mirror of
https://github.com/valentderah/totk-pc-recomp.git
synced 2026-11-21 21:05:56 +00:00
Merge pull request #239: Split the GPU's idle time by whether the next part was submitted yet (perf line) (lowlevel-larry)
This commit is contained in:
commit
949b06b72e
5 files changed
+89
-1
No files matched your search
@@ -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
|
||||
|
||||
@@ -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) {
|
||||
|
||||
+2
-1
@@ -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
|
||||
|
||||
@@ -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.
|
||||
|
||||
@@ -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();
|
||||
|
||||
Reference in new issue
Block a user