The Launch tab enables launching applications for analysis. This is where you will add the basic process information to launch and subsequently connect to the application you wish to analyze.

This tab has the following controls:

Application Executable - Specifies the root application to launch. Note that this may not be the final application that you wish to analyze; see this section on how to launch different types of applications.

Working Directory - The directory in which the application will be launched

Command Line Arguments - specify the arguments to pass the application executable.

Environment - the environment variables to set in the launched application

Automatically Connect - specifies whether the launched application should be automatically connected to. If the launched application is a launcher that creates the process that you ultimately wish to analyze, set this to 'No'.

To attach to an application, it must have previously been launched through the launch tab. This page will list the launched application as well as any children that the application has launched.

NVIDIA Nsight Graphics allows for adjusting the activity with a large set of options. Options are available in the Connect window under the Additional Options section. These options are saved per-project, and per-activity, because the options for one activity may not relate to the other. Note that you may need to apply them to multiple activities if your needs for each activity are the same.

The Application HUD is a heads-up display which overlays directly on your application. You can use the HUD to capture a frame and subsequently scrub through its constituent draw calls on either the HUD or an attached host.

All actions that occur either in the HUD or on the host — such as capturing a frame or scrubbing to a specific draw call — are automatically synchronized between the HUD and the host, and thus you can switch between using the HUD and host UI seamlessly as needed.

The HUD has three (3) modes:

1. Running: Interact with your game or application normally, while the HUD shows an FPS counter. When you first start your application with NVIDIA Nsight Graphics, the HUD is in Running mode. This mode is most useful for viewing coarse GPU frame time in real-time while you run your application.

2. Activated: Once activated (using the activation hot-key toggle), the NVIDIA Nsight Graphics HUD allows the pause and capture of a frame from the running application.

3. Frame Debugger: Once you have captured a frame, you can debug the frame directly in the NVIDIA Nsight Graphics HUD (as well as from the host). The HUD allows you to scrub through the constituent draw calls of a frame, to view render targets with panning and zooming, and to examine specific values in those render targets.

The API inspector is a common view to all supported APIs that offers an exhaustive look at all of the state that is relevant to a particular event to which the capture analysis is scrubbed.

To access this view, go to Frame Debugger > API Inspector.

To access this view, go to Nsight > Windows > API Inspector.

While the view is common, the state within it is particular to each API. See the section below that relates to your API of interest.

The API Statistics View is a high-level view of important API calls, and includes information to help you see where GPU and CPU time is spent.

To access this view, go to Frame Debugger > API Statistics.

To access this view, go to Nsight > Windows > API Statistics.

The Current Target view is used to show the currently bound output targets. This can be useful because it focuses in on the bound output resources, rather than having to search for them in the Resources view.

To access this view, go to Frame Debugger > Current Target.

To access this view, go to Nsight > Windows > Current Target.

Current Target will display thumbnails along the left pane for all currently bound color, depth, and stencil targets. This view will change as you scrub from event to event. All of the thumbnails on the left can be selected to show a larger image on the right. You can also click the link below each to open the target in the Resources View.

The Geometry view takes the state of the Direct3D, OpenGL, or Vulkan machine, along with the parameters for the current draw call, and shows pre-transformed geometry.

To access this View, go to Frame Debugger > Geometry.

To access this View, go to Nsight > Windows > Geometry View.

There are two views into this data: a graphical view and a memory view.

The Range Profiler is a powerful tool that can help you determine how various portions of your frame utilize the GPU, and give you direction to optimize the rendering of your application. Once you have captured a frame, the Range Profiler displays your frame broken down into a collection of ranges, or groups of contiguous actions. For each range, you can see the GPU execution time, as well as detailed GPU hardware statistics across all of the units in the GPU. The Range Profiler also includes unmatched data mining capabilities that allow you to group calls in the frame into ranges based on various criteria that you choose.

To access this view, go to Frame Debugger > Range Profiler.

To access this view, go to Nsight > Windows > Range Profiler View.

Note that the legacy Range Profiler, that is not user configurable, is still available. From the same menu, simply select Range Profiler (Legacy). This will be removed in a future release.

The Range Profiler initially appears with the Range Selector at the top, followed by 5 default sections below that: Range Info, Pipeline Overview, SM Section, Memory, and User Metrics.

Note:

Under certain conditions, the Range Profiler pane may be disabled and display one of the following messages. Hardware signals are not supported in this configuration This message could be due to one of the following reasons: You are running NVIDIA Nsight Graphics with a Kepler or lower GPU. You are using a defunct or non-NVIDIA GPU. You are attempting to profile an application with a debug or validation layer enabled. No hardware signals found for this API/GPU combination This message is likely to occur when you are running NVIDIA Nsight Graphics on a non-MSHybrid laptop.

