diff --git a/docs/building.md b/docs/building.md index 52e4f779..7a9e0530 100644 --- a/docs/building.md +++ b/docs/building.md @@ -771,6 +771,11 @@ first host present, after 200 ms without one and with the setting off, that fram give it to the pacer for the rest of the run, and that frames the multiplier periods apart switch Reflex to the frames on screen once and to the pacer the second time. No GPU, no game files. +A change to `runtime/dlssg/nx2_sl.h` or to the export check in `tools/build_dlssg.py` (`declared_exports`, +`pe_exports`) passes `python tests\dlssg_exports_check.py`, which builds a small DLL with MSYS2's clang and checks that +the export it lacks is the one named, and that every function `nx2_sl.h` declares is read. The DLL itself is checked +when `tools/build_dlssg.py` builds it, or with `--check `. No MSVC, no Streamline SDK, no game files. + A change to which frames the flight recorder takes for a one-frame flash (`runtime/flight_flash.h`, `runtime/flight.c` `flight_cells`) passes `python tests\flight_flash_check.py`, which builds the header alone, draws pictures of the thumbnails' size and checks that a patch or a whole frame shown once is a flash, that a camera cut, a fade, a pan and diff --git a/docs/launcher.md b/docs/launcher.md index 5b3b4704..080eae12 100644 --- a/docs/launcher.md +++ b/docs/launcher.md @@ -516,7 +516,9 @@ stays playable and Rebuild the Game, or Begin Installation, goes on from the ste `tools/streamline_pin.py` pins. The script downloads that release once (cached in `toolchain/launcher-dl/`), checks the archive's size and sha256 and each file's sha256, and writes `dlssg-NOTICE.txt` with the two licence texts; `make_game.py` copies the whole set beside the game. `--streamline SDK` takes an SDK folder on disk instead (its - files must be the pinned ones). + files must be the pinned ones). `tools/build_dlssg.py` fails a DLL that lacks an export `runtime/dlssg/nx2_sl.h` + declares, and `python tools/build_dlssg.py --check ` makes that check of a DLL built earlier: the runtime + takes a missing optional export for an older DLL and leaves that feature out, Reflex's frame limit among them. `--pgo FILE` puts an execution profile and its record in the release (`app//data`), and the prebuilt runtime is compiled with it; the release stops when the record names another `recomp/` than the checkout's, and diff --git a/tests/dlssg_exports_check.py b/tests/dlssg_exports_check.py new file mode 100644 index 00000000..b233a319 --- /dev/null +++ b/tests/dlssg_exports_check.py @@ -0,0 +1,75 @@ +"""Check tools/build_dlssg.py's export check: it reads the exports runtime/dlssg/nx2_sl.h declares and the ones a DLL +has, and names those the DLL lacks. A DLL built from older sources would otherwise ship: the runtime takes a missing +optional export (nx2sl_reflex2, nx2sl_frames_max) for an older DLL and leaves its feature out without an error. + +Builds a small DLL with two of three declared exports with MSYS2 UCRT64's clang (no MSVC, no Streamline SDK, no game +files) and checks that the third is the one reported; then that nx2_sl.h's own declarations are read in full. + +Usage: dlssg_exports_check.py +""" +import os +import shutil +import subprocess +import sys +from pathlib import Path + +ROOT = Path(__file__).resolve().parents[1] +MSYS_BIN = Path(r'C:\msys64\ucrt64\bin') +sys.path.insert(0, str(ROOT / 'tools')) +import build_dlssg # noqa: E402 + +HEADER = '''typedef int (*PFN_nx2sl_version)(void); +typedef void (*PFN_nx2sl_reflex)(int mode); +typedef int ( * PFN_nx2sl_reflex2 )(int mode, unsigned frame_limit_us); +''' +SOURCE = '''__declspec(dllexport) int nx2sl_version(void) { return 3; } +__declspec(dllexport) void nx2sl_reflex(int mode) { (void)mode; } +int nx2sl_not_exported(void) { return 0; } +''' + + +def compiler(): + """$CC, else MSYS2 UCRT64's clang, else clang on PATH (as tests/wb_lazy_check.py picks it).""" + if os.environ.get('CC'): + return os.environ['CC'] + if os.name == 'nt' and (MSYS_BIN / 'clang.exe').exists(): + return str(MSYS_BIN / 'clang.exe') + return shutil.which('clang') or 'clang' + + +def main(): + if os.name != 'nt': + print('dlssg_exports_check: Windows only (it builds a DLL)') + return 0 + work = ROOT / 'build' / 'test' / 'dlssg_exports' + work.mkdir(parents=True, exist_ok=True) + (work / 'two.h').write_text(HEADER, encoding='utf-8') + (work / 'two.c').write_text(SOURCE, encoding='utf-8') + env = dict(os.environ) + if MSYS_BIN.exists(): + env['PATH'] = str(MSYS_BIN) + os.pathsep + env.get('PATH', '') + dll = work / 'two.dll' + subprocess.check_call([compiler(), '-shared', '-O1', str(work / 'two.c'), '-o', str(dll)], env=env) + fails = 0 + + def expect(what, got, want): + nonlocal fails + if got != want: + print(f'FAIL {what}: {got!r}, not {want!r}') + fails += 1 + + expect('declared in the test header', build_dlssg.declared_exports(work / 'two.h'), + {'nx2sl_version', 'nx2sl_reflex', 'nx2sl_reflex2'}) + expect('exported by the test DLL', build_dlssg.pe_exports(dll), {'nx2sl_version', 'nx2sl_reflex'}) + expect('missing from the test DLL', build_dlssg.missing_exports(dll, work / 'two.h'), ['nx2sl_reflex2']) + declared = build_dlssg.declared_exports() + for name in ('nx2sl_version', 'nx2sl_init', 'nx2sl_reflex', 'nx2sl_reflex2', 'nx2sl_frames_max', 'nx2sl_shutdown'): + expect(f'{name} declared in nx2_sl.h', name in declared, True) + # the header names its version and log types too, which are no exports of their own + expect('types that are no functions', {'nx2sl_' + t for t in ('Image', 'Camera', 'Log')} & declared, set()) + print(f'dlssg_exports_check: {"ok" if not fails else f"{fails} failed"} ({len(declared)} exports in nx2_sl.h)') + return 1 if fails else 0 + + +if __name__ == '__main__': + sys.exit(main()) diff --git a/tools/build_dlssg.py b/tools/build_dlssg.py index 4b671454..bee04f07 100644 --- a/tools/build_dlssg.py +++ b/tools/build_dlssg.py @@ -1,22 +1,31 @@ """Build nx2navi_dlssg.dll (runtime/dlssg/nx2_sl.cpp, DLSS Frame Generation through NVIDIA Streamline) with MSVC. python tools/build_dlssg.py --sl [--out build/dlssg] + python tools/build_dlssg.py --check Streamline's C++ types have MSVC's ABI, so this one DLL is built with Visual Studio's compiler (the Build Tools are enough; vswhere finds them), against the SDK's headers, which stay where they are. The Vulkan headers are MSYS2's. A launcher release and the build kit ship the DLL ready-made beside Streamline's own runtime DLLs (tools/make_launcher.py and tools/make_kit.py --dlssg, with the Streamline files tools/streamline_pin.py pins), and tools/make_game.py place_dlssg puts them beside the game. + +The built DLL must export every function runtime/dlssg/nx2_sl.h declares (each PFN_nx2sl_ is the export +nx2sl_), or the build fails naming the ones it lacks: the runtime takes a missing optional export for an older +DLL and leaves its feature out without an error. --check makes the same check of a DLL built before, such as the one +a release is about to ship. """ import argparse import os +import re import shutil +import struct import subprocess import sys import tempfile from pathlib import Path ROOT = Path(__file__).resolve().parents[1] +HEADER = ROOT / 'runtime' / 'dlssg' / 'nx2_sl.h' VSWHERE = Path(os.environ.get('ProgramFiles(x86)', r'C:\Program Files (x86)')) / 'Microsoft Visual Studio' / 'Installer' / 'vswhere.exe' @@ -32,12 +41,68 @@ def vcvars(): return bat +def declared_exports(header=HEADER): + """The exports nx2_sl.h declares: nx2sl_ for each function pointer type PFN_nx2sl_.""" + text = Path(header).read_text(encoding='utf-8') + return {'nx2sl_' + name for name in re.findall(r'\(\s*\*\s*PFN_nx2sl_(\w+)\s*\)', text)} + + +def pe_exports(path): + """The names a PE file (PE32 or PE32+) exports: its export directory's name table. Empty without one.""" + d = Path(path).read_bytes() + pe = struct.unpack_from('