diff --git a/runtime/cfg.c b/runtime/cfg.c index 17817904..3539201a 100644 --- a/runtime/cfg.c +++ b/runtime/cfg.c @@ -49,7 +49,7 @@ static const char *const known[] = { "MENU_CURSOR", "MENU_CURSOR_LOG", "MENU_TEST_DIR", "MENU_TEST_SET", "MINIMAL_LAYOUT", "MIRROR_GAP", "MODS_DIR", "MODS_DISABLED", "MODS_ORDER", "MODS_REBUILD", "MOTION", "MOUSE_MODE", "MOUSE_DIRECT_PATCH", "MOUSE_SENS", "MOVIE_HOST", "MOVIE_PACE", "MVOBJ_ALL", "MVOBJ_BANKS", "MVOBJ_EQUAL", "MVOBJ_EXACT", "MVOBJ_EXEC", "MVOBJ_NOC4", "MVOBJ_ONLY", "MVOBJ_TIMES", "MVPREV_CHECK", "MVPREV_GROW", "MVPREV_SKIP", "MVPREV_TRUST", "MV_CHECK", "MV_SURVEY", - "ONE_PER_CORE", "OPERATION_MODE", "OUTPUT_RES", "PAD_LAYOUT", "PACE_HZ", "PASS_CRUMBS", "PATCH_OUTPUT", "PATCH_RES_FIXED", "PATCH_SCENE", "PATCH_WIDE_ASPECT", "PATCH_WIDE_HUD", "PATCH_WIDE_MOVIE", "PATCH_WIDE_OUT", "PATCH_WIDE_SCENE", "PCSS", "PCSS_K", "PERF_OVERLAY", "PERF_SLOW_MS", "PIPELINE_CACHE", "PIPE_MEMO", "PIPE_PREBUILD", "PIPE_SKIP", "PIPE_SYNC", "PIPE_WAIT", "POWER_FULL", "TEX_SAME", + "ONE_PER_CORE", "OPERATION_MODE", "OUTPUT_RES", "PAD_LAYOUT", "PACE_HZ", "PASS_CRUMBS", "PATCH_OUTPUT", "PATCH_RES_FIXED", "PATCH_SCENE", "PATCH_WIDE_ASPECT", "PATCH_WIDE_HUD", "PATCH_WIDE_MOVIE", "PATCH_WIDE_OUT", "PATCH_WIDE_SCENE", "PCSS", "PCSS_K", "PERF_OVERLAY", "PERF_SLOW_MS", "PIPELINE_CACHE", "PIPE_MEMO", "PIPE_PREBUILD", "PIPE_SKIP", "PIPE_SYNC", "PIPE_WAIT", "POWER_FULL", "TEX_SAME", "PRESENT_HELD", "HELD_SYNC", "PREWARM_FULL", "PREWARM_WAIT_MS", "PREWARM_XLATE", "PROBE_MOVIE", "PROBE_MOVIE_SHOT", "PROFILE", "PROFILE_CHAINS", "PROFILE_DIR", "PROFILE_FRAMES", "PROFILE_MAIN", "PROFILE_RENDER", "PROMPTS", "PUSH_SKIP", "PUSH_STAGE", "RDOC", "RDOC_DIR", "RDOC_DLL", "REALTIME", "REC_END", "REEXEC", "REFLEX", "RENDER_SCALE", "REPLAY_ASYNC", "RTSS", diff --git a/runtime/vk_backend.c b/runtime/vk_backend.c index a7aa7161..70b8a5cc 100644 --- a/runtime/vk_backend.c +++ b/runtime/vk_backend.c @@ -194,11 +194,73 @@ uint64_t gfx_replayed_submits(void) { return v; } +// ---- a present that waits for held work (event order, vk_exec.c) +// On the console a present is queued behind its queue's work and goes out once the GPU has run the frame, including +// work that waited for an event. The replay holds such work (vk_exec.c, "event order across the game's queues") until +// the wait holds, and the present went out at once: in Kokiri Forest dialogue (Saria), several presents a second came +// with the frame's whole submission held (4 held submissions, nothing drawn since the last present) and showed the +// picture from before, a flash of the whole picture; the frame was then drawn after its present, in the present +// thread's empty submission, next to the following frame. So with work held at a present, what can go on now goes +// first, in a submission of its own (held_resume); if work is still held, the present waits and goes out right after +// the submission that replays the last of it, at the next present, or after PH_MAX submissions at the latest. Only with +// the replay on the submitting thread, as the event order. NX2NAVI_PRESENT_HELD=0: every present goes out at once. +#define PH_MAX 8 +static struct { + int on; // a present waits + const tex_t *t; + int crop[4], has_crop; + uint64_t at_ns, queued, frame, since; // since: vk_exec_submit_seq when it began to wait + uint64_t waited, ran, after, capped, next, logged; // presents that waited; held work run first at a present; + // presents out after the held work, at PH_MAX, at the next present +} PH; + +static int present_held_on(void) { + static int on = -1; + if (on < 0) on = !gfx_replay_async() && rt_knob("PRESENT_HELD", "1"); + return on; +} + +static uint64_t submit_sync(const uint64_t *handles, int n); + +// The held work that can go on now, in a submission of its own (vk_exec_record syncs it like any other: held_sync). +static int held_resume(void) { + if (!vk_exec_held() || !vk_exec_held_ready()) return 0; + submit_sync(NULL, 0); + PH.ran++; + return 1; +} + +static void ph_flush(uint64_t *why) { + if (!PH.on) return; + PH.on = 0, (*why)++; + if (PH.logged < 16) + PH.logged++, rt_log("vk: the present of frame %llu went out %llu submission(s) after the game's present call, %d " + "held submissions left (%s)", (unsigned long long)PH.frame, + (unsigned long long)(vk_exec_submit_seq - PH.since), vk_exec_held(), + why == &PH.after ? "the held work was replayed" : why == &PH.capped ? "PH_MAX reached" + : "the next present came"); + present_image(PH.t, PH.has_crop ? PH.crop : NULL, PH.at_ns, PH.queued, PH.frame, 0); + if (PH.waited % 600 == 0) + rt_log("vk: presents that waited for held work: %llu (held work run at the present %llu times; out after it %llu, " + "at %d submissions %llu, at the next present %llu)", (unsigned long long)PH.waited, + (unsigned long long)PH.ran, (unsigned long long)PH.after, PH_MAX, (unsigned long long)PH.capped, + (unsigned long long)PH.next); +} + static uint64_t submit_sync(const uint64_t *handles, int n) { vk_sync_start(); + if (PH.on && n) { // a present waits: what can go on goes first, then the present, then this submission + held_resume(); + if (!vk_exec_held()) ph_flush(&PH.after); + } vk_present_drain(); vk_texture_new_submit(); - return vk_sync_submit(handles, n); + uint64_t f = vk_sync_submit(handles, n); + if (PH.on && n) { + if (!vk_exec_held()) ph_flush(&PH.after); + else if (vk_exec_submit_seq - PH.since >= PH_MAX) ph_flush(&PH.capped); + } + return f; } static void replay_main(void *arg) { @@ -336,7 +398,19 @@ static void vk_be_present(const tex_t *t, const int crop[4], uint64_t at_ns) { uint64_t frame = __atomic_add_fetch(&gfx_counters.frames, 1, __ATOMIC_RELAXED); vk_dlssg_submitted(frame); perf_present(frame); // before vk_exec_frame_log, which resets the frame's exec counts the flight recorder reads - present_image(t, crop, at_ns, kern_now_ns(), frame, 0); + uint64_t queued = kern_now_ns(); + if (present_held_on()) { // present_held + vk_present_drain(); // the present thread's empty submission may run held work: done before it is read + if (PH.on) held_resume(), ph_flush(&PH.next); // the last present still waits: out now + if (vk_exec_held()) held_resume(); + if (vk_exec_held()) { + PH.on = 1, PH.t = t, PH.has_crop = crop != NULL, PH.at_ns = at_ns, PH.queued = queued, PH.frame = frame; + if (crop) memcpy(PH.crop, crop, sizeof PH.crop); + PH.since = vk_exec_submit_seq, PH.waited++; + return; + } + } + present_image(t, crop, at_ns, queued, frame, 0); return; } // Frame bound: the replay thread handled the previous present before this one is queued. diff --git a/runtime/vk_exec.c b/runtime/vk_exec.c index dcbdd690..0e0aca64 100644 --- a/runtime/vk_exec.c +++ b/runtime/vk_exec.c @@ -988,6 +988,23 @@ static int cont_ready(const Cont *c) { int vk_exec_held(void) { return evo_pending; } +int vk_exec_held_ready(void) { + for (int s = 0; evo_pending && s < EVO_QUEUES; s++) + if (evq[s].head && cont_ready(evq[s].head)) return 1; + return 0; +} + +// Held work that goes on in a submission without commands of its own (the present thread's empty one after its blit, +// vk_backend.c present_main, or the one a waiting present makes, present_held) gets what any submission's recording +// gets: the VRAM mirror sync before and the write-back after (vk_mem_mirror_begin/end), and a uniform copy (vk_usnap). +// Without them its draws read mirrors that missed the CPU's writes since the last submission, and its GPU writes never +// went back to guest memory: the next vk_mem_mirror_begin dropped the write-back list. NX2NAVI_HELD_SYNC=0: as before. +static int held_sync(void) { + static int on = -1; + if (on < 0) on = rt_knob("HELD_SYNC", "1"); + return on; +} + // Walks the continuation from where it stopped; 1 when it stopped at another wait (c->i, c->at updated), 0 when done. static int cont_walk(VkExec *ex, Cont *c) { if (c->at && !vk_exec_event_met(nvn_op_payload(c->at))) { @@ -1176,7 +1193,8 @@ int vk_exec_record(VkCommandBuffer cb, const uint64_t *handles, int n, uint64_t int evo = evo_enabled() && gfx_submit_queue; int slot = evo ? evq_slot(gfx_submit_queue) : -1; if (evo && slot < 0) evo = 0; - if (n) { + int synced = n || (evo_pending && held_sync() && vk_exec_held_ready()); // held_sync + if (synced) { vk_mem_mirror_begin(); if (evo_pending) { // the uniform snapshot covers what held submissions bind too: they may go on here int tot = n; @@ -1184,7 +1202,7 @@ int vk_exec_record(VkCommandBuffer cb, const uint64_t *handles, int n, uint64_t for (Cont *c = evq[s].head; c; c = c->next) tot += c->n; uint64_t *all = malloc(sizeof *all * (size_t)tot); if (!all) rt_fatal("vk: out of memory (snapshot handles)"); - memcpy(all, handles, sizeof *all * (size_t)n); + if (n) memcpy(all, handles, sizeof *all * (size_t)n); int k = n; for (int s = 0; s < EVO_QUEUES; s++) for (Cont *c = evq[s].head; c; c = c->next) memcpy(all + k, c->h, sizeof *all * (size_t)c->n), k += c->n; @@ -1211,7 +1229,7 @@ int vk_exec_record(VkCommandBuffer cb, const uint64_t *handles, int n, uint64_t vk_exec_pass_end(ex); x_here = 0; if (ex->recorded) vk_exec_barrier(ex); // later submissions see this one's writes - if (n) ex->recorded += vk_mem_mirror_end(ex->cb, fence), vk_usnap_end(fence); // VRAM mirror bytes the GPU wrote go back to guest memory + if (synced) ex->recorded += vk_mem_mirror_end(ex->cb, fence), vk_usnap_end(fence); // VRAM mirror bytes the GPU wrote go back to guest memory if (ex->nviews) { ViewList *l = malloc(sizeof *l + sizeof(VkImageView) * (size_t)ex->nviews); if (!l) rt_fatal("vk: out of memory"); diff --git a/runtime/vk_exec.h b/runtime/vk_exec.h index 1076f9ca..82aa07b8 100644 --- a/runtime/vk_exec.h +++ b/runtime/vk_exec.h @@ -210,6 +210,7 @@ extern int vk_exec_signalled; // set by every replayed SignalEve void vk_exec_event_stats(uint64_t *waits, uint64_t *unmet, uint64_t *late, uint64_t *late_subs); extern uint64_t vk_exec_submit_seq; // replay thread: submissions replayed so far int vk_exec_held(void); // replay thread: held submissions waiting for a signal (event order) +int vk_exec_held_ready(void); // ... and one of them can go on now (vk_backend.c present_held) // vk_dlaa.c: once DLSS has scaled the scene this frame, passes larger than the scene's light target vk_dlaa_swap_img // sample DLSS's output vk_dlaa_swap_view in its place, so the game's scaling draw scales DLSS's picture. extern const VkTexImage *vk_dlaa_swap_img;