Plot enhancements

One of the most powerful elements of Telemetry is the ability to plot arbitrary game data and see how it correlates to performance. While the plots are great already, we do think that they can and should be better and have been talking to customers about what new features they'd like to see.

Some features up for discussion and possible implementation in the coming weeks and months include:

• discrete plot events. Instead of just assuming that plot events are somehow related, handle each sample as a discrete, independent event, generating a scatter plot instead of a line chart.
• plot limits/budgets. Set plot min/max values that generate flashing text, warning colors, etc. on the Visualizer if those limits are broken. Hovering over the plot would draw horizontal lines showing the budget(s) set. This way you can set resource budgets for your artists and they'll be able to spot them easily.
• Visual enhancements such as better contrast/rendering.

So what are your thoughts? Feel free to post here or drop me an email!

Telemetry/PS3/PPU is up

Telemetry now passes its basic tests on PS3/PPU. It may take a while to achieve feature parity with 360 (e.g. context switches and thread cycle times) but the important thing is that it will at least hopefully be available relatively soon. Now we have to address performance and features.

More message improvements

Minor things, but every little bit helps:

• memory and plot events generate virtual messages in the message window in the generated message group "telemetry/events/XXX". It's a quick and easy way to get a dump of plot and memory events until we get the export feature done.
• virtual messages are colored so they're easy to tell apart from other messages
• virtual messages can be filtered away just like other messages
• user messages (via tmMessage) can be masked off as well with a new checkbox
• the "Warnings" and "Error" checkbox labels are color coded
• "Copy/Save To File" messages now have timestamps prepended

We'll get search/filtering done "soon" once we figure out the ideal UI for it (some people want to search, others want incremental filtering, etc.)

tmEnterThread and tmBeginTimeSpanAt APIs added!

By request from a couple customers we've added two variants of existing APIs. tmEnterThread/tmLeaveThread let you manually specify your thread IDs, thus giving support for logical threads. This is handy if you have a single thread for something like AI but you want to visualize different subtasks/coroutines/fibers individually.

The other API addition is the ability to pass a specific time value to tmBeginTimeSpan and tmEndTimeSpan via the tmBegin/EndTimeSpanAt variants. Now you can measure an event indirectly, such as a GPU fence, and see it on the timeline.

Road map for Telemetry

One of the advantages of RAD Game Tools is that we're highly customer responsive and have a very aggressive release schedule. New features, optimizations, and bug fixes are rolled out at a very fast rate, usually at least once a month and often times a couple times a month.

After GDC we got a lot of good information from new and potential customers, and based on their feedback I wanted to mention what our tentative road map is looking like.

• Summer: PS3 support for PPU. We may have a beta of this as soon as April, but no promises. It's our highest priority major feature.
• Late Summer: basic GPU support on Windows and 360, at the very least allowing you to identify how long a command buffer took to execute and to visualize overlap with your CPU threads.
• Early Fall: PS3 support for SPU. The major issue is that all of our cool features do require space on the SPU, and most PS3 developers don't want to give up any room on their SPUs!
• Fall: deep memory visualization. The current memory stuff is very simple and just tracks allocations and frees, but we want to go crazy and do for memory everything we've done for performance. Fragmentation maps, current usage tree maps, multiheap support, and more!
• Winter: significant architectural changes on the back end with the goal being to remove the entire concept of hard coded frames. Instead we'd like you to be able to define arbitrary 'framesets' so you can refactor the zone view however you'd like, by 'render ticks', 'game ticks', 'physics ticks', etc. Getting this in place opens a huge host of opportunities.
• Winter+: continuous integration, regression testing, and visual diff support

Of course, during all this we'll be implementing lots of small features, polish items, customer requests, bug fixes, and optimizations, and if a new platform gets a lot of requests we'll support it as well. But barring stuff like that this is our current road map if anything changes I'll try to post about it here.

1.0i has shipped!

Telemetry 1.0i is out the door with a host of fixes and enhancements:

• new plots generates automatically showing number of context switches and current telemetry buffer size
• context switch background processing optimized significantly on Windows
• networking back end much faster and trickles data, avoiding network backups under extreme frame rate (500fps+) situations

The Visualizer also got some improvements:

• minimized tracks now stack vertically if they run out of room horizontally
• message window revamped so that it's faster and better looking (can handle millions of messages now)
• significant speed up to lock rendering
• fixed crash bug for certain windowed generated plots
• fixed memory corruption error if there were more than 32K plot points in a single plot
• non-idle, non-system processes in the context switch track are now rendered in light gray so you can tell them apart from 'system idle'