Rendering Performance (Tokens)

If FrameSync is set to ARB or ALL, this is the wait sync timeout used after DRAWS (in ms).

If positive, the wait occurs on the CPU.

If negative, the wait occurs in the driver / GPU.

If FrameSync is set to ARB or all, this is the wait sync timeout used after SWAP (in ms).

If positive, the wait occurs on the CPU.

If negative, the wait occurs in the driver / GPU.

Used in OTW, DAYTV, NVG, RADAR.

See also BufferFramesSensor.

Intended to be an app method for setting the max number of frames that the NVidia GL driver will queue ahead when 'Maximum prerendered frames = Use the 3D app setting' in the
NVidia Control Panel.

...however, testing reveals that this doesn't seem to work properly (FIXME).

Specifies the method(s) used to limit GL driver queue ahead to the number of frames given by BufferFrames or BufferFramesSensor.

Valid values: NVAPI, FENCE, ALL

Used in CCDNVG, LW IR, MW IR, SW IR, LLTV, COLOR_LLTV.

See also BufferFrames.

Intended to be an app method for setting the max number of frames that the NVidia GL driver will queue ahead when 'Maximum pre-rendered frames = Use the 3D app setting' in the NVidia Control Panel.

...however, testing reveals that this doesn't seem to work properly (FIXME). 

If set, pre-SWAP, we busy wait until at least BufferFramesSyncSampleTime milliseconds have elapsed since this point in the last frame.

Can be used for headless nodes or nodes w/o VSync to gate the frameloop time. 

When BufferFramesSync is set, this is the period (in milliseconds) to busy wait between successive pre-SWAP events.

Should be set to OFF for all internal use.

When ON, the "Average FPS" reported in the onscreen "S" stats are scaled up by a factor of 1.0345 and then clamped down to the nodes display rate. However, this scale + clamp is not applied to the Instantaneous FPS displayed in the PerfHUD FPS graph, nor is it applied to the Average FPS reported in Automation Manager performance stats output.

Where within the frame to execute clipmap generation kernels.

Where within the frame to execute cumulus cloud generation kernels.

Where within the frame to execute paged feature mesh
generation kernels. 

Where within the frame to execute terrain decoration generation kernels.

Where within the frame to execute terrrain mesh generation kernels.

Where within the frame to execute terrain mesh generation kernels.

Where within the frame to execute wave generation kernels.

Force draw thread (and/or GPU) to wait at specific points during frame rendering.

Default: ON.

Ignored for ISECT nodes (where ON is forced).

1) OFF: Disabled.

2) ON or ALL: Activate glFinish after SwapBuffers().

Causes CPU to wait until frame N is fully rendered by the GPU HW queue ("except" for insertion into the swap chain) before allowing the draw thread start queuing work for frame N + 1.

NOTE: With VSync + FlipMode and not overrunning, does "not" sync CPU with VBlank, but a GPU render dependent offset from it. Also, rendering to window and offscreen result in different alignments of GPU HW queue work w.r.t. VBlank.

3) ARB or ALL: Activate sync obj insert at SOF and wait after DRAW SS. Wait timeout specified by ArbFrameSyncTimeoutDraw.

Also activates sync obj insert just before SWAP and wait just after SWAP. Wait timeout specified by ArbFrameSyncTimeoutSync.

4) DRAW_AND_SWAP: ON + glFinish() before pre-EOF spin and SWAP.

Useful in profiling to determine how much CPU+GPU frame time is needed for:

1) Complete CPU+GPU DRAW

2) complete CPU+GPU post- DRAW

5) FS_PREV_SWAP: Like ON, but instead of waiting on the last SwapBuffers, waits on the prior SwapBuffers to actually swap on the GPU.

Useful for multiviewport modes (e.g. 120Hz) where we're rendering multiple frames per frameloop.

6) AUTO: Auto frame sync. Calls glFinish() after SWAP conditionally based on CULL + DRAW duration history. Uses [AutoFrameSyncThreshold, AutoFrameSyncThresholdHigh], and AutoFrameSyncCount.

7) ARB_AUTO: ARB behavior + AUTO frame sync (see above).

8) RUNNING_START: Behaviorally similar to SWAP_CHAIN, but with the CPU frame queueing starting N ms before the VBlank, and GPU frame execution starting at that VBlank. This lets the CPU get "a running start" queuing the next frame, allowing us to overlap final GPU rendering for frame N - 1 and initial CPU submission of frame N while maintaining consistent frame latency.

