Telemetry is a complete performance visualization system designed to help your entire team understand and optimize your software. 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 the lifetime of your application, so that you can fix intermittent performance problems (hitches and spikes). Get the whole team involved—optimization isn't just for programmers anymore! Graph data and see how it corresponds to performance—now when there's a spike in frame time your content authors can look at the plots and see what may have triggered performance problems.
The Telemetry 3 visualizer can handle tons of data with ease. The visualizer is just as smooth and interactive with 1 million zones or 100 million zones.
Telemetry 3 vividly displays profiling information while your program is running. The moment you sense a performance dip, Telemetry can show you where the time went!
Locks and Contention
Managing locks is a complex task. With Telemetry, you can easily see which threads are holding locks, and which threads are waiting on locks. Mousing over a "wait" zone will flash the thread holding the lock and causing the stall. The Telemetry Visualizer makes lock contention very clear, so engineers can focus on solutions that will actually make a difference.
Capture Context Switches
Multi-core programming is complicated, but Telemetry helps reveal what's happening on every core. With context switch tracking, it's easy to see when your threads are (or are not) running. See when your threads are jumping from one core to another. See when another process is stealing cycles.
Full Text Search
Telemetry 3 features full text search to find that needle in the haystack. Isolate your search by thread. Sort results by duration. It makes it trivial to do things like find the longest zone with "shadow" in the name on the render thread.
Plots are values over time, and they can be viewed in the Plot View or as independent tracks in the Timeline View. Plots are useful for spotting trends in your program (e.g. how much memory is used, how many triangles are visible, etc.).
Profile to a Local Machine or Network Server
Telemetry uses a client-server architecture—your program sends data 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.
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.
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 Microsoft Windows/XBOX One; Sony PS4; Linux (x86, x64, and ARM); and Android. The 64-bit Visualizer and command line server are available for Windows. If you are capturing and analyzing on the same system that is running your application, we highly recommend a quad core system with plenty of RAM.