Telemetry is a complete performance visualization system designed to help your entire team understand and optimize your game. Instead of just focusing on the low level aspects of a single frame or even scope of execution, Telemetry shows you everything that's going on, over the duration of your game, so that you can fix intermittent performance problems (hitches and spikes). Get the whole team involved -- optimization isn't just for programmers anymore! Graph in-game variables and see how they correspond to performance -- now when there's a spike in frame time your artists and designers can look at in-game variables and see what may have triggered performance problems.
Spot Spikes in Performance
Identify areas for optimization by quickly identifying hitches in performance. The timeline view shows frame time horizontally and vertically so you can rapidly focus on situational hot spots. While traditional profilers can tell you the total time you're spending in certain functions or areas of execution, Telemetry can tell you when you're slow, not just that you're slow! Smooth out frame rate glitches once and for all!
Visualize Thread Relationships
In today's multithreaded, multicore world, programmers must be able to debug and optimize thread interactions effectively. Telemetry graphically demonstrates how your threads are working in relation with each other. Spot idle areas, lock contention, stalls, and context switches. Is one thread stalling for milliseconds at a time fighting over a shared resource? Are you churning a single lock far too much? Are some of your threads sitting idle when they should be working? Telemetry can answer many of these questions for you!
Visualize Execution Flow
Telemetry's hierachical view of program zones clarifies your program's execution path. See who is calling whom, when, and for how long. Unlike traditional profilers, Telemetry lets you see not just time spent in areas, but the relationship between those areas in time.
Telemetry displays memory events on their own track, enabling you to spot problematic memory usage patterns. By hovering over a memory event, you can see where it took place (file/line), the zone in which it occurred, the name you gave it, its size, and its associated free or allocation.
Graph Game Data
Graph game specific variables with Telemetry's easy to use plotting API. Visually correlate the relationship between your game state and overall performance. Tag the values with type information and the Telemetry Visualizer will event present that data in the appropriate format (float,hex,memory size,time,etc.).
printf-style Logging API
Send printf-style messages to the server for later review. You can identify messages as log messages, warnings, or errors. Optionally place event markers along the top of the zone view for easy tracking. Show only the specific message classes you're interested in with our path-like classification system.
Message output within a zone is displayed as part of that zone's tooltip.
Profile to a Local Machine or Network Server
Telemetry uses a client-server architecture -- data is sent from your game to a server that is responsible for storing and processing the profile data. Of course, that server can be run on your own machine, but it can also be run on a separate machine depending on your needs.
Store and Render Your Own Binary 'Blob' Data
Telemetry measures and transmits those things it knows about, but in some cases you may have custom proprietary data that you'd like to visualize alongside Telemetry's own. For this reason we've provided a custom binary object ("blob") API that lets you send opaque data to the server. By writing a custom Visualizer plugin, you can then display this proprietary information on its own dedicated track. Common uses include sending screenshots, custom internal hardware information, and so on.
Watch Context Switches on Windows and 360
Under Windows 7 (and Vista) and on XBOX 360 Telemetry can capture and display thread activity per core/hardware thread. Now you can clearly see which threads are running on which cores. Identify idle or parked cores. Find out which background tasks are taking up valuable computing cycles.
How it Works
All this is accomplished by instrumenting your application with markup that defines zones of execution (for example, function calls), memory events, thread names and so on. The markup is simple, easy to integrate, and goes away by defining NTELEMETRY=1 and recompiling.
Once your program is instrumented, you just run it and start capturing data. You can review this data in real-time or save it and look at it later.
Telemetry's overhead is minimal and predictable. We use only the memory you give us -- we don't do any memory allocation ourselves -- and the performance overhead is proportional to the amount of data generated. In addition, most of Telemetry's processing is done on a background thread when possible, thus minimally impacting your own game's main thread performance.
Telemetry is focused on ease of use, ease of integration,and minimal impact on run-time performance and memory usage.
Telemetry has run-time support for Nintendo WiiU, Microsoft XBOX 360, Sony PS3 (PPU and SPU), Windows XP SP3 and later (32 and 64-bit), Linux (x86, x64, and ARM), iOS, and OS X 10.6+ (32- and 64-bit, Intel only). The Visualizer is available for Windows, OS X, and Linux, and the command line server is available for Windows (64-bit), OS X (64-bit), and Linux (64-bit). If you are capturing and analyzing on the same system that is running your game, we highly recommend a quad core system with plenty of RAM.