Auto-disabled when VSync is OFF. When GpuSwapTimer TIMESTAMP is active, uses GPU Swap Chain insertion timestamps for the VBlank clock. Otherwise, uses D3D VBlank timestamps.

9) SWAP_CHAIN: Behaviorally similar to RUNNING_START with a StartTime offset of 0 ms, but functionally similar to ON with the glFinish() moved forward just past SwapBuffers() and window glClear() (added if necessary).

Causes the draw thread to wait until:

1) Frame N is fully rendered by the GPU HW queue

2) Inserted into the swap chain

3) The window image for frame N+1 has been acquired. With VSync+FlipMode when not overrunning, the latter should occur at a VBlank clock.

If FrameSync is set to PREV_SWAP, this is the wait sync timeout used (in ms).

If positive, the wait occurs on the CPU.

If negative, the wait occurs in the driver / GPU.

If FrameSync is set to RUNNING_START, this is the threshold (in ms) for when the draw thread sleeps rather than busy waits until the running start time.

See FrameSyncRunningStartTime.

NOTE: Sleep() seems horribly inaccurate for this, sometimes oversleeping up to 2 ms.

Set to 1 60Hz frame time to avoid using Sleep() at all for RUNNING_START.

If FrameSync is set to RUNNING_START, this is the time offset before the GPU-side SWAP of frame N - 1 (i.e. VBlank if VSync enabled) when the CPU DRAW thread starts processing and submitting frame N.

Value must be in (0, P) where P is the VBlank period (i.e. 1 / BeFrameRateFreq; e.g. 16.66 ms for 60.0Hz backend).

Conceptually, RUNNING_START is FrameSync SWAP_CHAIN with the CPU DRAW thread timing shifted left P ms from VBlank. This lets the CPU get "a running start" on the next frame N - 1 and CPU submit of frame N while still maintaining consistent frame-to-frame latency.

If true, do manual aeCullWorldNode() in aeGeometry cull traversal using node bounds.

Used to enable and tune filtering for GPU Swap Timestamps (enabled by GpuSwapTimer TIMESTAMP or SwapTimestamps ON).

Sets the number of taps used for filtering.

1: No filtering.

NOTE: This is different from the filtering enabled by SwapTimeFilterFactor.

SwapTimeFilterFactor enables time averaging (which is nonsense), whereas this token enables time fitting. 

Sets the method used to estimate the GPU Swap "Execution" time of the "next" SwapBuffers that we queue with the GL driver (used for extrapolation).

Ideally this is when the user will first see the frame we're about to render, and the time we need to extrapolate to.

NOTES:

1) This is "not" the time that the CPU queued the SwapBuffers request.

That may have been as much as 66.6 ms (4 frames) before the GPU Swap execute and submitted completely out-of-phase with GPU Swap! Nor technically is it when the driver inserts the pipeline- rendered image into the swap chain.

It is when the GPU dequeues the image from the swap chain and first displays it.

2) Only TIMESTAMP and D3D_VBlank attempt to measure actual GPU swap execution times. The rest depend on CPU frameloop queuing time which (for some FrameSync methods) has little/nothing to do with GPU swap execution times.

3) The swap time value measured (or computed) based on the selected method may optionally be filtered before it is set on _swap_exec_time (see GpuSwapTimeFilterWidth for TIMESTAMP SwapTimeFilterFactor for ON).

SETTINGS:

OFF: Disables measuring of GPU swap execution time. CPU- based _swapTimer (sampled after VSync Wait) is used for measurement instead.

This is completely dependent on CPU frameloop times and may have little/no relation to GPU swap times unless our CPU draw thread frameloop is locked to GPU VBlank (e.g. FrameSync SW AP_CHAIN, or FrameSync RUNNING_START with a small StartTime offset).

ON: (LEGACY MODE) Not very reliable or accurate. Measures GPU execution time between "before" swap on the last frame to "before" Swap on the current frame (see caveats), and just adds that to a running swap exec time. No concrete tie to GPU Swap execution.

CAVEATS:

1) Due to the blocking driver query method used, ON prevents the driver from queuing ahead, regardless of the Maximum Pre-rendered Frames setting.

2) Partly since elapsed time is measured "before" the CPU queues SwapBuffers, the time measured is at the mercy CPU draw thread processing time, driver queuing internals (including implicit sync and read-ahead), as well as CPU-GPU phase (which varies).

