User Guide

  • 2021.1
  • 03/24/2021
  • Public Content
Contents

Run Render State Experiments with System Analyzer

Use the override modes provided by System Analyzer to identify performance bottlenecks without modifying the code.
With the System Analyzer and System Analyzer HUD, you can perform "what if" experiments (also known as overrides) of various portions of the graphics pipeline to isolate one or more performance bottlenecks in your application. Override modes provide a method for high-level performance analysis and visual debugging. Performance-related state overrides allow you to find high-level bottlenecks using subtractive analysis.
Override modes operate in the background within the graphics driver to modify one or more of the render states of the graphics pipeline. Using these overrides, you can perform quick "what if" experiments on various portions of the graphics pipeline without requiring any code changes in your game to isolate one or more performance bottlenecks in your application. If using a certain override mode improves performance significantly, then that overridden mode might be a performance bottleneck, and warrants further analysis.
For example, the
Null Hardware
override simulates an infinitely fast GPU. If using this override significantly increases your FPS, your game is limited by the GPU.
Other overrides can help isolate where in the rendering pipeline your bottlenecks are: try out
Texture 2x2
to see whether your textures are causing memory bandwidth issues ("thrashing"), or
Simple Pixel Shader
to check if your shader code is too complex. To use an override, follow this procedure:
  • System Analyzer HUD:
    1. While your game and the System Analyzer HUD are running, use
      Ctrl+F1
      to cycle through the HUD display modes until you see the list of keyboard shortcuts available.
    2. Use one of these shortcuts (such as
      Ctrl+Alt+H
      to use
      Null Hardware
      ), and check whether the FPS improves.
  • System Analyzer:
    To apply an override mode, select it from the
    State Overrides
    pane.
    Only one of these modes can be enabled at a time.

Disable all, Null Hardware, and Disable Draw Calls

Use the
Disable all
option to disable all override modes. Use this option to reset the rendering state of the game or graphics application back to the default state.
The
Null Hardware
override emulates an infinitely fast GPU by not sending any primitives to the GPU. This override is only available on systems using Intel® HD Graphics.
  • To enable the
    Null Hardware
    override, enable the
    Null Hardware Override Support
    toggle button in the Graphics Monitor
    Options
    screen.
  • You can apply the
    Null Hardware
    override mode only to the most recent application opened for analysis. To apply this mode to an application opened previously, restart this application from the Graphics Monitor. For example, if you start the CityRacer application while the gpasample application is running, you can apply the
    Null Hardware
    override mode only to CityRacer. If you close CityRacer, you still need to restart the gpasample application to use this mode.
The
Disable Draw Calls
override emulates an infinitely fast driver and GPU by not sending any primitives to the driver and, therefore, to the GPU as well.
On Intel® GPUs prior to Intel® HD Graphics 3000/2000, the
Null Hardware
override implementation requires that all GPU work is blocked causing the System Analyzer HUD to not update while
Null Hardware
is in effect. The display appears to "freeze" while
Null Hardware
is active. On more recent GPUs, this is no longer a requirement and the System Analyzer HUD continues to update while
Null Hardware
is active and you must manually toggle the override off.
Run these overrides iteratively, using
Disable all
between experiments. Compare frame rate results between experiments and analyze your results based on the following table:
Performance
Bottleneck
Disable Draw Calls
- no change
Null Hardware
- no changes
CPU bound in the application: use the Graphics Trace Analyzer or VTune™ Profiler to analyze game/CPU code
Disable Draw Calls
- improves frame rate
Null Hardware
- no changes
CPU bound in the driver: use the Graphics Trace Analyzer or VTune™ Profiler to analyze game/CPU code
Null Hardware
- improves frame rate
GPU bound: use the Graphics Frame Analyzer to analyze the issue
Use the set of
Disable all
,
Null Hardware
and
Disable Draw Calls
to determine if the game is CPU bound in the application, CPU bound in the driver, or GPU bound. If your application is GPU-bound, you can capture a frame with a low frame rate for a detailed analysis with the Graphics Frame Analyzer. If your application is CPU-bound, you can use the Graphics Trace Analyzer to show how the various CPU tasks within your application are being executed.

