Superlumial

What is Superlumial?

RESOURCES

Supported platforms and languages

Superluminal currently supports profiling apps on Windows and Xbox One, written in C++. It is also intended to support PlayStation 4, Rust and .NET in the future

Built for scale

Superluminal was built to scale from the very beginning. You can record a few frames of data or a few hours of data. Superluminal will remain stable, with little memory usage, while showing its profiling data in a smooth and fast 60 FPS user interface. Want to see CallGraph data for a specific part performing poorly on the timeline? Select a time range in the timeline view and all views will be filtered to that specific section in constant time – whether you're selecting the entire interval or a second somewhere in the middle of a large capture.

Visual UI

Traditionally reserved for profiling instrumentators, Superluminal is the only sample profiler that displays profiling data in a visual interface. The sampling data is displayed on a timeline, which allows you to see exactly, by threading, which function is being called when, what functions are being called around it, and in what order. This provides an unprecedented understanding of what's happening in your program; understand not only what is being called, but more importantly, why it is being called. Obviously, like everything in Superluminal, the UI is built to scale – it will remain smooth all the time, regardless of the amount of data captured.

Sampling

Superluminal is a sampling profiler. This allows you to hit the ground running without the need to make modifications to the code. After installation, you will collect performance data quickly. A powerful property of sampling is that it allows you to capture data from all the code running on the system, not just yours. System processes, third-party code, all included.

High frequency

Most profilers sample 1 KHz, which isn't very useful if you're working on high-performance apps like games that need to run at 30 or 60 FPS. On the other hand, Superluminal has a high-frequency sampling engine, which samples at 8 Khz (Windows) or 10 kHz (Xbox One). The high sampling frequency allows you to capture all the interesting work that's happening in your app.

Multithreading analysis

Superluminal has first-class support for the analysis of modern, highly parallel applications. Understanding the complex interactions between threads in a program can be essential to solving performance issues. These complex interactions are visualized in an intuitive interactive interface that allows you to inspect stacks of lock and unlock calls and easily navigate between them.

Context Options

It's easy to see at a glance what the state of a thread is at any given time – running or waiting. The standby states are even more colorful so you can visually distinguish the different types of standby. This makes it easy to identify when the thread is waiting for a lock, when it has been anticipated by the operating system, and by many other different wait states.

Filtering

Superluminal is able to isolate a specific portion of a capture. This is a powerful feature to investigate an unexpected spike in performance in your capture, or to display only a certain section of the capture, such as the application launch code or the unexpected interruption when a button was pressed. This filter is created by dragging a time selection into the timeline view. All visualizations, such as call graph, simple list, and source code view, will use the filter. Like everything in Superluminal, this was created for scale - filtering happens in constant time.

Find

Superluminal supports capturing profiling data for an arbitrary period of time. To help you navigate through profiling data, Superluminal has a Find function, which you can use to find any function you want. When you find a function, the search results are displayed prominently on the timeline. This makes it easy to quickly see where your function is being called. In cases where the function you are interested in is called from multiple segments, you can select only the segments in which you are interested.

Sourcing and Disassembly

The source window displays the source code along with the time-per-line and thread state information. To dig even deeper, a mixed-mode disassembly view lets you display time information per instruction. If no source code is available, the disassembly is displayed.

Instrumentation

While the sampling engine offers unprecedented accuracy right away, sometimes you just need that little extra. Through the use of instrumentation, you can add more precision and context when needed. Instrumentation data is fully integrated into all views, including the timeline.

Instrumentation API

The API allows you to instrument the relevant code in your application. This can be useful for improving accuracy when needed, or adding contextual information such as a file name, size, or ID to an event.

Visual graphic

Instrumentation times are a powerful way to quickly see average and maximum performance behavior. A typical example for real-time rendering applications is that of a single rendering frame. When you click on an event on the chart, all other visualizations navigate to the corresponding instrumentation event, allowing you to investigate in more detail.

System Requirements

Available for Windows and Xbox One