woutermans
e0d1549a21
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]>
42 lines
2.6 KiB
C++
42 lines
2.6 KiB
C++
// 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
|