Show Wireframe

Use the
Show Wireframe
override mode for visual debugging or to visualize a high concentration of geometry primitives in the scene.
Show Wireframe
can help you identify how many redundant geometry items are drawn to the scene. This override is different from other override modes, because it can help you understand how you can improve performance rather than to determine whether game performance improves.
For example, through visual inspection you might see that you are rendering a large number of very small graphics primitives, which is relatively expensive compared to the level of detail that they provide in the scene. Visual inspection might also highlight unintended primitives being rendered. If either of these is the case, consider using a bump map, texture map, and/or other level-of-detail optimizations to improve the rendering speed of the application. However, it is possible that some other item, such as a very complex pixel shader, is causing the slowdown. In this case, you may need to analyze your scene with other override modes to better understand your performance bottlenecks.
Normal Picture
Show Wireframe

Texture 2x2

Use the
Texture 2x2
override mode to identify potential performance bottlenecks caused by texture maps used in your application. All textures for a scene are replaced with four different colors for each pixel for these textures.
If using this override mode significantly improves the frame rate, this is an indicator that the application is texture bound. The common ways to fix this issue are:
  • Reduce the size of textures
  • Reduce the number of textures used in the scene, for instance use one texture for a set of objects
  • Reduce the texture filtering setting, especially minimize the usage of anisotropic filtering
  • Reduce the number of texture fetches in the shaders
Normal Picture
Force Texture 2x2

Simple Pixel Shader

The
Simple Pixel Shader
override mode replaces every pixel shader with one that writes a constant color to the render target.
If the frame rate shows a large increase with this override enabled, this is an indicator that the performance slowdown is due to pixel shader computation and/or texture performance. In this case, you should inspect your scene with the Graphics Frame Analyzer to identify and rework expensive pixel shaders to improve scene rendering performance.
Normal Picture
Force Simple Pixel Shader

1x1 Scissor Rect

The
1x1 Scissor Rect
override mode cuts pixel processing from a pipeline. If the frame rate does not increase after enabling this override, then a complex geometry or vertex shader is a bottleneck. In this case, you can use the
Show Wireframe
override mode to check whether the geometry is complex. If the geometry is not complex, then the vertex shader is the bottleneck.
However, the effect of this override mode is driver/graphics hardware vendor specific and depends upon whether scissoring on your device occurs prior to or after the pixel shader stage.

Disable Texture Filtering

Use the
Disable Texture Filtering
override mode to determine whether the texture filtering algorithm is a bottleneck. Texture filtering allows you to interpolate (filter) the color of a textured object if the distance between two neighboring texels is more than one pixel.
If the performance of an application improves after applying the
Disable Texture Filtering
technique, then the texture filtering algorithm might be a bottleneck. It may be the result of using computationally expensive texture filtering, such as high-level anisotropic filtering.
Depending on your speed versus quality requirements, consider a faster texture filtering method. Since anisotropic filtering is the slowest method, consider the use of bilinear, linear, or even nearest-point filtering. You can test the performance and visual effects of different filtering methods by modifying the graphics state of primitives without changing any application code.

Disable Z-Test, Disable Z-Write

Use the
Disable Z-Test
and
Disable Z-Write
override modes to help determine whether your application is encountering potential performance issues due to Z-buffer operations.
In the viewing pipeline, 3D data is projected onto 2D screen space; a Z-buffer stores the z-coordinate of the object used to render each pixel in 2D space. Z-testing, also known as depth testing, typically rejects attempts to render into a specific pixel if the z-buffer value of a new rendering pixel is farther away from the viewer than the current depth value stored in the z-buffer.
The
Disable Z-Test
override mode does not perform any Z-buffer comparisons. If you use the
Disable Z-Write
override mode, the result of the depth comparison is not stored in the Z-buffer.
Normal Picture
Disable Z-Test
Disabling Z–test and Z-write renders all objects in a sequential order independent of their closeness to the viewer, and reveals some objects that are otherwise hidden.
If these modes significantly improve performance, you may be able to increase your frame rate by using some other culling technique prior to the Z-buffer test in the pipeline. Also, performance might be improved by drawing closer objects first, so that the Z-buffer test can reject further objects before these primitives pass through the entire rendering pipeline.

