pane displays the sequence and duration of captured events in graphical format. You can adjust the manner of displaying events by using the Visualization Settings
Erg Graph and Render Targets Graph
Graphics Frame Analyzer supports the following views of the bar chart:
- shows metrics associated with each erg
Render Targets Graph
- shows metrics associated with sets of ergs, grouped by render target.
On traditional rendering architectures, you can toggle between the two views.
On tile-based rendering architectures, only the
is available. This is because work is processed in batches, and per-erg metrics are not meaningful in tile-based rendering.
Each bar on the
corresponds to a set of contiguous ergs drawing to a single render target. The boundaries between bars are defined by when the application switches render targets.
Bars on the
can be of three colors:
Blue bars - represent render targets in which no erg is selected
Yellow bars - represent render targets in which all ergs are selected
Dark yellow bars - represent render targets where at least one, but not all ergs are selected
To select render targets (and all of the ergs that they contain), use
on the bars. Selected render targets are represented by blue regions:
An erg is any item in the frame that potentially renders pixels to the frame buffer, such as "draw" calls or "clear" calls. Once you load the capture file, ergs are visualized as vertical bars, which can be of one of the following types:
Draw Call (colored Dark Blue)
Surface Copy (colored Red)
Dispatch Call/DirectCompute ergs (colored Orange), shown below:
Ergs are shown in chronological order starting from the left. If the "GPU Breakdown" metric is selected, each erg bar consists of the following parts:
Dark Blue/Purple/Red part stands for erg type
White part stands for Vertex Shader Time
Dark Gray part stands for Geometry Shader Time
Black part stands for Pixel Shader Time
By default, the height of the erg bar indicates the duration of the erg execution on the GPU.
To get information on an erg and GPU duration, put the cursor on a required erg, as shown in the figure below. GPU time is measured in microseconds.
Ergs are grouped into regions
: ergs written to the same render target appear in the same region. This matches the information provided in the
When analyzing a game that includes multiple D3D devices, the Graphics Frame Analyzer only displays ergs associated with the first device encountered in the stream of DirectX* calls in your capture file. However, when running experiments, the Graphics Frame Analyzer still renders all ergs for all D3D devices. Since Graphics Frame Analyzer displays total rendering time on a per-region basis, the total rendering time for each region is accurate if you interleave calls to all D3D devices within a region. However, Intel® GPA may not capture all of the rendering time when you render to the other devices outside the regions defined by the first device.
When the Graphics Frame Analyzer renders a frame, it performs multiple rendering passes on the selected ergs, and displays the minimum and maximum rendering time for each erg.
The red bars associated with each erg provide a visual representation of three things:
Variance - indicated by the red bar height
Minimum value - indicated by the bottom line of the red variance line
Maximum value - indicated by the top line of the red variance line
A frame is subdivided into regions displayed in a light gray color and separated by thin white lines.
Regions are delineated by the shading of the chart’s background.
Regions are generated when:
A new render target is used; such regions are delineated when the graphics application is drawing to something new.
A new portion of the scene, defined by
() API calls, is created. This isolates the work for specific portions. For example, if the
() API calls define the "Drawing a car" portion, the work for the various parts of the scene used in car drawing is easily grouped and analyzed.
calls can be nested, regions can be also nested. The region color corresponds to the level of nesting, and cycle through light gray, medium gray, and dark gray:
levels 6 and greater = dark gray, light gray, medium gray, ...
The following code shows a sample of nested
D3DPERF_BeginEvent(<color>, L"Draw Car");
D3DPERF_BeginEvent(<color>, L"Draw Car Body");
D3DPERF_EndEvent(); // end of car body drawing
D3DPERF_BeginEvent(<color>, L"Draw Car Wheels");
D3DPERF_EndEvent(); // end of car wheels drawing
D3DPERF_EndEvent(); // end of car drawing
On the bar chart, vertical orange lines between ergs serve as markers.
A marker is an event that you can include to denote that something has happened, such as "Finished Drawing Trees." As a marker is not something that the graphics hardware processes; markers do not have metrics associated with them.
Graphics Frame Analyzer supports the following events and markers:
int D3DPERF_BeginEvent(D3DCOLOR col, LPCWSTR wszName)
void D3DPERF_SetMarker(D3DCOLOR col, LPCWSTR wszName)
For information on these APIs, refer to the Microsoft* DirectX* SDK documentation.
For information on how these APIs can be seen in the Graphics Frame Analyzer, refer to the Visualization pane
To set a marker, use the
API in the Microsoft* DirectX* code. The following code shows an example:
D3DPERF_SetMarker(<color>, L "My marker ");
If the number of ergs exceeds the GUI current width, a horizontal scroll bar appears.