ayo
a617c818de
network natively on HIP with Vulkan->HIP shared memory, extend K kernels to
gfx11 (RDNA3), and add dependency/packaging/test tooling around them.
Windows: FSR RR backend, native HIP K runner, gfx11 K kernels, tooling
FSR Ray Regeneration (experimental)
- Add fsr_rr_backend.{h,cpp}, fsr_rr_passes.h and the fsr_rr/ prepare and
compose compute shaders. They run AMD's FidelityFX denoiser
(amd_fidelityfx_denoiser_dx12.dll, SDK 2.3, not bundled) on a private
vkd3d-proton device.
- Add the amdxc64 shim (tools/windows/amdxc64_shim) and two vkd3d-proton
patches for libcxx includes. AMD's amdxc64.dll is never loaded.
- d4r_nvngx_windows: RrFeature now selects between the native DLSS RR
backend and the FSR backend (D4R_RR_BACKEND=fsr). After the denoiser it
runs an internal Super Sampling stage (feature 1) to upscale. If SR is
unavailable and output != render size, the frame fails; it is never
returned noisy.
- d4r.ini / player_config: new [RayReconstruction] FsrDenoiser,
FsrStabilityBias (auto or >= 0) and FsrDetail (0-1), with validation, and
matching D4R_FSR_* environment variables.
- Add the FSR RR fixture, output-check and ngx test scripts, and a shader
compile script.
Native HIP K runner (Windows)
- CMake: add d4r_engine_k_hip (d4r-k-hip) plus separate volk/engine copies,
because VK_USE_PLATFORM_WIN32_KHR changes volk's entry points.
- Share Vulkan memory with HIP via Win32 opaque handles on Windows
(VK_KHR_external_memory_win32) and via fds on Linux. Handle types are now
intptr_t, and the platform choice is in D4R_EXT_MEMORY_* macros.
- HipNetwork: add debugRepeatHashes and debugNodeMicros, exposed as
D4R_HIP_REPEAT_CHECK, D4R_HIP_REPEAT_ALL and D4R_HIP_NODE_PROFILE in
replay.cpp.
- replay.cpp: display-resolution-motion frames (FrameFlagDisplayMotion) no
longer require near2rnd == out2rnd. Both values must still be in (0, 1].
K kernels on gfx11
- Allow position-token and enc1 tiling on __GFX11__ as well as gfx12.
- Add an opt-in ds_bpermute cross-half exchange
(D4R_WINDOWS_GFX11_DS_EXCHANGE, enabled for K on Windows gfx11). M keeps
its LDS path.
- Fix a block-barrier race in the position layer. Without POS_VSHARE a fast
wave could overwrite its hb rows while a slower wave still read them for a
later head, giving rare wrong results on gfx1101 (enc0 outputs differing
between identical launches).
Packaging and install
- install.bat, d4r.ini, WINDOWS_README: FSR option, and
install_dependencies.py to install pinned NVIDIA dependencies with staged,
hash-verified replacement and rollback.
- Update the release package, local package refresh and test scripts.
- Add the InteropBatchInputCopies option (default false). Batching is faster
on some synthetic runs, but player temporal exactness is unresolved.
Tooling and tests
- K model: capture_k_weights, build_k_model, compare_k_outputs,
benchmark_k_hip, build_capture_runtime, test_k_model and the
zluda-k-output-capture patch. Captured weights and models are private
local assets and must not enter release archives.
- Synthetic probes: test_m_ngx, test_sr_dynamic,
prepare_rr_dynamic_fixture and the d3d12/rr_ngx probe updates.
- Add tests/windows/test_install_dependencies.py.
Docs
- Update the windows-fsr-rr, k-performance, local-package, rr-interop and
rr-model-cache docs. Add windows-parity-handoff.md and
windows-parity-continuation-prompt.md.
73 lines
3.8 KiB
Python
73 lines
3.8 KiB
Python
"""Build bounded synthetic dynamic-size RR references with the standalone engine.
|
|
|
|
Reference resets at each size change; combined NGX frames deliberately omit that
|
|
reset to verify the adapter's implicit history reset. This is engine consistency,
|
|
not an NVIDIA image-quality reference. No game files are read or written.
|
|
"""
|
|
import argparse
|
|
import json
|
|
import os
|
|
from pathlib import Path
|
|
import shutil
|
|
import struct
|
|
import subprocess
|
|
import sys
|
|
|
|
|
|
def main():
|
|
repo = Path(__file__).resolve().parents[2]
|
|
parser = argparse.ArgumentParser(description=__doc__)
|
|
parser.add_argument('--runner', required=True, type=lambda p: Path(p).resolve())
|
|
parser.add_argument('--model', required=True, type=lambda p: Path(p).resolve())
|
|
parser.add_argument('--output', required=True, type=lambda p: Path(p).resolve())
|
|
args = parser.parse_args()
|
|
if args.output.exists() or not args.output.is_relative_to((repo / 'build').resolve()):
|
|
parser.error('use a fresh directory under ignored build/')
|
|
args.output.mkdir(parents=True)
|
|
inputs, reference = args.output / 'inputs', args.output / 'reference'
|
|
inputs.mkdir(); reference.mkdir()
|
|
lines, extents = ['size 96 96 192 192'], []
|
|
env = {key: value for key, value in os.environ.items() if not key.startswith('D4R_')}
|
|
env['D4R_RR_TIME_REPEAT'] = '1'
|
|
index = 0
|
|
for segment, (width, height) in enumerate(((96, 96), (64, 64), (96, 96), (72, 80))):
|
|
source, result = args.output / f'segment-{segment}', args.output / f'reference-{segment}'
|
|
subprocess.run([sys.executable, str(repo / 'scripts/windows/rr-synthetic-inputs.py'), str(source),
|
|
'--width', str(width), '--height', str(height), '--frames', '2',
|
|
'--output-width', '192', '--output-height', '192'], check=True, timeout=60)
|
|
# Exercise optional-view rebinding across reconfiguration and an absent
|
|
# guide frame. Fixture uploads and standalone replay use the same values.
|
|
for frame in (1,):
|
|
for name, texel in (('hitdistance', struct.pack('<f', 2.0)),
|
|
('disocclusion', struct.pack('<e', 0.0)),
|
|
('sss', struct.pack('<e', 0.125)),
|
|
('particles', struct.pack('<4e', 0.2, 0.3, 0.4, 1.0))):
|
|
(source / f'{frame}-{name}.bin').write_bytes(texel * (width * height))
|
|
result.mkdir()
|
|
with (args.output / f'segment-{segment}.log').open('wb') as log:
|
|
subprocess.run([str(args.runner), str(args.model), str(source), str(result)],
|
|
env=env, stdout=log, stderr=subprocess.STDOUT, check=True, timeout=180)
|
|
frames = (source / 'frames.txt').read_text().splitlines()[1:]
|
|
for local, line in enumerate(frames):
|
|
fields = line.split()
|
|
fields[1] = str(index)
|
|
if segment and local == 0:
|
|
fields[7] = '0' # omit caller reset on a size change
|
|
lines.append(' '.join(fields))
|
|
extents.append([width, height])
|
|
for path in source.glob(f'{local}-*.bin'):
|
|
shutil.copy2(path, inputs / (str(index) + path.name[len(str(local)):]))
|
|
shutil.copy2(result / f'{local}-out.bin', reference / f'{index}-out.bin')
|
|
index += 1
|
|
(inputs / 'frames.txt').write_text('\n'.join(lines) + '\n')
|
|
(inputs / 'dynamic-extents.txt').write_text(''.join(f'{w} {h}\n' for w, h in extents))
|
|
report = dict(kind='synthetic-dynamic-rr-engine-consistency', extents=extents,
|
|
frames=index, callerResetOnSizeChange=False, qualityReference=False,
|
|
model=str(args.model), runner=str(args.runner), gameAccessed=False)
|
|
(args.output / 'fixture.json').write_text(json.dumps(report, indent=2) + '\n')
|
|
print(json.dumps(report, indent=2))
|
|
|
|
|
|
if __name__ == '__main__':
|
|
main()
|