Cull None, Cull Clockwise, Cull Counter-Clockwise

Usually, an application uses a consistent orientation for all graphics primitives. This orientation may be clockwise or counter-clockwise, depending on the order of vertices. This orientation determines the view normal of each primitive, and this normal determines whether the primitive is forward- or backward-face oriented with respect to the viewer or camera - typically backward-facing primitives are not rendered. Use of these override modes may help uncover errors in how you have defined the orientation of primitives in the scene.
Use the
Cull Counter-Clockwise
or
Cull Clockwise
override modes to remove the rasterization of all triangles oriented to the camera or turned away from the camera correspondingly. The culling mode applied to a geometry having an opposite orientation order of primitives reveals internal sides of that geometry because all front-faced primitives become invisible.
Use of the
Cull None
override mode usually has no visual effect but may decrease application performance because both visible and invisible primitives are rasterized. When using this override mode, Graphics Frame Analyzer disables culling so all primitives are rendered, independent of whether they are clockwise or counter-clockwise-oriented.
Certain games use a full-screen quadrangle with the render target texture to expose the frame. If you apply the
Cull Clockwise
state override to such games, certain triangles will not be written to the back buffer and you will see blinking of the screen. This is the result of swapping the front buffer with old content and the back buffer with cleared content (commonly referred to as a "Swap Chain").

Disable Alpha Blending

Use the
Disable Alpha Blending
override mode to find out whether blending may be a performance bottleneck.
If applying the
Disable Alpha Blending
override mode significantly improves performance, try to reduce the number of transparent objects in your scene and/or consider other techniques for pre-calculating these visual effects.
Normal Picture
Disable Alpha Blending

Disable Alpha Test Windows

Use the
Disable Alpha Test
override mode to understand the performance impact of testing each pixel's alpha component. Performance may increase because at least the same number of pixels will be rendered, but may decrease because alpha blending may be enabled to blend pixels that were rejected by the alpha test.
  • The Disable Alpha Test override mode might cause rendering artifacts to appear, especially if the scene uses textures or other techniques that would not be rendered due to failing the alpha test.
  • This override is available only for Microsoft DirectX* 9. For Microsoft DirectX* 10 and Microsoft DirectX* 11 applications you should use the
    Simple Pixel Shader
    feature to get similar results.

Overdraw Visualization

Use this override mode to visualize the overall complexity of your scene, highlighting potential areas to investigate for optimization. If a scene renders only a few objects, the amount of overdraw is usually low and no further optimization is required. If a scene has many overlapping objects, or objects with semitransparent textures (such as smoke, fog, or water), this typically results in a high load on the graphics card and therefore lower frame rates.
The
Overdraw Visualization
mode fills the frame buffer with a brightness value according to the number of times each pixel is drawn. The brightness of a pixel indicates the number of times each pixel was "touched" by a draw call or clear call. The lighter the pixel, the more times that pixel has been overdrawn, which typically means the relative cost of rendering that pixel is fairly high. Conversely, darker pixels indicate relatively efficient rendering. Bright areas of the screen may provide optimization opportunities such as culling primitives prior to rendering them, altering the draw order (so that z-buffer tests will reject many primitives prior to rendering them with an expensive pixel shader), or using other level-of-detail optimizations that simplify the complexity of the scene.
If the overdraw value in one or more areas of the scene is high, use the Graphics Frame Analyzer with the
Pixel History
feature with overdraw mode enabled - this can help you understand which events are being rendered into each pixel and help pinpoint optimization opportunities.
The current implementation may not take into account overdraw in off-screen render target surfaces, if such surfaces are used as a texture with a non-full screen quad draw call. However, if an off-screen render target is used as a full screen quad, all accumulated overdrawn pixels will be visualized.
Normal Picture
Overdraw Visualization

Product and Performance Information

1

Performance varies by use, configuration and other factors. Learn more at www.Intel.com/PerformanceIndex.