ayo
162bbd77c8
- [Interop] MarkerPollUs = auto is the new default: the input-marker wait learns when each feature's inputs become ready, sleeps in <=200 us chunks, yields near the prediction and backs off when late (d4r_input_wait.h); a number keeps fixed pacing (0 yields). d4r_config.py no longer exports 200 when the key is unset - D4R_SHIM_GPU_INPUT_WAIT=1 (experimental, split VRAM, age 0): NGX's null stream waits on a coherent Vulkan word imported into HIP (d4rStreamWaitValue32Eq) instead of CPU polling. The original readback marker stays the authority; a CPU watchdog releases discarded lists and timeouts. Denoiser, verify, capture and dilation frames keep the CPU wait - D4R_SHIM_GPU_COMPLETION=1 (needs GPU_INPUT_WAIT): the bridge writes a completion word right after the native output kernel (d4rNgxWriteValue32), and the game's queue polls it with a bounded compute wait (kernels/support/vulkan_wait.comp), replacing the split list's CPU timeline signal. frame_retired writes the same word on every failure path - D4R_SHIM_NATIVE_COMPLETION=1: a null-stream callback in the bridge signals the split timeline (d4rNgxTimeline*); D4rFrameCompletion::can_signal only releases the oldest outstanding frame - RGBA8 output: tex_common.h adds an 'R4' redirect tag, so K's native output kernel stores packed RGBA8 directly (D4R_SHIM_OUTPUT_RGBA8=1, checked against the kernel manifest by d4rOutputKernelRgba8). Host packing handles RGBA8 too. patches/vkd3d-proton/0004 (VKD3D_D4R_LINEAR_RGBA8=WxH) makes such outputs linear and exportable so the result can be written in place - D4R_SHIM_FUSE_RGBA8_INPUT=1: one Vulkan pass converts and copies RGBA8 color input (vulkan_read.comp mode 5 matches the blit's toward-zero halves, plus a row stride) - profiling: thread CPU time from the Unix bridge (Wine's GetThreadTimes ticks at 10 ms); game-queue D3D12 timestamps (vk_input/vk_dlss_wait/vk_output/vk_total); gpu_eval split into input_gpu_wait and dlss_gpu; D4R_PROFILE_GPU_EVENTS, _TIMESTAMPS, _LOG and _CPU_TIME=0 switch off individual parts for bisection - bridge: D4R_NGX_STREAM_PRIORITY=high|normal runs NGX on a priority stream (off by default; no gain measured) - release_feature: a feature already marked retiring by a failed drain can still be released normally - harness: RGBA8 with motion and jitter scenes (re-quantized each frame), D4R_HARNESS_RGBA8_RAMP, D4R_HARNESS_THRASH_MB to evict L2/Infinity Cache before each evaluation - kernels/native: in_hoist.py and split_output_paths.py (opt-in scheduling experiments); scripts/build_k_ldr_output.sh builds K's LDR output with an optional D4R_LDR_OUTPUT_MAX_VGPR cap - tests: test_input_wait.py and test_latency_optimizations.py; MarkerPollUs and frame-completion tests updated
104 lines
5.3 KiB
INI
104 lines
5.3 KiB
INI
; Modified in this fork for CUDA Ray Reconstruction support and validation (2026).
|
|
; d4r settings for this game. This file lives in the game's d4r folder and applies to this game only.
|
|
; "auto" means the built-in default. Any setting can also be overridden with the environment variable
|
|
; that config/d4r.ini.default in the source repository lists for it, e.g. in the game's launch options.
|
|
|
|
[DLSS]
|
|
; DLSS model recommendations:
|
|
;
|
|
; Model | DLSS | Recommended modes | Notes
|
|
; ------+-------+---------------------------------+----------------------------------
|
|
; K | 4 | DLAA / Quality / Balanced | Default; faster alternative to M/L
|
|
; M | 4.5 | Performance | More demanding on RDNA3
|
|
; L | 4.5 | Ultra Performance | Especially 4K; experimental
|
|
; E | 3 CNN | Quality / Balanced / Performance | Legacy faster fallback
|
|
; F | 3 CNN | DLAA / Ultra Performance | Deprecated; prefer K or L
|
|
;
|
|
; Select the upscaling mode separately in game/OptiScaler. These are recommendations;
|
|
; other modes are allowed. L requires the L texture build.
|
|
; game = use the game/OptiScaler choice. Benchmarks: D4R_README.txt.
|
|
Model = K
|
|
; NVIDIA's library marks the image "DLSS SDK - DO NOT DISTRIBUTE" in this setup; d4r turns that off.
|
|
; true shows it.
|
|
ShowWatermark = false
|
|
|
|
[RayReconstruction]
|
|
; Requires a CUDA-capable nvngx_dlssd.dll (tested: 310.7) beside nvngx.dll and RR enabled in game.
|
|
; auto uses the denoiser when available; false disables the route.
|
|
; RR D/E temporal validation on gfx1201 uses [Kernels] NativeFp8 = on; scalar FP8 RR is not validated.
|
|
Enable = auto
|
|
; Independent denoiser presets: auto (game choice), default, D, E (transformer) or F (DLSS 4.5).
|
|
; E and F through NVIDIA's library need a denoiser DLL containing that model (F: 310.9 or later). On the engine
|
|
; ([Engine] Enabled = true) F runs from the model in d4r\engine\rr-f; frames the library serves instead show
|
|
; preset D when the DLL is older (d4r_nvngx.log says so).
|
|
Model = auto
|
|
|
|
[Latency]
|
|
; 0: every frame shows its own DLSS result, as with a native upscaler (needs the d3d12.dll that came
|
|
; with d4r next to the game).
|
|
; 1-3: allow results up to that many frames old. Slightly more fps, more input latency.
|
|
FrameAge = 0
|
|
|
|
[Kernels]
|
|
; Prioritize fidelity over speed. Uses accuracy variants of all native kernels, preserves NVIDIA's
|
|
; intermediate FP8/f16 rounding and denormal handling, and keeps NGX's synchronization calls.
|
|
; Slower but aims to match RTX DLSS.
|
|
PreferAccuracy = false
|
|
; false reduces L/M motion trails by using original enc1/enc2 layers; other native kernels stay on.
|
|
; Best paired with PreferAccuracy = true; costs some GPU time. Restart after changing this.
|
|
NativeSwinEncoders = true
|
|
; Hand-written RDNA3 and RDNA4 kernels for the DLSS 4 and 4.5 networks (d4r\kernels). Each one is used
|
|
; only when your DLSS library's code for that kernel matches the code it was written for; otherwise
|
|
; that kernel is compiled from NVIDIA's code instead, which is slower but still correct.
|
|
NativeKernels = on
|
|
; RDNA4 (RX 9000 series) only: run DLSS's FP8 math on the GPU's native FP8 matrix units, with NVIDIA's
|
|
; own FP8 rounding in the DLSS 4.5 (M) layers. off runs it as 16-bit math, as on RDNA3. Ignored on
|
|
; other GPUs.
|
|
NativeFp8 = on
|
|
|
|
[Interop]
|
|
; Experimental thin-feature tracking: 0 = off; 1/2 = opaque-surface dilation radius.
|
|
; Both enabled values fill sky gaps from the nearest foreground within 8 render pixels.
|
|
; Requires render- or display-resolution, unjittered motion vectors and same-frame linear VRAM inputs. Restart to change.
|
|
; Unsupported features keep original vectors; larger radii may affect disocclusion edges.
|
|
MotionVectorDilation = 0
|
|
; Keep inputs and output in video memory. Readiness uses adaptive CPU polling by default.
|
|
VramInterop = true
|
|
; auto: adaptive input-marker polling; N: fixed interval in microseconds (0 yields).
|
|
MarkerPollUs = auto
|
|
LinearInputs = true
|
|
ElideNgxSync = true
|
|
; Lets DLSS's last kernel write straight into the game's output buffer (DLSS 4 / K only). It takes
|
|
; effect only while d4r's own output kernel runs, which it does when the DLSS library matches.
|
|
DirectOutput = auto
|
|
|
|
[Engine]
|
|
; Experimental. Runs DLSS 4 and 4.5 (models K, L and M) on d4r's own Vulkan inference engine instead of NVIDIA's
|
|
; kernels: the game shows the result of the frame it just rendered and [Latency] / [Interop] do not apply.
|
|
; Needs Mesa RADV with VK_KHR_cooperative_matrix and the models in d4r\engine\k, k-ldr, m, m-ldr, l and l-ldr
|
|
; (see D4R_README.txt). Games or settings it does not cover use the normal path; d4r_nvngx.log says why.
|
|
Enabled = false
|
|
; Another model K folder for games with the HDR flag (a path relative to the d4r folder, or a Windows path
|
|
; such as Z:\home\me\k)
|
|
ModelDir = auto
|
|
; auto / vulkan = the network on the engine's shader, hip = on d4r's native HIP layer kernels when the model
|
|
; folder has them
|
|
Network = auto
|
|
|
|
[Paths]
|
|
; Linux paths.
|
|
; ROCm installation (default: the ROCm runtime in d4r\rocm, else /opt/rocm)
|
|
RocmDir = auto
|
|
; Cache for the compiled DLSS kernels (default ~/.cache/d4r). The first launch fills it.
|
|
CacheDir = auto
|
|
|
|
[Debug]
|
|
; d4r's log is d4r\d4r_nvngx.log, rewritten at every launch.
|
|
; Profile = true adds one line of timings per frame.
|
|
Profile = false
|
|
|
|
[Env]
|
|
; Extra environment variables for d4r, NAME = value.
|
|
; Sleeping event queries are the default; 0 restores context waits for an A/B comparison.
|
|
; D4R_SHIM_BLOCKING_SYNC = 0
|