ADC Home > Reference Library > Technical Q&As > Graphics & Imaging > OpenGL >

OpenGL Driver Monitor Decoder Ring

Q: What do the parameters in the OpenGL Driver Monitor actually represent?

A: The OpenGL Driver Monitor provides insight into the operation of the Graphics Processing Unit (GPU) and its interaction with the Central Processing Unit (CPU). Quantities are reported for the selected GPU in the "Monitors" menu and apply to all operations associated with the GPU and its interaction with the CPU(s). Note that this reporting is inclusive of all applications using OpenGL during the period being monitored. You can use this information to determine where performance bottlenecks exist in their application and which device is the responsible for the bottleneck thus enabling optimization of data throughput between the GPU and CPU.

Available parameters can be selected for measurement by dragging the parameter from the parameter drawer to the parameter list in the Driver Monitor window. The available parameters are derived from the actual quantities measured by the GPU and as you might expect are not all equally useful for every scenario. Additionally, some quantities subsume the results from other measurements. These should be obvious from the descriptions provided, for example, commandBytes includes all quantities reported by command2DBytes, commandGLBytes and commandDVDBytes. The list below shows driver parameters available for examination by the OpenGL Driver Monitor.

Notes:
  • Data throughput is measured in bytes for the entire update interval, as set in Driver Monitor Preferences. Thus with the default one second update interval, data can be read as bytes per second.
  • All times are in nanoseconds. So one "giga-nanoseconds", or "1G" as shown on the graph, would represent about one second spent on a particular operation, or 100% of the time if the update interval is one second. If the update interval is changed in the Preferences, reported values are measured for the entire interval chosen and not normalized to a one second interval.
  • Counts are absolute, with values measured once per interval, thus will not be affected by the length of the update interval but may, of course, vary during the interval.
  • All CPU wait times are assumed to be waiting for the selected GPU operation to complete unless otherwise specified.
  • Total Command Data: commandBytes (bytes)
    The number of bytes sent via all graphics contexts (2D, OpenGL, DVD)
  • 2D Command Data: command2DBytes (bytes)
    The number of bytes sent via 2D graphics contexts.
  • OpenGL Command Data: commandGLBytes (bytes)
    The number of bytes sent via OpenGL contexts.
  • DVD Command Data: commandDVDBytes (bytes)
    The number of bytes sent via DVD contexts.
  • Extra OpenGL Data: dataGLBytes (bytes)
    The number of bytes used for extra OpenGL command traffic (usually vertex data). Not used by all drivers in all modes.
  • Swap Data: swapBytes (bytes)
    The number of bytes sent by swap commands.
  • AGP Data Mapped: gartMapInBytes (bytes)
    The number of bytes mapped into the AGP Graphics Address Remapping Table (GART) or equivalent hardware.
  • AGP Data Unmapped: gartMapOutBytes (bytes)
    The number of bytes unmapped from the AGP GART (or equivalent hardware).
  • Texture Page On Data (Non-AGP): texturePageInBytes (bytes)
    The number of bytes transferred for texture page-ins. Textures mapped via AGP will not show up here.
  • Texture Page Off Data (Non-AGP): texturePageOutBytes (bytes)
    The number of bytes transferred for texture page-off operations. Under most conditions, textures are not paged off but are simply thrown away since a backup exists in system memory. Texture page-off traffic usually happens when VRAM pressure forces a page-off of a texture that only has valid data in VRAM, such as a texture created via glCopyTexImage(), or modified via glCopyTexSubImage() or glTexSubImage().
  • Surface Page On Data (Non-AGP): surfacePageInBytes (bytes)
    The number of bytes transferred due to surface page-on operations.
  • Surface Page Off Data (Non-AGP): surfacePageOffBytes (bytes)
    The number of bytes transferred due to surface page-off operations.
  • Textures: textureCount (count)
    The total number of kernel textures allocated by the GPU.
  • Surfaces: surfaceCount (count)
    The total number of surfaces allocated by the GPU.
  • 2D Contexts: context2DCount (count)
    The total number of 2D contexts in use on the GPU.
  • OpenGL Contexts: contextGLCountcontextGLCount (count)
    The total number of OpenGL contexts in use on the GPU.
  • DVD Contexts: contextDVDCount (count)
    The total number of DVD contexts is use on the GPU.
  • 2D Context Switches: context2DSwitchCount (count)
    The total number of context switches to a 2D context on the GPU.
  • OpenGL Context Switches: contextGLSwitchCount (count)
    The total number of context switches to an OpenGL context on the GPU.
  • DVD Context Switches: contextDVDSwitchCount (count)
    The total number of context switches to a DVD context on the GPU.
  • Buffer Swaps: bufferSwapCount (count)
    The total number of buffer swaps (or blits) performed by the GPU.
  • OpenGL Data Buffers: dataBufferCount (count)
    The total number of extra OpenGL data buffers allocated.
  • CPU Texture Page-on Wait: texturePageInWaitTime (nanoseconds)
    The amount of time the CPU stalled while waiting for a texture upload command to be completed by the GPU so that it can be updated for a re-upload. Time spent here will be very rare.
  • CPU Texture Page-off Wait (non-DMA): texturePageOffWaitTime (nanoseconds)
    The amount of time the CPU stalled while waiting for the GPU to finish activity that could be modifying a texture before the texture can be paged off. This only applies if the texture must be paged via the CPU and not via DMA.
  • CPU Texture Upload Wait (2D context only): textureWaitTime (nanoseconds)
    The amount of time the CPU stalled while waiting for a texture upload to complete before the buffer can be modified. This particular statistic only tracks usage by 2D contexts, and is somewhat obsolete.
  • CPU Wait for GPU: hardwareWaitTime (nanoseconds)
    The amount of time the CPU stalled while waiting on the GPU for any reason.
  • CPU Wait to Submit Commands: hardwareSubmitWaitTime (nanoseconds)
    The amount of time the CPU stalled while waiting to be able to submit a new batch of commands to the GPU.
  • CPU Wait in User Code: clientGLWaitTime (nanoseconds)
    The amount of time the CPU stalled while the client (user level) OpenGL driver waited for a hardware time stamp to arrive (usually for making texture modifications or waiting for a fence to complete).
  • CPU Wait for Free 2D Command Buffer: freeCommandBuffer2DWaitTime (nanoseconds)
    The amount of time the CPU stalled while waiting for a free 2D command buffer to become available.
  • CPU Wait for Free OpenGL Command Buffer: freeCommandBufferGLWaitTime (nanoseconds)
    The amount of time the CPU stalled while waiting for a free OpenGL command buffer to become available.
  • CPU Wait for Free DVD Command Buffer: freeCommandBufferDVDWaitTime (nanoseconds)
    The amount of time the CPU stalled while waiting for a free DVD command buffer to become available.
  • CPU Wait for Free OpenGL Data Buffer: freeDataBufferGLWaitTime (nanoseconds)
    The amount of time the CPU stalled while waiting for a free OpenGL data buffer to become available.
  • CPU Wait for Free 2D Context Switch Buffer: freeContextBuffer2DWaitTime (nanoseconds)
    The amount of time the CPU stalled while waiting for a free 2D context switch buffer to become available.
  • CPU Wait for Free OpenGL Context Switch Buffer: freeContextBufferGLWaitTime (nanoseconds)
    The amount of time the CPU stalled while waiting for a free OpenGL context switch buffer to become available.
  • CPU Wait for Free DVD Context Switch Buffer: freeContextBufferDVDWaitTime (nanoseconds)
    The amount of time the CPU stalled while waiting for a free DVD context switch buffer to become available.
  • CPU Wait for Mapped AGP Buffer Removal: removeFromGARTWaitTime (nanoseconds)
    The amount of time the CPU stalled waiting for the GPU to finish an operation on a buffer that needs to be removed from GART.
  • CPU Wait for 2D Swap to Complete: swapComplete2DWaitTime (nanoseconds)
    The amount of time the CPU stalled waiting for a previously issued 2D buffer swap to complete.
  • CPU Wait for OpenGL Swap to Complete: swapCompleteGLWaitTime (nanoseconds)
    The amount of time the CPU stalled waiting for a previously issued OpenGL buffer swap to complete.
  • CPU Wait for DVD Swap to Complete: swapCompleteDVDWaitTime (nanoseconds)
    The amount of time the CPU stalled waiting for a previously issued DVD buffer swap to complete.
  • CPU Wait for Operations to Finish: finishAll2DWaitTime (nanoseconds)
    The amount of time the CPU stalled waiting for all GPU operations to complete and go idle. Generally only the Window Server will wait for this.
  • CPU Wait for 2D Operations to Finish: finish2DWaitTime (nanoseconds)
    The amount of time the CPU stalled waiting for all 2D commands issued on a single context to complete.
  • CPU Wait for OpenGL Operations to Finish: finishGLWaitTime (nanoseconds)
    The amount of time the CPU stalled waiting for all OpenGL commands issued on a single context to complete. This is essentially the time spent in glFinish().
  • CPU Wait for DVD Operations to Finish: finishDVDWaitTime (nanoseconds)
    The amount of time the CPU stalled waiting for all DVD commands issued on a single context to complete.
  • CPU Wait to perform VRAM Surface Page-on: surfaceCopyInWaitTime (nanoseconds)
    The amount of time the CPU stalled while waiting for the GPU to go idle so that the CPU can page a surface in to VRAM.
  • CPU Wait to perform VRAM Surface Page-off: surfaceCopyOutWaitTime (nanoseconds)
    The amount of time the CPU stalled while waiting for the GPU to go idle so that the CPU can page a surface out of VRAM.
  • CPU Wait to perform Surface Read: surfaceReadLockIdleWaitTime (nanoseconds)
    The amount of time the CPU stalled while waiting for the GPU to go idle so that the CPU may read from a surface.
  • CPU Wait to perform Surface Write: surfaceWriteLockIdleWaitTime (nanoseconds)
    The amount of time the CPU stalled while waiting for the GPU to go idle so that the CPU may write to a surface.
  • CPU Wait to perform Surface Resize: surfaceSetShapeIdleWaitTime (nanoseconds)
    The amount of time the CPU stalled while waiting for the GPU to go idle so that the CPU may change the dimensions of a surface.
  • Current Mapped AGP Memory: gartUsedBytes (bytes)
    The total number of bytes mapped into AGP GART.
  • Current Free AGP Memory: gartFreeBytes (bytes)
    The total number of free bytes in the AGP GART.
  • Current AGP Memory: gartSizeBytes (bytes)
    The total size of the AGP GART
  • Target Minimum Mapped AGP Memory: gartCacheBytes (bytes)
    The minimum amount of data a driver tries to keep mapped into AGP GART.
  • Last GPU Submission Time: submitStamp (absolute time value)
    The last submitted time stamp to the GPU.
  • Last Read GPU time: lastReadStamp (absolute time value)
    The last time stamp read back from the GPU.

The following parameters are vendor specific and not available for all drivers.

  • Current Free Video Memory: vramFreeBytes (bytes)
    The total amount of free VRAM.
  • Current Largest Free Video Memory Block: vramLargestFree (bytes)
    The largest free contiguous chunk of VRAM.
  • Current Video Memory in Use: vramUsedBytes (bytes)
    The total amount of VRAM in use.

[Jan 30, 2004]

Did this document help you?
Yes: Tell us what works for you.
It’s good, but: Report typos, inaccuracies, and so forth.
It wasn’t helpful: Tell us what would have helped.