From c79b5f6cf74a73947bae583a73ce622a3b7081a8 Mon Sep 17 00:00:00 2001 From: lowlevel-larry Date: Sat, 31 Oct 2026 11:42:51 -0300 Subject: [PATCH] Split the GPU's idle time by whether the next part was submitted yet, with calibrated timestamps The perf line's "bound" said cpu at 640x360 on a Ryzen 5 4600G (Vega 7, RADV) and also at 1600x900, where lowering the resolution showed the GPU held the frame back; the GPU busy time alone cannot tell the two apart. With VK_KHR/EXT_calibrated_timestamps the GPU timestamps of each part go on the CPU clock (QPC on Windows, CLOCK_MONOTONIC elsewhere), each part records when it was handed to vkQueueSubmit2, and a third perf line splits the gap before each timed part: submitted after the previous part ended (the GPU waited for the replay or the game) or already queued (untimed uploads and presents, or a wait). It also gives the gaps over 0.5 ms, the longest one and the mean time from submit to start. On the 4600G at 640x360 (44 fps) it reads 11.3 ms idle a frame, 10.3 ms of it waiting for the next submission, in 3-4 gaps of up to 8 ms, with the replay at 16 ms a frame: the GPU starves behind the replay. Without the extension, or when the driver refuses the domain pair, the line is left out. Only TOTK_TRACE=perf and the full overlay time the GPU. Co-Authored-By: Claude Opus 5.5 --- runtime/host.h | 3 ++ runtime/perf.c | 8 +++++ runtime/vk.h | 3 +- runtime/vk_device.c | 3 ++ runtime/vk_sync.c | 73 +++++++++++++++++++++++++++++++++++++++++++++ 5 files changed, 89 insertions(+), 1 deletion(-) diff --git a/runtime/host.h b/runtime/host.h index 452ac8e4..0a8bdfcf 100644 --- a/runtime/host.h +++ b/runtime/host.h @@ -57,6 +57,9 @@ typedef struct { int have_gpu, have_vram, vram_exact; uint64_t gpu_ns, gpu_parts, gpu_missed; // busy time, submission parts timed, parts left untimed uint64_t vram_used, vram_budget; + int have_idle; // calibrated timestamps: the idle split below is filled + uint64_t idle_ns, starved_ns, queued_ns; // GPU idle between timed parts; of it, before the part was submitted; submit to start + uint64_t idle_gaps, max_gap_ns; // gaps over 0.5 ms; the longest } PerfGpu; extern void (*perf_gpu_stats)(PerfGpu *out); // The performance overlay (perfmon.c): mode 0 off, 1 fps, 2 full. While it is on, perf_present hands every frame to diff --git a/runtime/perf.c b/runtime/perf.c index 3db4b6ed..ef04ede5 100644 --- a/runtime/perf.c +++ b/runtime/perf.c @@ -183,6 +183,9 @@ static uint64_t ft_frame(uint64_t frame, uint64_t now, uint64_t d) { // process memory, and which side holds the frame back. pace: the frame waited for pacing (vsync, the frame limiter) at // least 15% of the window; gpu: the GPU was busy for 80% of the frame interval or more (without timestamps: threads // waited for fences for half the interval or more); cpu otherwise. +// With calibrated timestamps a third line splits the GPU's idle time between timed parts: the part was submitted only +// after the previous one had ended (the GPU waited for the CPU's replay or the game), or it was already queued (untimed +// work such as uploads and presents ran there, or a wait held it). static void perf_gpu_line(uint64_t frame, double interval_ms, double pace_share, uint64_t n) { PerfGpu g; memset(&g, 0, sizeof g); @@ -205,6 +208,11 @@ static void perf_gpu_line(uint64_t frame, double interval_ms, double pace_share, rt_log("perf: frame %llu: %s; fence wait per frame: render thread %.2f ms, other threads %.2f ms; %s; ram working set " "%.0f MiB, private %.0f MiB; bound: %s", (unsigned long long)frame, gs, rw, ow, vs, ws, priv, bound); + if (g.have_gpu && g.have_idle) + rt_log("perf: frame %llu: gpu idle per frame %.2f ms between timed parts: %.2f ms waiting for the next submission, " + "%.2f ms with it queued (untimed work or waits); %.1f gaps over 0.5 ms, longest %.2f ms; submit to start avg %.2f ms", + (unsigned long long)frame, g.idle_ns / 1e6 / n, g.starved_ns / 1e6 / n, (g.idle_ns - g.starved_ns) / 1e6 / n, + (double)g.idle_gaps / n, g.max_gap_ns / 1e6, g.gpu_parts ? g.queued_ns / 1e6 / g.gpu_parts : 0.0); } int rt_ab(void) { diff --git a/runtime/vk.h b/runtime/vk.h index 6d72c85f..e3a2f050 100644 --- a/runtime/vk.h +++ b/runtime/vk.h @@ -33,7 +33,8 @@ typedef struct VkCtx { int has_custom_border_color, has_eds, has_eds2, has_eds3, has_vertex_input_dynamic_state, has_conditional_rendering, has_transform_feedback, has_provoking_vertex, has_device_fault, has_memory_budget, has_robustness2, has_buffer_device_address, has_fragment_shader_interlock, has_buffer_marker, - has_astc_ldr; // textureCompressionASTC_LDR (enabled when reported) + has_astc_ldr, // textureCompressionASTC_LDR (enabled when reported) + has_calibrated; // VK_KHR/EXT_calibrated_timestamps (GPU idle split in the perf line) // Feedback loops (maxwell.md 1.9, vk_exec_draw.c feedback_prepare): a draw samples a target of its open pass that // an earlier draw of the pass wrote. TOTK_FEEDBACK=0: VK_FEEDBACK_OFF (sampled in GENERAL without a barrier, the // old behaviour); VK_FEEDBACK_LAYOUT with VK_EXT_attachment_feedback_loop_layout and dynamicRenderingLocalRead diff --git a/runtime/vk_device.c b/runtime/vk_device.c index e92e6de0..e523f033 100644 --- a/runtime/vk_device.c +++ b/runtime/vk_device.c @@ -247,6 +247,9 @@ static int create_device(void) { CHAIN(lr, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DYNAMIC_RENDERING_LOCAL_READ_FEATURES_KHR); } if (has_ext(ep, ne, VK_EXT_MEMORY_BUDGET_EXTENSION_NAME)) { g_vk.has_memory_budget = 1; ext[n_ext++] = VK_EXT_MEMORY_BUDGET_EXTENSION_NAME; } + // GPU timestamps on the CPU clock (vk_sync.c): the perf line splits GPU idle time into waiting for a submission or not. + if (has_ext(ep, ne, VK_KHR_CALIBRATED_TIMESTAMPS_EXTENSION_NAME)) { g_vk.has_calibrated = 2; ext[n_ext++] = VK_KHR_CALIBRATED_TIMESTAMPS_EXTENSION_NAME; } + else if (has_ext(ep, ne, VK_EXT_CALIBRATED_TIMESTAMPS_EXTENSION_NAME)) { g_vk.has_calibrated = 1; ext[n_ext++] = VK_EXT_CALIBRATED_TIMESTAMPS_EXTENSION_NAME; } // GPU breadcrumbs for a lost device (vk_crumbs.c): AMD's drivers and RADV report it. if (has_ext(ep, ne, VK_AMD_BUFFER_MARKER_EXTENSION_NAME)) { g_vk.has_buffer_marker = 1; ext[n_ext++] = VK_AMD_BUFFER_MARKER_EXTENSION_NAME; } // Graphics pipeline library: chained last so it can be dropped again when vk_caps_gpl declines it. diff --git a/runtime/vk_sync.c b/runtime/vk_sync.c index 8f16f154..8a4acdcf 100644 --- a/runtime/vk_sync.c +++ b/runtime/vk_sync.c @@ -61,6 +61,14 @@ static volatile uint8_t ts_busy[TS_PAIRS]; // written until the completion threa static int ts_cur = -1; // the pair of the part being recorded, -1 untimed static uint64_t ts_last_end; // completion thread: end of the latest part read (ticks) static volatile int64_t ts_busy_ns, ts_parts, ts_missed; +// GPU idle (with calibrated timestamps): the gap before each timed part, split by whether the part was submitted after +// the previous one had ended (the GPU waited for the CPU: starved) or before (it waited for untimed work or a wait). +static uint64_t ts_sub_ns[TS_PAIRS]; // CPU time the part was handed to vkQueueSubmit2 +static int ts_unsent[4], ts_n_unsent; // pairs closed and not yet submitted (sub_lock) +static uint64_t ts_last_end_ns; // completion thread: ts_last_end on the CPU clock +static volatile int64_t ts_idle_ns, ts_starved_ns, ts_gaps, ts_max_gap_ns, ts_queued_ns; +static int64_t cal_tick, cal_ns, cal_at; // completion thread: a calibrated (GPU tick, CPU ns) pair and when it was taken +static PFN_vkGetCalibratedTimestampsKHR cal_fn; // On the first submission that wants timing (perf_gpu_timing: TOTK_TRACE=perf or the full performance overlay). static void ts_setup(VkCtx *c) { @@ -91,6 +99,49 @@ static void ts_setup(VkCtx *c) { typedef struct { uint32_t pair; } TsRead; +// Completion thread: refresh the GPU tick / CPU clock pair every 250 ms; 0 when there is no calibration. The host +// domain is the clock plat_now_ns reads (QPC on Windows, CLOCK_MONOTONIC elsewhere), plat_counter_hz ticks a second. +static int cal_refresh(VkCtx *c) { + if (!c->has_calibrated) return 0; + if (!cal_fn) { + cal_fn = (PFN_vkGetCalibratedTimestampsKHR)vkGetDeviceProcAddr(c->device, c->has_calibrated == 2 ? "vkGetCalibratedTimestampsKHR" + : "vkGetCalibratedTimestampsEXT"); + if (!cal_fn) { c->has_calibrated = 0; return 0; } + } + int64_t now = (int64_t)plat_now_ns(); + if (cal_at && now - cal_at < 250000000) return 1; + VkCalibratedTimestampInfoKHR ci[2] = {{.sType = VK_STRUCTURE_TYPE_CALIBRATED_TIMESTAMP_INFO_KHR, .timeDomain = VK_TIME_DOMAIN_DEVICE_KHR}, +#ifdef _WIN32 + {.sType = VK_STRUCTURE_TYPE_CALIBRATED_TIMESTAMP_INFO_KHR, .timeDomain = VK_TIME_DOMAIN_QUERY_PERFORMANCE_COUNTER_KHR}}; +#else + {.sType = VK_STRUCTURE_TYPE_CALIBRATED_TIMESTAMP_INFO_KHR, .timeDomain = VK_TIME_DOMAIN_CLOCK_MONOTONIC_KHR}}; +#endif + uint64_t v[2], dev; + if (cal_fn(c->device, 2, ci, v, &dev) != VK_SUCCESS) { + if (!cal_at) { // the domain pair is not supported: no split + rt_log("vk: calibrated timestamps failed: the perf line shows no GPU idle split"); + c->has_calibrated = 0; + } + return cal_at != 0; + } + cal_tick = (int64_t)(v[0] & ts_mask), cal_ns = (int64_t)((double)v[1] * 1e9 / (double)plat_counter_hz()), cal_at = now; + return 1; +} + +static int64_t tick_ns(uint64_t t) { return cal_ns + (int64_t)((double)((int64_t)t - cal_tick) * ts_period); } + +static void max64(volatile int64_t *m, int64_t v) { + int64_t o = __atomic_load_n(m, __ATOMIC_RELAXED); + while (v > o && !__atomic_compare_exchange_n(m, &o, v, 0, __ATOMIC_RELAXED, __ATOMIC_RELAXED)) {} +} + +// Just before vkQueueSubmit2 (sub_lock held): the parts closed since the last submit leave the CPU now. +static void ts_submitted(void) { + uint64_t now = plat_now_ns(); + for (int i = 0; i < ts_n_unsent; i++) ts_sub_ns[ts_unsent[i]] = now; + ts_n_unsent = 0; +} + static void ts_read_cb(void *arg) { // completion thread, in submission order TsRead *t = arg; VkCtx *c = vk_ctx(); @@ -98,6 +149,18 @@ static void ts_read_cb(void *arg) { // completion thread, in submission order if (vkGetQueryPoolResults(c->device, ts_pool, 2 * t->pair, 2, sizeof v, v, sizeof v[0], VK_QUERY_RESULT_64_BIT) == VK_SUCCESS) { uint64_t s = v[0] & ts_mask, e = v[1] & ts_mask; if (e >= s) { + if (cal_refresh(c)) { + int64_t sn = tick_ns(s), en = tick_ns(e), sub = (int64_t)ts_sub_ns[t->pair]; + if (ts_last_end_ns && sn > ts_last_end_ns) { + int64_t gap = sn - ts_last_end_ns, late = sub - ts_last_end_ns; + plat_add64(&ts_idle_ns, gap); + if (late > 0) plat_add64(&ts_starved_ns, late < gap ? late : gap); + if (gap > 500000) plat_inc64(&ts_gaps); + max64(&ts_max_gap_ns, gap); + } + if (sub && sn > sub) plat_add64(&ts_queued_ns, sn - sub); + if (en > ts_last_end_ns) ts_last_end_ns = en; + } uint64_t from = s > ts_last_end ? s : ts_last_end; if (e > from) { int64_t ns = (int64_t)((double)(e - from) * ts_period); @@ -132,6 +195,8 @@ static int ts_open(VkCommandBuffer cb) { static void ts_close(VkCommandBuffer cb, int pair, uint64_t fence) { if (pair < 0) return; vkCmdWriteTimestamp(cb, VK_PIPELINE_STAGE_BOTTOM_OF_PIPE_BIT, ts_pool, 2 * (uint32_t)pair + 1); + ts_sub_ns[pair] = 0; + if (ts_n_unsent < 4) ts_unsent[ts_n_unsent++] = pair; TsRead *t = malloc(sizeof *t); if (!t) rt_fatal("vk: out of memory"); t->pair = (uint32_t)pair; @@ -159,6 +224,12 @@ static void gpu_stats(PerfGpu *g) { g->gpu_parts = (uint64_t)plat_xchg64(&ts_parts, 0); g->gpu_missed = (uint64_t)plat_xchg64(&ts_missed, 0); g->have_vram = vk_mem_vram(&g->vram_used, &g->vram_budget, &g->vram_exact); + g->have_idle = vk_ctx()->has_calibrated != 0 && cal_at != 0; + g->idle_ns = (uint64_t)plat_xchg64(&ts_idle_ns, 0); + g->starved_ns = (uint64_t)plat_xchg64(&ts_starved_ns, 0); + g->queued_ns = (uint64_t)plat_xchg64(&ts_queued_ns, 0); + g->idle_gaps = (uint64_t)plat_xchg64(&ts_gaps, 0); + g->max_gap_ns = (uint64_t)plat_xchg64(&ts_max_gap_ns, 0); } // Weak stand-in for vk_exec.c's replay: only empty recordings ({OP_BEGIN, OP_END}) can be submitted. @@ -303,6 +374,7 @@ VkCommandBuffer vk_sync_split(void) { {.sType = VK_STRUCTURE_TYPE_COMMAND_BUFFER_SUBMIT_INFO, .commandBuffer = cb}}; VkSubmitInfo2 si = {.sType = VK_STRUCTURE_TYPE_SUBMIT_INFO_2, .commandBufferInfoCount = pro ? 2 : 1, .pCommandBufferInfos = pro ? cbi : cbi + 1}; + ts_submitted(); vk_queue_lock(); VkResult r = vkQueueSubmit2(c->gfx_queue, 1, &si, VK_NULL_HANDLE); vk_queue_unlock(); @@ -366,6 +438,7 @@ uint64_t vk_sync_submit(const uint64_t *handles, int n) { .commandBufferInfoCount = (pro ? 1u : 0u) + (recorded ? 1u : 0u), .pCommandBufferInfos = pro ? cbi : cbi + 1, .signalSemaphoreInfoCount = 1, .pSignalSemaphoreInfos = &sig}; + ts_submitted(); vk_queue_lock(); VkResult r = vkQueueSubmit2(c->gfx_queue, 1, &si, VK_NULL_HANDLE); vk_queue_unlock();