|
|
|
|
@@ -19,6 +19,16 @@
|
|
|
|
|
// game's frame sleeps in Reflex where it starts (its acquire of a window image), and each frame carries the latency
|
|
|
|
|
// markers from that start to the host present, all with the frame's number, the count of the game's presents up to it.
|
|
|
|
|
// The mode is the swapchain's, so it is set again after each one (vk_dlssg_create_swapchain).
|
|
|
|
|
//
|
|
|
|
|
// One limiter. Reflex's sleep also holds the frame limit (its frame limit, the driver's minimum interval), and the
|
|
|
|
|
// game's own pacer then keeps only the game's ceiling (vk_dlssg_pace, nvn_api_obj.c nvnQueuePresentTexture): the pacer's
|
|
|
|
|
// wait came after the picture was drawn, so the pad was read up to a period before the picture left, and Reflex's sleep
|
|
|
|
|
// at the frame's start already waited for the GPU. The pacer keeps the limit while a movie plays, before the first host
|
|
|
|
|
// present, while none went out for DLSSG_HOLD_IDLE_NS, with a DLL older than nx2sl_reflex2 or a limit Streamline
|
|
|
|
|
// refused, and for the rest of the run once the frames show Reflex does not hold it (dlssg_pace.h). The guest thread
|
|
|
|
|
// that presents decides and the present thread hands the limit to Streamline before its present (vk_dlssg_frame, under
|
|
|
|
|
// the present lock, which keeps Streamline's options calls on one thread at a time); the pacer stands aside only once
|
|
|
|
|
// Streamline took that limit.
|
|
|
|
|
#ifdef _WIN32
|
|
|
|
|
#include <windows.h>
|
|
|
|
|
#endif
|
|
|
|
|
@@ -27,6 +37,7 @@
|
|
|
|
|
#include <string.h>
|
|
|
|
|
|
|
|
|
|
#include "cfg.h"
|
|
|
|
|
#include "dlssg_pace.h"
|
|
|
|
|
#include "host.h"
|
|
|
|
|
#include "vk.h"
|
|
|
|
|
#include "vk_dlaa.h"
|
|
|
|
|
@@ -51,17 +62,27 @@ static struct {
|
|
|
|
|
PFN_nx2sl_submit_end submit_end;
|
|
|
|
|
PFN_nx2sl_shown shown;
|
|
|
|
|
PFN_nx2sl_reflex reflex;
|
|
|
|
|
PFN_nx2sl_reflex2 reflex2; // NULL with an older DLL: Reflex holds no frame limit, the pacer keeps it
|
|
|
|
|
uint32_t game; // the game's presents (vk_dlssg_game_present)
|
|
|
|
|
uint32_t cur; // the frame the present thread blits and presents next (vk_dlssg_present_frame)
|
|
|
|
|
uint32_t started; // the last frame vk_dlssg_frame_start started
|
|
|
|
|
uint64_t hosted_ns; // kern_now_ns after the last host present
|
|
|
|
|
// Reflex's frame limit, in microseconds (0 none). want: what vk_dlssg_pace asks for (the presenting guest thread
|
|
|
|
|
// writes it); set: what Streamline last took (written under the present lock, reflex_apply); refused: Streamline
|
|
|
|
|
// refused a limit, so the pacer keeps it for the run. Atomics.
|
|
|
|
|
uint32_t limit_want, limit_set;
|
|
|
|
|
int limit_refused;
|
|
|
|
|
DlssgPace pace; // the presenting guest thread's (vk_dlssg_pace)
|
|
|
|
|
int pace_said; // who held the limit as last logged: 1 Reflex, 0 the pacer, -1 not yet
|
|
|
|
|
// the frame starts Reflex's sleep held, and their time, since the last statistics line (stats); atomics
|
|
|
|
|
uint64_t n_hold, hold_ns, n_unheld;
|
|
|
|
|
PFN_nx2sl_shutdown shutdown;
|
|
|
|
|
PFN_vkCreateSwapchainKHR create_sc;
|
|
|
|
|
PFN_vkDestroySwapchainKHR destroy_sc;
|
|
|
|
|
PFN_vkGetSwapchainImagesKHR images;
|
|
|
|
|
PFN_vkAcquireNextImageKHR acquire;
|
|
|
|
|
PFN_vkQueuePresentKHR present;
|
|
|
|
|
} S = {.wanted = -1, .fail = DLSSG_NO_FILES, .shown_mult = 1};
|
|
|
|
|
} S = {.wanted = -1, .fail = DLSSG_NO_FILES, .shown_mult = 1, .pace_said = -1};
|
|
|
|
|
|
|
|
|
|
static void sl_line(const char *line) { rt_log("%s", line); }
|
|
|
|
|
|
|
|
|
|
@@ -75,6 +96,30 @@ static int reflex_mode(void) {
|
|
|
|
|
return m;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
// Reflex's mode and frame limit to Streamline: under the present lock (vk_dlssg_frame, vk_dlssg_create_swapchain), or
|
|
|
|
|
// once at the device's creation before any present. Streamline's slReflexSetOptions is not thread safe, and every
|
|
|
|
|
// caller is one of these. A limit Streamline refuses leaves the limit to the pacer for the run.
|
|
|
|
|
static void reflex_apply(uint32_t us) {
|
|
|
|
|
if (!S.reflex2) {
|
|
|
|
|
S.reflex(reflex_mode());
|
|
|
|
|
return;
|
|
|
|
|
}
|
|
|
|
|
if (__atomic_load_n(&S.limit_refused, __ATOMIC_ACQUIRE)) us = 0;
|
|
|
|
|
int ok = S.reflex2(reflex_mode(), us);
|
|
|
|
|
if (!ok && us) {
|
|
|
|
|
__atomic_store_n(&S.limit_refused, 1, __ATOMIC_RELEASE);
|
|
|
|
|
rt_log("dlssg: Streamline did not take Reflex's frame limit of %.3f ms: the game's own limiter keeps the limit "
|
|
|
|
|
"for the rest of the run", us / 1000.0);
|
|
|
|
|
ok = S.reflex2(reflex_mode(), 0), us = 0;
|
|
|
|
|
}
|
|
|
|
|
__atomic_store_n(&S.limit_set, ok ? us : 0, __ATOMIC_RELEASE);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
// Reflex may hold the frame limit: a DLL with nx2sl_reflex2 whose limit Streamline did not refuse.
|
|
|
|
|
static int limit_allowed(void) {
|
|
|
|
|
return S.reflex2 && !__atomic_load_n(&S.limit_refused, __ATOMIC_ACQUIRE);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
// With any upscaler or none: vk_dlaa.c makes the inputs either way (vk_dlaa_frame says which, at the start and at each
|
|
|
|
|
// change).
|
|
|
|
|
int vk_dlssg_wanted(void) {
|
|
|
|
|
@@ -112,6 +157,8 @@ int vk_dlssg_early(void) {
|
|
|
|
|
S.reflex = (PFN_nx2sl_reflex)(void *)GetProcAddress(m, "nx2sl_reflex");
|
|
|
|
|
S.frames_max = (PFN_nx2sl_frames_max)(void *)GetProcAddress(m, "nx2sl_frames_max"); // optional: 2x only without
|
|
|
|
|
if (!S.frames_max) rt_log("dlssg: nx2navi_dlssg.dll is older than multi frame generation: 2x at most");
|
|
|
|
|
S.reflex2 = (PFN_nx2sl_reflex2)(void *)GetProcAddress(m, "nx2sl_reflex2"); // optional: the pacer keeps the limit
|
|
|
|
|
if (!S.reflex2) rt_log("dlssg: nx2navi_dlssg.dll is older than Reflex's frame limit: the game's own limiter keeps it");
|
|
|
|
|
if (!ver || ver() != NX2SL_VERSION || !S.init || !S.gipa || !S.gdpa || !S.available || !S.frame || !S.marker ||
|
|
|
|
|
!S.sleep || !S.submit_end || !S.shown || !S.reflex) {
|
|
|
|
|
rt_log("dlssg: nx2navi_dlssg.dll is from another build: DLSS Frame Generation off");
|
|
|
|
|
@@ -166,7 +213,7 @@ void vk_dlssg_device_ready(VkPhysicalDevice physical, VkDevice dev) {
|
|
|
|
|
S.present = (PFN_vkQueuePresentKHR)g(dev, "vkQueuePresentKHR");
|
|
|
|
|
S.active = S.create_sc && S.destroy_sc && S.images && S.acquire && S.present;
|
|
|
|
|
rt_log("dlssg: %s", S.active ? "DLSS Frame Generation on the swapchain" : "the swapchain hooks are missing: off");
|
|
|
|
|
if (S.active) S.reflex(reflex_mode());
|
|
|
|
|
if (S.active) reflex_apply(0); // no swapchain and no present yet: the mode alone
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
int vk_dlssg_active(void) { return S.active; }
|
|
|
|
|
@@ -229,9 +276,11 @@ static int multiplier_wanted(void) {
|
|
|
|
|
// its plugins see the calls they hook (Reflex's frame timing and DLSS-G's presents). NULL keeps the loader's.
|
|
|
|
|
PFN_vkGetDeviceProcAddr vk_dlssg_dpa(void) { return S.loaded > 0 && S.gdpa ? S.gdpa() : NULL; }
|
|
|
|
|
|
|
|
|
|
// gfx_present.c create_swapchain, under the present and queue locks: the new swapchain has neither the mode nor the
|
|
|
|
|
// limit, so both go to Streamline again, the limit as the presenting guest thread last asked for it.
|
|
|
|
|
VkResult vk_dlssg_create_swapchain(VkDevice d, const VkSwapchainCreateInfoKHR *ci, VkSwapchainKHR *sc) {
|
|
|
|
|
VkResult r = S.create_sc(d, ci, NULL, sc);
|
|
|
|
|
if (r == VK_SUCCESS) S.reflex(reflex_mode());
|
|
|
|
|
if (r == VK_SUCCESS) reflex_apply(__atomic_load_n(&S.limit_want, __ATOMIC_ACQUIRE));
|
|
|
|
|
return r;
|
|
|
|
|
}
|
|
|
|
|
void vk_dlssg_destroy_swapchain(VkDevice d, VkSwapchainKHR sc) { S.destroy_sc(d, sc, NULL); }
|
|
|
|
|
@@ -240,34 +289,103 @@ VkResult vk_dlssg_acquire(VkDevice d, VkSwapchainKHR sc, uint64_t t, VkSemaphore
|
|
|
|
|
return S.acquire(d, sc, t, sem, VK_NULL_HANDLE, idx);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
// One line after the first 600 blits of a game frame and every 3600 after that (600 with NX2NAVI_TRACE=perf), on the
|
|
|
|
|
// present thread outside the queue lock (vk_dlssg_frame): who holds the frame limit, and how many frame starts Reflex's
|
|
|
|
|
// sleep held and for how long.
|
|
|
|
|
static void stats(void) {
|
|
|
|
|
static uint64_t shown, next = 600;
|
|
|
|
|
if (++shown < next) return;
|
|
|
|
|
next = shown + (rt_trace & RT_TRACE_PERF ? 600 : 3600);
|
|
|
|
|
uint64_t n = __atomic_exchange_n(&S.n_hold, 0, __ATOMIC_RELAXED);
|
|
|
|
|
uint64_t ns = __atomic_exchange_n(&S.hold_ns, 0, __ATOMIC_RELAXED);
|
|
|
|
|
uint64_t un = __atomic_exchange_n(&S.n_unheld, 0, __ATOMIC_RELAXED);
|
|
|
|
|
uint32_t us = __atomic_load_n(&S.limit_set, __ATOMIC_ACQUIRE);
|
|
|
|
|
char limit[96];
|
|
|
|
|
if (us) snprintf(limit, sizeof limit, "Reflex holds frame starts to %.3f ms", us / 1000.0);
|
|
|
|
|
else snprintf(limit, sizeof limit, "the game's own limiter holds the frame limit");
|
|
|
|
|
rt_log("dlssg: present %llu: %s; %llu frame starts held by Reflex's sleep, %.2f ms on average; %llu not held",
|
|
|
|
|
(unsigned long long)shown, limit, (unsigned long long)n, n ? (double)ns / (double)n / 1e6 : 0.0,
|
|
|
|
|
(unsigned long long)un);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
VkResult vk_dlssg_present(VkQueue q, const VkPresentInfoKHR *pi) {
|
|
|
|
|
S.marker(0, S.cur);
|
|
|
|
|
VkResult r = S.present(q, pi);
|
|
|
|
|
S.marker(1, S.cur);
|
|
|
|
|
__atomic_store_n(&S.hosted_ns, kern_now_ns(), __ATOMIC_RELAXED);
|
|
|
|
|
__atomic_store_n(&S.hosted_ns, kern_now_ns(), __ATOMIC_RELEASE);
|
|
|
|
|
return r;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
// Reflex holds the frame's start until the time the driver computes from the measured render and queue times, so the
|
|
|
|
|
// game's CPU work ends about when the GPU is free for it; then the frame's first markers. Once a frame: the game may
|
|
|
|
|
// acquire again before it presents. No hold while no host present went out for HOLD_IDLE_NS (the window minimized:
|
|
|
|
|
// gfx_present.c skips the host presents while the game runs on): the driver then has no present to time the frame by,
|
|
|
|
|
// and the sleep would wait out Streamline's half-second timeout each frame.
|
|
|
|
|
#define HOLD_IDLE_NS 200000000ull
|
|
|
|
|
|
|
|
|
|
// Turning generation on or off is an slDLSSGSetOptions call and Streamline's own rebuild, and it can be seen: around a
|
|
|
|
|
// menu, a fade or a swapchain change the depth and motion-vector views come and go for a frame or two. Following them
|
|
|
|
|
// frame by frame switched generation off and on dozens of times a second (a run logged 32 changes, in pairs, a frame
|
|
|
|
|
// apart), so a change waits until the new state has held for FG_SETTLE_FRAMES frames.
|
|
|
|
|
#define FG_SETTLE_FRAMES 12
|
|
|
|
|
|
|
|
|
|
// Reflex holds the frame's start until the time the driver computes from the measured render and queue times, and no
|
|
|
|
|
// sooner than its frame limit after the frame before (vk_dlssg_pace), so the game's CPU work ends about when the GPU is
|
|
|
|
|
// free for it; then the frame's first markers. Once a frame: the game may acquire again before it presents. No hold
|
|
|
|
|
// while no host present went out for DLSSG_HOLD_IDLE_NS (the window minimized: gfx_present.c skips the host presents
|
|
|
|
|
// while the game runs on): the driver then has no present to time the frame by, and the sleep would wait out
|
|
|
|
|
// Streamline's half-second timeout each frame. The guest thread gave its core up for the acquire (NVN_BLOCKING). The
|
|
|
|
|
// sleep counts as the pacer's wait (PERF_PACE), whose place it takes while Reflex holds the limit, on whichever guest
|
|
|
|
|
// thread acquires (perf_end_any), as the acquire's own waits do.
|
|
|
|
|
void vk_dlssg_frame_start(void) {
|
|
|
|
|
if (!S.active) return;
|
|
|
|
|
uint32_t f = __atomic_load_n(&S.game, __ATOMIC_RELAXED) + 1;
|
|
|
|
|
if (f == S.started) return;
|
|
|
|
|
S.started = f;
|
|
|
|
|
uint64_t hosted = __atomic_load_n(&S.hosted_ns, __ATOMIC_RELAXED);
|
|
|
|
|
S.sleep(f, hosted && kern_now_ns() - hosted < HOLD_IDLE_NS);
|
|
|
|
|
uint64_t hosted = __atomic_load_n(&S.hosted_ns, __ATOMIC_ACQUIRE), t0 = kern_now_ns(); // in this order: t0 >= hosted
|
|
|
|
|
int hold = hosted && t0 - hosted < DLSSG_HOLD_IDLE_NS;
|
|
|
|
|
uint64_t p0 = hold ? perf_begin() : 0;
|
|
|
|
|
S.sleep(f, hold);
|
|
|
|
|
if (!hold) {
|
|
|
|
|
__atomic_add_fetch(&S.n_unheld, 1, __ATOMIC_RELAXED);
|
|
|
|
|
return;
|
|
|
|
|
}
|
|
|
|
|
perf_end_any(PERF_PACE, p0);
|
|
|
|
|
__atomic_add_fetch(&S.hold_ns, kern_now_ns() - t0, __ATOMIC_RELAXED);
|
|
|
|
|
__atomic_add_fetch(&S.n_hold, 1, __ATOMIC_RELAXED);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
// Who holds the frame limit, as a log line when it changes (the first 40). why: the reason the pacer holds it.
|
|
|
|
|
static void pace_say(int reflex, uint32_t us, const char *why) {
|
|
|
|
|
static int lines;
|
|
|
|
|
if (S.pace_said == reflex || lines >= 40) return;
|
|
|
|
|
S.pace_said = reflex, lines++;
|
|
|
|
|
if (reflex)
|
|
|
|
|
rt_log("frame rate: Reflex holds the frame limit where each frame starts (%.3f ms%s); the game's own limiter "
|
|
|
|
|
"keeps only its ceiling", us / 1000.0, S.pace.shown ? ", the frames on screen" : "");
|
|
|
|
|
else rt_log("frame rate: the game's own limiter (DLSS Frame Generation: %s)", why);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
int vk_dlssg_pace(uint64_t period_ns) {
|
|
|
|
|
if (!S.active) return 0;
|
|
|
|
|
uint64_t hosted = __atomic_load_n(&S.hosted_ns, __ATOMIC_ACQUIRE), now = kern_now_ns();
|
|
|
|
|
int allowed = limit_allowed(), mult = vk_dlssg_multiplier(), found;
|
|
|
|
|
uint32_t applied = __atomic_load_n(&S.limit_set, __ATOMIC_ACQUIRE), want;
|
|
|
|
|
int held = dlssg_pace_step(&S.pace, now, period_ns, mult, hosted, allowed, applied, &want, &found);
|
|
|
|
|
__atomic_store_n(&S.limit_want, want, __ATOMIC_RELEASE); // the present thread hands it over (vk_dlssg_frame)
|
|
|
|
|
double ms = (double)period_ns / 1e6;
|
|
|
|
|
if (found == DLSSG_PACE_FAST)
|
|
|
|
|
rt_log("dlssg: Reflex does not hold the frame limit (over half of %d frames came sooner than three quarters of "
|
|
|
|
|
"%.2f ms): the game's own limiter holds it for the rest of the run", DLSSG_PACE_WINDOW, ms);
|
|
|
|
|
else if (found == DLSSG_PACE_SHOWN)
|
|
|
|
|
rt_log("dlssg: Reflex held the frames on screen to the limit, not the frames the game draws (over half of %d "
|
|
|
|
|
"came about %d times %.2f ms apart): it is given %.2f ms over the multiplier from now on",
|
|
|
|
|
DLSSG_PACE_WINDOW, mult, ms, ms);
|
|
|
|
|
else if (found == DLSSG_PACE_SLOW)
|
|
|
|
|
rt_log("dlssg: the frames still came about %d times %.2f ms apart: the game's own limiter holds the limit for the "
|
|
|
|
|
"rest of the run", mult, ms);
|
|
|
|
|
if (held) pace_say(1, want, NULL);
|
|
|
|
|
else if (!want) // (a limit Streamline has yet to take is no change: the present thread hands it over next)
|
|
|
|
|
pace_say(0, 0, !allowed ? (!S.reflex2 ? "nx2navi_dlssg.dll is older than Reflex's frame limit"
|
|
|
|
|
: "Streamline refused the limit")
|
|
|
|
|
: S.pace.bad ? "Reflex did not hold the limit"
|
|
|
|
|
: !period_ns ? "a movie plays, or no limit"
|
|
|
|
|
: hosted ? "no host present for 200 ms"
|
|
|
|
|
: "no host present yet");
|
|
|
|
|
return held;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
void vk_dlssg_game_present(void) { __atomic_add_fetch(&S.game, 1, __ATOMIC_RELAXED); }
|
|
|
|
|
@@ -294,6 +412,10 @@ void vk_dlssg_frame(VkCommandBuffer cb, VkExtent2D ext) {
|
|
|
|
|
else want = S.mode; // hold the state it has until the new one stays
|
|
|
|
|
int on = want, mult = multiplier_wanted();
|
|
|
|
|
__atomic_store_n(&S.shown_mult, on ? mult : 1, __ATOMIC_RELAXED); // the pacer's divisor (frame_rate.c)
|
|
|
|
|
// Reflex's frame limit as the presenting guest thread last asked for it (vk_dlssg_pace), before this present
|
|
|
|
|
uint32_t limit = __atomic_load_n(&S.limit_want, __ATOMIC_ACQUIRE);
|
|
|
|
|
if (S.reflex2 && limit != __atomic_load_n(&S.limit_set, __ATOMIC_ACQUIRE)) reflex_apply(limit);
|
|
|
|
|
stats();
|
|
|
|
|
Nx2SlImage zd = {d.image, dv, d.format, d.width, d.height, VK_IMAGE_LAYOUT_GENERAL,
|
|
|
|
|
VK_IMAGE_USAGE_SAMPLED_BIT | VK_IMAGE_USAGE_DEPTH_STENCIL_ATTACHMENT_BIT};
|
|
|
|
|
Nx2SlImage zm = {m.image, mvv, m.format, m.width, m.height, VK_IMAGE_LAYOUT_GENERAL,
|
|
|
|
|
@@ -322,4 +444,5 @@ void vk_dlssg_frame(VkCommandBuffer cb, VkExtent2D ext) {
|
|
|
|
|
void vk_dlssg_release(void) {
|
|
|
|
|
if (S.loaded > 0 && S.shutdown) S.shutdown();
|
|
|
|
|
S.active = 0;
|
|
|
|
|
__atomic_store_n(&S.limit_set, 0, __ATOMIC_RELEASE); // a device made again starts without a limit
|
|
|
|
|
}
|
|
|
|
|
|