TIMESTAMP: Uses GL timestamps queued after SwapBuffers to measure actual GPU swap chain insertion times. These are then used to estimate the GPU swap execution time for the next SwapBuffers that we will submit (the one submitted in the next frameloop cycle).

NOTES:

1) VSYNC: Requires VSync ON and not overrunning the frame time budget to be accurate.

This because the GPU timestamp tracked is the Swap Chain queue insertion time, not the Swap Chain dequeue + display time.

With VSync ON, the latter is always locked to the VBlank clock. However, that's only true of the former so long as the CPU+GPU isn't overrunning its frame time budget.

2) FrameSync: We have observed querying the current GPU timestamp to occasionally trigger blocks in Framesync OFF configs (NOVA-15977). Consequently, TIMESTAMP will be forced to OFF if requested with FrameSync OFF.

D3D_VBLANK: Uses the VBlank timestamps obtained from D3DKMTWaitForVerticalBlankEvent to set GPU Swap execution times.

HMD: Use the attached Head Mounted Display's estimated display time.

Used for old-style instanced features (not MDI).

If InstancedLODScale is greater than 0 and the instance model's LOD range is greater than 0, this scale factor is applied to the override fade-out ranges used.

By default, these ranges fade out the model between 65% and 100% of the model's LOD rang * InstancedLODScale.

Used for old-style instanced features (not MDI). If set to a value greater than 0, this scale factor is applied to the fade-out range (from the instanced feature library file) for the LOD node added above instanced features.

It is also applied to the ranges for the FadeInOut attribute added. If set to 0, disables the addition of a LOD node and an override FadeInOut attribute over the model.

Minimum size, in pixels, at which objects are drawn, otherwise, they are culled.

A setting of zero disables projected size culling.

Maximum number of kilobytes per second of GPU bandwidth allotted to paged arrays.

Default: 1GB/second, which is effectively disabled.

Set to 262144 or lower to limit throughout to reasonable values. A value of 0 will still allow at least one paged array tile to download.

Used in tandem with GpuSwapTimer.

SwapTimeFilterFactor is used as obtuse switch (FIXME!) to determine:

1) Whether _swap_exec_time (GPU swap execution time) is measured or just computed from ideal frame rates

2) If measured, whether the time measurement is used as-is or filtered with a box filter.

OPTIONS:

0.0: Enables GPU Swap

Time measurement and ENABLES "time" box filtering (across the last 5 samples).

Greater than 0.0 - Enables GPU Swap

Time measurement, but DISABLES "time" box filtering.

Less than 0.0: Disables GPU Swap Time measurement.

_swap_exec_time is instead computed directly from
FeFrameRate (on FRONTEND) or BeFrameRate (on
other nodes).

WARNINGS:

1) _swap_exec_time is supposed to be a monotonically increasing "time" (not "time delta"). So, box filtering these times is completely bogus. When fed real times, this has the effect of shifting the filtered time back half the width of the box filter (back 2 frames for 5 tap filter).

2) The magnitude of the value set makes "no difference"! (as mentioned, this is an obtuse switch -- FIXME)

3) Because time box filtering is nonsense, it is disabled in TIMESTAMP and D3D_VBLANK modes.

4) Ignored in movie capture mode (CaptureMovie ON) or when a path is active, where _swap_exec_time is computed from the ideal frame rate (BeFrameRateFreq).

TODO: Delete this token and the filtering of swap "times".

Enables submission and deferred collection of GPU timestamps for GPU SwapBuffers calls for frame timing statistics.

This enables use of the following Dashboard frame timing graphs:

1) GPU Swap Time - Reports the time elapsed between adjacent GPU swap executions.

2) Swap Latency (frames or msec) - Reports the time elapsed between CPU submission of a SwapBuffers request and GPU execution of that Swap.

3) Frame Latency (msec) - Reports the time elapsed between CPU start-of-frame and the corresponding GPU Swap Execution for that frame.

NOTES:

1) GPU timestamps are implicitly enabled in GpuSwapTimer TIMESTAMP mode.

2) Should not be used with FrameSync OFF, as we have observed occasional driver blocks querying the current GPU timestamp in this config (NOVA-15977).

Select which timer's value we store in the uber _timestamp field in the ICD phase.

Enables use of a CPU thread which stays tightly synchronized to the GPU's VBlank clock (also implicitly enabled by FrameSync RUNNING_START or GPUSwapTimeD3D_VBLANK).

This allows other threads to query the absolute time offset of the last observed VBlank relative to the time that the VSync thread was started.