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
40 lines
1.4 KiB
C++
40 lines
1.4 KiB
C++
#pragma once
|
|
#include <cstdint>
|
|
#include <deque>
|
|
|
|
// A timeline signal releases every lower value too. Prep can cancel a later
|
|
// frame while the CUDA worker is still producing an earlier one, so only the
|
|
// completed prefix of admitted frames may be signalled. The caller serializes
|
|
// admission and retirement with the same mutex used for the timeline signal.
|
|
class D4rFrameCompletion
|
|
{
|
|
public:
|
|
void admit(uint32_t frame) { pending_.push_back({frame, false}); }
|
|
|
|
// A native completion callback can release this value without crossing an unfinished producer
|
|
// only when it is the first admitted frame still outstanding. Retirement itself stays on the
|
|
// worker, which also folds any later discarded frames into the completed prefix.
|
|
bool can_signal(uint32_t frame) const { return !pending_.empty() && pending_.front().frame == frame; }
|
|
|
|
uint64_t retire(uint32_t frame)
|
|
{
|
|
for (auto& pending : pending_)
|
|
if (pending.frame == frame)
|
|
{
|
|
pending.done = true;
|
|
break;
|
|
}
|
|
while (!pending_.empty() && pending_.front().done)
|
|
{
|
|
completedThrough_ = pending_.front().frame;
|
|
pending_.pop_front();
|
|
}
|
|
return completedThrough_;
|
|
}
|
|
|
|
private:
|
|
struct Pending { uint32_t frame; bool done; };
|
|
std::deque<Pending> pending_;
|
|
uint64_t completedThrough_ = 0;
|
|
};
|