diff --git a/runtime/gfx.h b/runtime/gfx.h index 6788b5b9..98266c11 100644 --- a/runtime/gfx.h +++ b/runtime/gfx.h @@ -109,7 +109,9 @@ typedef struct { uint64_t (*submit)(const uint64_t *handles, int n); // replays; returns this submission's fence value int (*fence_wait)(uint64_t value, uint64_t timeout_ns); // 1 reached; caller has given its core up uint64_t (*fence_done)(void); // highest value whose side effects are written - void (*present)(const tex_t *t, const int crop[4]); // queues the present; returns at once + // Queues the present and returns at once; the host present goes out at at_ns (kern_now_ns clock), at once when that + // has passed or at_ns is 0. + void (*present)(const tex_t *t, const int crop[4], uint64_t at_ns); void (*finish)(void); void (*read_texels)(const tex_t *t, const view_t *v, const NVNcopyRegion *r, uint8_t *dst, uint64_t row, uint64_t img); void (*write_texels)(const tex_t *t, const view_t *v, const NVNcopyRegion *r, const uint8_t *src, uint64_t row, uint64_t img); diff --git a/runtime/gfx_null.c b/runtime/gfx_null.c index 5e33acd8..847a82f7 100644 --- a/runtime/gfx_null.c +++ b/runtime/gfx_null.c @@ -111,8 +111,8 @@ static int null_fence_wait(uint64_t value, uint64_t timeout_ns) { static uint64_t null_fence_done(void) { return __atomic_load_n(&fence, __ATOMIC_ACQUIRE); } -static void null_present(const tex_t *t, const int crop[4]) { - (void)t, (void)crop; +static void null_present(const tex_t *t, const int crop[4], uint64_t at_ns) { + (void)t, (void)crop, (void)at_ns; __atomic_fetch_add(&gfx_counters.frames, 1, __ATOMIC_RELAXED); } diff --git a/runtime/gfx_window.c b/runtime/gfx_window.c index d22d84ec..3949a950 100644 --- a/runtime/gfx_window.c +++ b/runtime/gfx_window.c @@ -58,6 +58,8 @@ static VmaAllocation g_cap_alloc; static uint8_t *g_cap_ptr; static VkDeviceSize g_cap_size; static int g_cap_w, g_cap_h, g_cap_valid; +static int g_flip_on; // vk_present_blit submitted the blit of swapchain image g_flip_idx; vk_present_flip presents it +static uint32_t g_flip_idx; // ---- TOTK_FLIGHT thumbnails (flight.c; g_pl): each present also blits the swapchain image down into slot frame % g_th_n // of a host-visible ring. A slot's tag names the frame it holds complete; recording a new frame clears the tag first, @@ -261,6 +263,21 @@ static VkPresentModeKHR pick_present_mode(VkPhysicalDevice pd) { return VK_PRESENT_MODE_FIFO_KHR; } +// Queues the present of a blit vk_present_blit left waiting (g_pl held). A swapchain rebuild and the next blit flush it +// first; the device release drops it. +static void flip_locked(void) { + if (!g_flip_on) return; + g_flip_on = 0; + if (!g_sc) return; + VkPresentInfoKHR pi = {.sType = VK_STRUCTURE_TYPE_PRESENT_INFO_KHR, .waitSemaphoreCount = 1, + .pWaitSemaphores = &g_render_done[g_flip_idx], .swapchainCount = 1, .pSwapchains = &g_sc, + .pImageIndices = &g_flip_idx}; + vk_queue_lock(); + VkResult r = vkQueuePresentKHR(vk_ctx()->gfx_queue, &pi); + vk_queue_unlock(); + if (r == VK_ERROR_OUT_OF_DATE_KHR || r == VK_SUBOPTIMAL_KHR) InterlockedExchange(&g_dirty, 1); +} + static void free_capture(void) { VkCtx *c = vk_ctx(); if (g_cap_buf && c) vmaDestroyBuffer(c->vma, g_cap_buf, g_cap_alloc); @@ -272,6 +289,7 @@ static void free_capture(void) { // Returns 1 with a usable swapchain, 0 when the window has no area (minimised). Called with g_pl held. static int create_swapchain(void) { + flip_locked(); // the acquired image goes out before its swapchain is replaced VkCtx *c = vk_ctx(); VkSurfaceCapabilitiesKHR caps; if (vkGetPhysicalDeviceSurfaceCapabilitiesKHR(c->phys, g_surface, &caps) != VK_SUCCESS) return 0; @@ -479,12 +497,12 @@ int vk_present_captured(const uint8_t **px, int *w, int *h, VkFormat *fmt) { return ok; } -void vk_present_image(VkImage src, VkImageLayout layout, VkFormat fmt, int w, int h, const int crop[4]) { - (void)fmt; +static void present_image(VkImage src, VkImageLayout layout, int w, int h, const int crop[4], int defer) { int general = layout == VK_IMAGE_LAYOUT_GENERAL; gfx_window_start(); VkCtx *c = vk_ctx(); EnterCriticalSection(&g_pl); + flip_locked(); if (!g_sc || InterlockedCompareExchange(&g_dirty, 0, 0)) { if (!IsIconic(g_hwnd) && !create_swapchain() && !g_sc) goto out; } @@ -569,16 +587,14 @@ void vk_present_image(VkImage src, VkImageLayout layout, VkFormat fmt, int w, in .pSignalSemaphoreInfos = &sig}; vk_queue_lock(); r = vkQueueSubmit2(c->gfx_queue, 1, &si, g_fence[slot]); + vk_queue_unlock(); if (r == VK_SUCCESS) { - VkPresentInfoKHR pi = {.sType = VK_STRUCTURE_TYPE_PRESENT_INFO_KHR, .waitSemaphoreCount = 1, - .pWaitSemaphores = &g_render_done[idx], .swapchainCount = 1, .pSwapchains = &g_sc, - .pImageIndices = &idx}; - r = vkQueuePresentKHR(c->gfx_queue, &pi); - if (r == VK_ERROR_OUT_OF_DATE_KHR || r == VK_SUBOPTIMAL_KHR) InterlockedExchange(&g_dirty, 1); + g_flip_on = 1; + g_flip_idx = idx; + if (!defer) flip_locked(); } else { rt_log("gfx: present submit failed (%d)", (int)r); } - vk_queue_unlock(); g_frame++; if (cap) { vkWaitForFences(c->device, 1, &g_fence[slot], VK_TRUE, 5000000000ull); @@ -591,6 +607,21 @@ out: LeaveCriticalSection(&g_pl); } +void vk_present_image(VkImage src, VkImageLayout layout, VkFormat fmt, int w, int h, const int crop[4]) { + (void)fmt; + present_image(src, layout, w, h, crop, 0); +} + +void vk_present_blit(VkImage src, VkImageLayout layout, int w, int h, const int crop[4]) { + present_image(src, layout, w, h, crop, 1); +} + +void vk_present_flip(void) { + EnterCriticalSection(&g_pl); + flip_locked(); + LeaveCriticalSection(&g_pl); +} + void gfx_window_resize(int cw, int chh) { gfx_window_start(); RECT r = {0, 0, cw, chh}; @@ -609,6 +640,7 @@ void gfx_window_release_vk(void) { vk_queue_lock(); vkDeviceWaitIdle(c->device); vk_queue_unlock(); + g_flip_on = 0; // its blit is done (device idle); the swapchain goes away unpresented free_capture(); free_thumbs(); for (int i = 0; i < FRAMES; i++) { diff --git a/runtime/host.h b/runtime/host.h index 0c1005dc..bd7cff84 100644 --- a/runtime/host.h +++ b/runtime/host.h @@ -18,8 +18,8 @@ // ---- logging and results void rt_log(const char *fmt, ...) __attribute__((format(printf, 1, 2))); // "[host] \n" to stderr, one write enum { RT_TRACE_SVC = 1, RT_TRACE_HOSTCALL = 2, RT_TRACE_IPC = 4, RT_TRACE_FS = 8, RT_TRACE_GFX = 16, RT_TRACE_PERF = 32, - RT_TRACE_SCHED = 64, RT_TRACE_AUDIO = 128 }; -extern unsigned rt_trace; // from TOTK_TRACE=svc,host,ipc,fs,gfx,perf,sched (or all) + RT_TRACE_SCHED = 64, RT_TRACE_AUDIO = 128, RT_TRACE_PRESENT = 256 }; +extern unsigned rt_trace; // from TOTK_TRACE=svc,host,ipc,fs,gfx,perf,sched,audio,present (or all) // prof_win.c: TOTK_PROFILE= sampling profiler; TOTK_TRACE=perf frame timing (waits of the render thread) // PERF_TEX: texture uploads on the render thread (deswizzle, decode, staging), PERF_ASTC included enum { PERF_PACE, PERF_FENCE, PERF_DRAIN, PERF_PIPE, PERF_XLATE, PERF_TEX, PERF_ASTC, PERF_N }; diff --git a/runtime/main.c b/runtime/main.c index a4ec7910..c813415c 100644 --- a/runtime/main.c +++ b/runtime/main.c @@ -50,13 +50,14 @@ static void parse_trace(void) { if (!e) return; static const struct { const char *name; unsigned bit; } names[] = { {"svc", RT_TRACE_SVC}, {"host", RT_TRACE_HOSTCALL}, {"ipc", RT_TRACE_IPC}, {"fs", RT_TRACE_FS}, - {"gfx", RT_TRACE_GFX}, {"perf", RT_TRACE_PERF}, {"sched", RT_TRACE_SCHED}, {"audio", RT_TRACE_AUDIO}, {"all", ~0u}}; + {"gfx", RT_TRACE_GFX}, {"perf", RT_TRACE_PERF}, {"sched", RT_TRACE_SCHED}, {"audio", RT_TRACE_AUDIO}, + {"present", RT_TRACE_PRESENT}, {"all", ~0u}}; for (const char *p = e; *p;) { size_t n = strcspn(p, ","); int known = 0; for (unsigned i = 0; i < sizeof names / sizeof *names; i++) if (strlen(names[i].name) == n && !strncmp(p, names[i].name, n)) rt_trace |= names[i].bit, known = 1; - if (!known && n) rt_log("TOTK_TRACE: unknown item '%.*s' (svc, host, ipc, fs, gfx, perf, sched, audio, all)", (int)n, p); + if (!known && n) rt_log("TOTK_TRACE: unknown item '%.*s' (svc, host, ipc, fs, gfx, perf, sched, audio, present, all)", (int)n, p); p += n + (p[n] == ','); } } diff --git a/runtime/nvn_api_obj.c b/runtime/nvn_api_obj.c index 89c660b2..17a1c04e 100644 --- a/runtime/nvn_api_obj.c +++ b/runtime/nvn_api_obj.c @@ -663,7 +663,7 @@ static void sleep_until(uint64_t deadline) { // NVNwindowAcquireTextureResult nvnWindowAcquireTexture(NVNwindow *w, NVNsync *s, int *index): blocks here, not in the // present, until the image's previous present plus one period has passed (the game often presents with a lock held). -// Presents return at once, so the image is free as soon as that time is reached. +// That is the time the next frame goes to the display, so the image is free as soon as that time is reached. NVN_API(nvnWindowAcquireTexture) { win_t *o = arg_p(c, 0); sync_t *s = arg_p(c, 1); @@ -686,8 +686,10 @@ NVN_API(nvnWindowAcquireTexture) { ret_x(c, NVN_WINDOW_ACQUIRE_TEXTURE_RESULT_SUCCESS); } -// void nvnQueuePresentTexture(NVNqueue *q, NVNwindow *w, int index): queues the copy and returns at once; the display -// time comes from the pacer and frees the image for the next acquire +// void nvnQueuePresentTexture(NVNqueue *q, NVNwindow *w, int index): queues the copy and returns at once. The display +// time comes from the pacer: the back end's present thread holds the host present until then (back-edge pacing, as the +// Switch's display flips at vblank), so the present cadence does not follow the replay time; one period later the +// image is free for the next acquire. Added latency: the slack of the frame (period minus its work), as on the Switch. NVN_API(nvnQueuePresentTexture) { win_t *o = arg_p(c, 1); int idx = (int)arg_x(c, 2); @@ -697,10 +699,10 @@ NVN_API(nvnQueuePresentTexture) { rt_fatal("nvn: QueuePresentTexture of image %d on window %p", idx, (void *)o); o->presents++; const tex_t *t = (const tex_t *)o->tex[idx]; - gfx_backend()->present(t, o->crop); - o->ticket[idx] = o->presents; uint64_t period = present_period(o), now = kern_now_ns(); uint64_t slot = now + pace(&o->pace, now, period); + gfx_backend()->present(t, o->crop, slot); + o->ticket[idx] = o->presents; o->avail[idx] = slot + period; frame_step_present(slot, o->interval); // frame_rate.c: the real-time step follows the display times rt_frame_presented(t, o->presents); diff --git a/runtime/vk.h b/runtime/vk.h index 02b48aac..09836c63 100644 --- a/runtime/vk.h +++ b/runtime/vk.h @@ -78,6 +78,10 @@ int vk_selftest(void); // 0 on success // the blit). All its writes must be submitted to gfx_queue before the call (queue order does the rest). Starts the // window on first use. A minimised window or a lost swapchain skips the frame. Calls serialise on an internal lock. void vk_present_image(VkImage src, VkImageLayout layout, VkFormat fmt, int w, int h, const int crop[4]); +// vk_present_image split in two: vk_present_blit submits the blit and leaves the present waiting, vk_present_flip +// queues it. The next blit or a swapchain rebuild queues a waiting present first. +void vk_present_blit(VkImage src, VkImageLayout layout, int w, int h, const int crop[4]); +void vk_present_flip(void); // Every submission to ctx->gfx_queue (and xfer_queue when shared) takes this lock; vk_present_image and the swapchain // rebuild do. Recursive. void vk_queue_lock(void); diff --git a/runtime/vk_backend.c b/runtime/vk_backend.c index 730a94e2..7b18a945 100644 --- a/runtime/vk_backend.c +++ b/runtime/vk_backend.c @@ -5,7 +5,11 @@ // Present: the game texture is resolved on the calling thread and its blit is handed to a present thread, so // nvnQueuePresentTexture returns at once (section 5). Queue order does the rest: the submissions that wrote the texture // are already on gfx_queue, and every call that may write or free GPU state the blit reads (submit, finish, pool and -// texture teardown, texel writes) first waits until the queued present was submitted (vk_present_drain). +// texture teardown, texel writes) first waits until the queued blit was submitted (vk_present_drain). +// +// Back-edge pacing: the present thread submits the blit at once, then holds the host present (vkQueuePresentKHR) until +// the frame's display time from the pacer (nvn_api_obj.c), so present-to-present intervals stay even whatever the +// replay took. The blit is already on the queue, so the wait blocks no submission. #include #include "flight.h" @@ -17,15 +21,27 @@ #define WEAK __attribute__((weak)) -typedef struct { VkImage image; VkFormat format; int w, h, has_crop, crop[4]; uint64_t frame; } PresentJob; +typedef struct { VkImage image; VkFormat format; int w, h, has_crop, crop[4]; uint64_t frame, at, queued; } PresentJob; static SRWLOCK pl = SRWLOCK_INIT; static CONDITION_VARIABLE pcv = CONDITION_VARIABLE_INIT; // job queued, job taken, job submitted static PresentJob job; static int pending, busy, present_thread; +// Sleeps on a high-resolution timer to 1 ms before at, then yields until at: the timer alone wakes up to ~0.5 ms late. +static void wait_until(HANDLE timer, uint64_t at) { + uint64_t now = kern_now_ns(); + if (at > now + 1500000 && timer) { + LARGE_INTEGER d = {.QuadPart = -(LONGLONG)((at - now - 1000000) / 100)}; + if (SetWaitableTimer(timer, &d, 0, NULL, NULL, FALSE)) WaitForSingleObject(timer, INFINITE); + } + while (kern_now_ns() < at) SwitchToThread(); +} + static DWORD WINAPI present_main(void *arg) { (void)arg; + HANDLE timer = CreateWaitableTimerExW(NULL, NULL, CREATE_WAITABLE_TIMER_HIGH_RESOLUTION, TIMER_ALL_ACCESS); + uint64_t last = 0, last_queued = 0; AcquireSRWLockExclusive(&pl); for (;;) { while (!pending) SleepConditionVariableSRW(&pcv, &pl, INFINITE, 0); @@ -35,12 +51,25 @@ static DWORD WINAPI present_main(void *arg) { WakeAllConditionVariable(&pcv); ReleaseSRWLockExclusive(&pl); if (flight_on) vk_thumbs_frame(j.frame); - vk_present_image(j.image, VK_IMAGE_LAYOUT_GENERAL, j.format, j.w, j.h, j.has_crop ? j.crop : NULL); + vk_present_blit(j.image, VK_IMAGE_LAYOUT_GENERAL, j.w, j.h, j.has_crop ? j.crop : NULL); vk_sync_submit(NULL, 0); // a timeline value after the blit: deferred destruction waits for the blit too AcquireSRWLockExclusive(&pl); busy = 0; WakeAllConditionVariable(&pcv); ReleaseSRWLockExclusive(&pl); + uint64_t t0 = kern_now_ns(); + wait_until(timer, j.at); + uint64_t t1 = kern_now_ns(); + vk_present_flip(); + // TOTK_TRACE=present: one line per present: the host present's interval, the interval of the game's present + // calls (when the host present went out before back-edge pacing), the wait and how far past its target it went + if (rt_trace & RT_TRACE_PRESENT) + rt_log("present: frame %llu interval %.3f ms, game %.3f ms, waited %.3f ms, %.3f ms past target", + (unsigned long long)j.frame, last ? (t1 - last) / 1e6 : 0.0, + last_queued ? (j.queued - last_queued) / 1e6 : 0.0, (t1 - t0) / 1e6, + j.at && t1 > j.at ? (t1 - j.at) / 1e6 : 0.0); + last = t1; + last_queued = j.queued; vk_pipeline_autosave(); // off the render thread, outside the present lock AcquireSRWLockExclusive(&pl); } @@ -55,7 +84,7 @@ void vk_present_drain(void) { perf_end(PERF_DRAIN, p0); } -static void vk_be_present(const tex_t *t, const int crop[4]) { +static void vk_be_present(const tex_t *t, const int crop[4], uint64_t at_ns) { static volatile long n_skipped; vk_sync_start(); uint64_t frame = __atomic_add_fetch(&gfx_counters.frames, 1, __ATOMIC_RELAXED); @@ -69,7 +98,8 @@ static void vk_be_present(const tex_t *t, const int crop[4]) { rt_log("vk: present of texture %p (format %#x) skipped: no colour image", (const void *)t, t ? t->d.format : 0); return; } - PresentJob j = {.image = img->image, .format = img->format, .w = (int)img->width, .h = (int)img->height, .frame = frame}; + PresentJob j = {.image = img->image, .format = img->format, .w = (int)img->width, .h = (int)img->height, .frame = frame, + .at = at_ns, .queued = kern_now_ns()}; if (crop) { j.has_crop = 1; for (int i = 0; i < 4; i++) j.crop[i] = crop[i]; diff --git a/runtime/vk_exec_probe.c b/runtime/vk_exec_probe.c index 8b9043a2..7b83d323 100644 --- a/runtime/vk_exec_probe.c +++ b/runtime/vk_exec_probe.c @@ -128,7 +128,7 @@ static int test_present(const GfxBackend *b, uint8_t *guest, int *w_out, int *h_ uint64_t frames = gfx_stats().frames; vk_present_capture(1); const int crop[4] = {0, 0, TEX_W, TEX_H}; - b->present(&t, crop); + b->present(&t, crop, 0); b->finish(); // the queued present is submitted and, with capture on, read back const uint8_t *px; int w, h;