Engine: native presets K and M in the D3D12 shim, wider game coverage

A standalone Vulkan inference engine (engine/) for DLSS presets K and M that
runs from weights extracted from the user's own nvngx_dlss.dll, with d4r's
own input, network and reconstruction shaders or the native HIP network
layers, recorded into the game's command list by the shim. Opt-in
([Engine] Enabled / D4R_ENGINE=1); anything uncovered falls back to the
CUDA/ZLUDA path with the reason logged.

Byte-identical to NGX's CUDA backend under the phase-capable reference
(1706x960 -> 2560x1440, native HIP network, eleven frames, RX 9070 XT):
- K render- and display-resolution motion vectors, HDR and LDR
- K game-supplied exposure and automatic exposure with any pre-exposure
  and exposure scale (one residual: effective exposure exactly 2 or 4)
- K and M with the DLSS indicator's inverted-axis parameters
- M with any exposure settings (NGX ignores them for M)
K packages need the current compile_k.py (marker D4RO0003).

Also: HIP shared buffers are pooled across feature recreation (ROCm leaks
destroyed imports), hipnet.bin must match the preset, M-only games do not
load the K model, install_d4r_runtime.sh stages k, k-ldr, m, m-ldr with
hip/, the activation table has a generator (gen_activation_m.py), and
package_release.sh can bundle the engine's shaders (never its weights).

Signed-off-by: woutermans <[email protected]>

engine/hip_net.h

@@ -0,0 +1,41 @@
+// d4r engine: the DLSS network on d4r's native HIP layer kernels instead of the Vulkan layer shader. HIP reaches
+// the hardware's packed FP8 conversions and keeps a block's activations in registers, which a cooperative-matrix
+// shader cannot, so the network runs about 1.7x faster here. The stages around it stay on Vulkan: the engine's
+// front writes the tokens into memory shared with HIP, launch() runs the layers, the engine's back reads their
+// output (ExternalNetwork in runtime.h).
+//
+// The model directory needs hipnet.bin and hip/*.hsaco (compile_m.py --hip for preset M, compile_k.py --hip for
+// preset K) and the header + entry names select the preset:
+//   D4RMHIP1 (10 layers) - M on the kernels/m layer kernels. width/height are the render dimensions; two
+//     window-alignment phases, one per evaluation.
+//   D4RKHIP1 (11 layers) - K on the kernels/k DltssPaddedWinLayer kernels, the bottleneck layer running as its
+//     main kernel plus post1..3. width/height are the OUTPUT dimensions (the token grid is max(256, align 32 of
+//     their quarter resolution, makeKShape) and the input/output buffers hold 16 / 40 f16 channels per token,
+//     row-major, with no layout copy. Eight immutable window graphs, one per evaluation of makeKWindows' cycle.
+// Either way every graph is uploaded once and one evaluation is a single hipGraphLaunch: no per-frame allocation,
+// no per-frame parameter copy. The frame counter advances once per launch() and is never reset (a reset
+// evaluation is still an evaluation), so the caller must pair one launch() with each network evaluation.
+#pragma once
+#include <cstdint>
+#include <memory>
+#include <string>
+namespace d4r {
+class HipNetwork {
+public:
+    // tokensFd, outputFd: opaque file descriptors of the two shared Vulkan allocations (ownership passes to HIP);
+    // allocationBytes: the size of each allocation; the buffers start at offset 0. width/height are preset
+    // dependent, as above.
+    HipNetwork(const std::string& modelDirectory, uint32_t width, uint32_t height, int tokensFd, int outputFd,
+               uint64_t tokensAllocationBytes, uint64_t outputAllocationBytes);
+    ~HipNetwork();
+    HipNetwork(const HipNetwork&) = delete;
+    HipNetwork& operator=(const HipNetwork&) = delete;
+    void launch();      // queues the network; input tokens must already be complete
+    bool done();        // true once the queued layers have finished
+    void wait();        // blocks until they have
+    float lastMilliseconds(); // GPU time of the last finished launch
+private:
+    struct Impl;
+    std::unique_ptr<Impl> impl;
+};
+} // namespace d4r