Identifier: "Name"
DisplayName: "Name"
Order: 100
Header {    
    Metrics {	
        Label: "L2 SOL"	
        Name: "lts__throughput.avg.pct_of_peak_sustained_elapsed"
    }
Body {    
    Items {	
        Table {	    
            Label: ""	    
            Rows: 1	    
            Columns: 2	    
            Metrics {		
                Label: "SM Active"		
                Name: "sm__active_rate"	    
            }
            
            Metrics {		
                Label: "SM Warp Can't Issue Allocation"		
                Name: "smsp__warps_cant_issue_allocation_stall_per_warp_active.pct"	    
            }
        }
    }
}

The NVIDIA Nsight Graphics Frame Debugger has two parts. One part appears as the Frame Debugger window on the host. The other part appears as a Heads-Up Display (HUD) on the target application.

To access this view, go to Frame Debugger > Scrubber.

To access this view, go to Nsight > Windows > Scrubber.

The part of the Frame Debugger that appears as a HUD on the target machine is comprised of the following:

• HUD Toolbar — controls the frame capture, along with a number of other options (help, etc.).

• Frame Scrubber — indicates the current draw event. There is a scrubber view in the Frame Debugger on the host, as well as a frame scrubber on the HUD. The frame scrubber controls stay in synch with each other, meaning that when you move the controls on one, it affects the other. For example, if you move the frame scrubber on the HUD to highlight a new draw event, the scrubber on the Frame Debugger moves in synch to do likewise.

Understanding the Frame Scrubber

For the sake of discussion when it comes to graphics debugging, it helps to note some common terminology.

• An event is a single call to the API. It could be a triangle draw call, or backbuffer clear, or a less obvious call, like configuring buffers. A snapshot is a sequence of events.

• An action is a subset of the event types. It can be one of the following: (1) Draw Call, (2) Clear, or (3) Dispatch. Actions are interesting since they explicitly change data which may result in visual changes.

When you debug your graphics project, the Scrubber window shows the perf markers you implemented. When working with user-defined markers, the Scrubber window will use the color and label that you defined for the perf marker.

On the Scrubber, you can select one performance marker and it will automatically create a range of all of the draw calls that occurred within that time frame. Clicking on it again will cause the scrubber to automatically zoom to that range of events. You can zoom in on a nested/child marker the same way.

To zoom out, click the parent performance marker, or use CTRL + mouse wheel.

Performance markers are also displayed on the HUD, color-coded the same way that they are on the Scrubber. However, on the HUD, the information is condensed, and you must hover your mouse over the selected performance marker to get its details.

The default view will show the events in your application, in addition to any performance markers you have defined. Clicking the Add... button will open a dialog that allows you to select what type of range you want to add.

• Program Ranges — Actions that use the same shader program.

• Viewport — Actions that render to the same viewport rectangle.

• Alpha Blending Enabled — Actions that have alpha blending enabled.

• Alpha Test Enabled — Actions that have alpha test enabled.

• Back Face Cull Enabled — Actions that have back face cull enabled.

• User — A range defined by you on the fly. Use SHIFT + left-click and drag the scrubber on the created "User" row to create a new range.

Right-clicking on a specific action in the Scrubber will allow you to open the API Inspector for that action, change your view settings, or initiate a profile session with the Range Profiler.

The Resources View allows you to see all of the available resources in the scene.

To access this view, go to Frame Debugger > Resources.

To access this view, go to Nsight > Windows > Resources.

To open the Resources page, go to Frame Debugger > Resources. There are two tabs available here:

1. Graphical

2. Memory

At the top of the Resources view, you'll find a toolbar:

• Clone — makes a copy of the current view, so that you can open another instance.

• Lock — freezes the current view so that changing the current event does not update this view. This is helpful when trying to compare the state or a resource at two different actions.

• Save — saves the captured resources to disk.

• Red, Green, and Blue — toggles on and off specific colors.

• Alpha — enables alpha visualization. In the neighboring drop-down, you can select one of the following two options:

  • Blend — blends the alpha with a checkerboard background.

  • Grayscale — alpha values are displayed as grayscale.

• Flip Image — inverts the image of the resource displayed.

Below the toolbar is a set of buttons, described below, for high-level filtering of the resources based on type. Next to that, there is a drop-down menu that allows you to select how you wish to view the resources: thumbnails, small thumbnails, tiles, or details.

If you select the Details view, you can sort the resources by the available column headings (type, name, size, etc.).

int;      // creates a column with an anonymous int
int x;    // creates a second column with an int named x
float y;  // creates a third column with a float named y

struct MyType{ int x; float y;};
struct MyOtherType{ MyType z; double u; };

The Linked Programs View lists all of the shaders in your application.

To access this view, go to Frame Debugger > Linked Programs.

To access this view, go to Nsight > Windows > Linked Programs View.

• If the shader (or its parent program or pipeline object) hasn’t been used by the application yet, it will show up with the symbol in the Status column.

• If the shader has been used, selected statistics will be presented for that shader.

For programs or pipeline objects, you can view the individual shaders by pressing the ► button to the left of the program/pipeline name. When expanded, you can select the link to open a text view of the shader source (when available).

Name

This is the name of the shader. This name is either generated internally, or can be assigned by the user per API.

Type

The type of the shader: Vertex, Pixel, Compute, etc.

Status

This column displays the current status of the shader. The status includes Source or Binary, to denote whether or not source code is available for this shader. Also, if the µCode text is included, this means that we have driver level binary code that is necessary for gathering shader performance metrics.

The symbol means that we are waiting for the shader to be bound by the application.

The symbol means that shader performance metrics are currently being computed.

Context

Indicates to which of the application's contexts this shader is owned. Shown on multi-context OpenGL applications, only.

Regs

This column gives the number of registers used by the program. Register count impacts occupancy/threads in flight. This may be not available for all shaders.

# Barrier

Indicates the number of barriers used by the shader. Shown on compute shaders only.

The Acceleration Structure View shows the geometry that has been specified in build commands when running an application that uses ray tracing APIs. If the application does not use these APIs, the view will not be available.

In Ray tracing APIs, such as DXR and NVIDIA Vulkan Ray Tracing, an acceleration structure is a data structure that describes the full-scene geometry that will be traced when performing the ray tracing operation. This data structure is described in detail in the following links:

https://developer.nvidia.com/rtx/raytracing/dxr/DX12-Raytracing-tutorial-Part-1

https://developer.nvidia.com/rtx/raytracing/vkray

This data structure is purpose-built to allow for translation to application-specific data structures that perform well on modern GPUs. While constructing this data structure, the developer has the responsibility of constructing the structure correctly and using flags to identify the functional and performance characteristics within it. Needless to say, this can be an error-prone operation.

Nsight Graphics Acceleration Structure Viewer allows you to view the structures you are creating, navigate through them, and see the flags that you are using. Additionally, you can filter and colorize the structure to highlight, at a bird’s eye view, different kinds of geometry.

To access this View, go to Frame Debugger > Acceleration Structure.

To access this View, go to Nsight > Windows > Acceleration Structure View.

Additionally, the Acceleration Structure Viewer can be opened from the API Inspector View when scrubbed to a build event trace rays call. When scrubbed to these events, the view will present a list of the active structures with a link to open each.

The view is multi-paned -- it shows a hierarchical view of the acceleration structure on the left, a graphical view of the structure in the middle, and controls and options on the right. With the hierarchy of the Acceleration Structure view, the top-level acceleration structure (TLAS), bottom-level acceleration structures (BLAS), child instances, and child geometries are presented. When a particular item is selected, the name, flags, and other meta-data for this entry are listed in a section on the bottom left-hand side. Each item within the tree has a check box that allows the rendering of the selected geometry or hierarchy to be disabled. Double-clicking on an item will jump to the item in the rendering view and automatically adjust the camera speed to be relative to the size of the selected object.

The VR Inspector view allows you to inspect how your application is using VR APIs. It will be available when an application is captured with a supported API. Supported APIs include Oculus (LibOVR) and OpenVR.

To access this view, go to Frame Debugger > VR Inspector.

To access this view, go to Nsight > Windows > VR Inspector.

Once opened, this view is context-specific to the VR API in use. See the sections below for a discussion on each API.

The additional features of an nsight-gfxcppcap file include:

1. Screenshot of the capture taken from the original application

2. Information about the captured application and its original system

3. Statistics about the captured API stream

4. Utilities to build the C++ capture without opening the generated Visual Studio project

5. Utilities to launch the compiled application:

   1. The Execute button will launch the compiled executable.

   2. The Connect... button will populate a new connection dialog that allows you to run a specific activity on the generated capture.

6. User comments that are persisted within this file.

At the left top of the Scrubber view, there are 3 buttons that extend the Scrubber's capabilities.

1. Ruler Relative: Controls the Zero point of the ruler. This can be:

   • Capture: Zero is when the capture begins.

   • Viewport: In this mode, if you select a regime and expand it, the beginning of the selected regime will be the beginning of the regime.

   • Cursor: Zero is where the mouse is.

2. Trace Compare: See Trace Compare.

At the right top of the scrubber view, there are the zoom buttons. These buttons may assist in navigating the scrubber to the desired regimes.

1. Start / End: Mark down the exact time for you start and end selection

2. Reset Zoom: Will reset the Scrubber zoom for the entire capture.

3. Zoom to Selection: Will zoom to the selected regimes. For multiple markers selectoin: Select multiple markers using mouse left-click + ctrl .

The Metrics Data Rows can track NVIDIA GPU hardware units' activity using performance monitors. In this version of the GPU Trace, we enable you to capture this data and observe in detail the hardware utilization during the frame execution

When hovering your mouse over the Scrubber, a tooltip appears that displays the average of the metrics data per the selected time. The data is sorted from high to low.

The Information Tabs section provides general information on the capture, and also provides an additional view on the metrics data that were captured.

It contains 4 tabs:

The Regime Table is applicable to the user markers that exist in the captured application. It summarizes the user markers' data and correlates with the Scrubber so it is easier to find a regime and understand its metric data.

The Trace Compare tool enables the GPU Trace user to easily analyze the effect of his code changes on a specific frame. It displays a simplified version of the GPU Trace time line for 2 frames. The frames are placed one on top of the other, with their start time aligned. Trace compare enables to compare either 2 frames from 2 different capture files or 2 frames within the same file.

Nsight Graphics framework enables launching an application with a specific set of command line arguments and / or environment variables. This is done via 'Connect to Process' dialog.

Below are special pre-defined environment variables: