From 710b7f5dd0b37bdd34d908dce1ab671491f53a16 Mon Sep 17 00:00:00 2001 From: Valiantsin Dzerakh Date: Mon, 2 Nov 2026 09:50:30 +0300 Subject: [PATCH] The device-lost report names the pass or dispatch the GPU was running The replay marks the start and the end of every render pass and dispatch (vk_exec.c vk_exec_pass_begin and vk_exec_pass_end, vk_exec_draw.c op_dispatch and op_dispatch_ind), outside the pass so no pass is broken. With VK_AMD_buffer_marker the GPU writes the last started and finished mark into words 2 and 3 of the breadcrumb buffer; with VK_NV_device_diagnostic_checkpoints the same points are checkpoints, read with vkGetQueueCheckpointData2NV after the loss. A ring of 4096 records maps a mark to its submission, index, target formats and size, draw count and the input ids of the first and last draw's shaders. vk_device_fault_report logs both marks with their records. The calls go through the recorder thread. TOTK_PASS_CRUMBS (menu: GPU pass marks): unset, AMD buffer marks only; 1, also NVIDIA checkpoints, whose extension is enabled only then; 0, none. The design follows Savage Wind Recomp 3fae40c; the code is ours. --probe-vkexec gets a pass marks part: pass, dispatch, pass in one submission; the marks read back after the fence name the last pass and the report text says so. Co-Authored-By: Claude Opus 5.5 --- docs/tester-guide.md | 4 + runtime/cfg.c | 5 +- runtime/ui/menu.cpp | 1 + runtime/ui_text.c | 8 ++ runtime/ui_text.h | 1 + runtime/vk.h | 40 ++++++++ runtime/vk_crumbs.c | 206 +++++++++++++++++++++++++++++++++++++++- runtime/vk_device.c | 13 ++- runtime/vk_exec.c | 24 +++++ runtime/vk_exec.h | 7 ++ runtime/vk_exec_draw.c | 20 ++++ runtime/vk_exec_probe.c | 79 ++++++++++++++- runtime/vk_rec.c | 10 ++ runtime/vk_rec.h | 2 + totk.ini.example | 4 + 15 files changed, 414 insertions(+), 10 deletions(-) diff --git a/docs/tester-guide.md b/docs/tester-guide.md index cf661ba9..2ddd4ac9 100644 --- a/docs/tester-guide.md +++ b/docs/tester-guide.md @@ -39,6 +39,10 @@ build\\totk.exe `TOTK_VK_VALIDATION=1` turns on the Vulkan validation layer (it comes with the Vulkan SDK). It makes the game slower; do one run with it and one without (`set TOTK_VK_VALIDATION=`). +If the game stops with a lost device (the log says `device lost` or `VK_ERROR_DEVICE_LOST`), the lines starting with +`vk: pass marks` name the render pass or dispatch the GPU was running. AMD GPUs write them by default. On an NVIDIA GPU, +`set TOTK_PASS_CRUMBS=1` (or GPU pass marks: On in the Advanced tab) before the run that reproduces the crash. + The game keeps running behind other windows (`assume_focus = 0` in `totk.ini` pauses it instead). Shaders the preparation did not cover compile on first use, so the first minutes of play can stutter. Play into the open field (load a save, walk around for a minute, fight something if you can), then close the window. diff --git a/runtime/cfg.c b/runtime/cfg.c index 43137260..53f2bb98 100644 --- a/runtime/cfg.c +++ b/runtime/cfg.c @@ -44,7 +44,7 @@ static const char *const known[] = { "HDR_PEAK_NITS", "HDR_UI_NITS", "HIGHFPS_FIX", "INPUT", "INPUT_RECORD", "INPUT_SCRIPT", "LANG", "LIB_PREBUILD", "LIB_PREBUILD_KEEP", "LIB_PREBUILD_THREADS", "LOCALE", "LOD_GUARD", "LSTICK_DEADZONE", "MEMORY", "MENU_LANG", "MENU_TEST", "MENU_TEST_DIR", "MENU_TEST_SET", "MINIMAL_LAYOUT", "MIRROR_GAP", "MODS_DIR", "MODS_DISABLED", "MODS_ORDER", "MODS_REBUILD", "MOTION", "MOUSE_SENS", "MOVIE_HOST", "MOVIE_PACE", - "ONE_PER_CORE", "OPERATION_MODE", "OUTPUT_RES", "PAD_LAYOUT", "PATCH_OUTPUT", "PATCH_SCENE", "PCSS", "PCSS_K", "PERF_OVERLAY", "PERF_SLOW_MS", "PIPELINE_CACHE", "PIPE_MEMO", "PIPE_PREBUILD", "PIPE_SKIP", "PIPE_SYNC", "PIPE_WAIT", + "ONE_PER_CORE", "OPERATION_MODE", "OUTPUT_RES", "PAD_LAYOUT", "PASS_CRUMBS", "PATCH_OUTPUT", "PATCH_SCENE", "PCSS", "PCSS_K", "PERF_OVERLAY", "PERF_SLOW_MS", "PIPELINE_CACHE", "PIPE_MEMO", "PIPE_PREBUILD", "PIPE_SKIP", "PIPE_SYNC", "PIPE_WAIT", "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", "RENDER_SCALE", "REPLAY_ASYNC", @@ -95,7 +95,7 @@ static const struct { const char *key, *section; } sections[] = { {"BIND_SKIP", "performance"}, {"SHADER_MEMO", "performance"}, {"PIPE_MEMO", "performance"}, {"TEX_MEMO", "performance"}, {"DESC_TEMPLATE", "performance"}, {"PUSH_SKIP", "performance"}, {"SPLIT_DRAWS", "performance"}, {"SPLIT_US", "performance"}, {"VK_VALIDATION", "performance"}, {"VK_DYN_VERTEX", "performance"}, {"VK_DYN_A2C", "performance"}, {"VK_SUBGROUP_PIN", "performance"}, - {"TRACE", "diagnostics"}, {"FLIGHT", "diagnostics"}, {"FLIGHT_SPIKE_MS", "diagnostics"}, + {"TRACE", "diagnostics"}, {"FLIGHT", "diagnostics"}, {"PASS_CRUMBS", "diagnostics"}, {"FLIGHT_SPIKE_MS", "diagnostics"}, {"WB_FENCE_LIMIT", "diagnostics"}, {"WB_EXACT", "diagnostics"}, }; @@ -167,6 +167,7 @@ static const CfgMeta metas[] = { // diagnostics {"TRACE", "", NULL, RESTART}, {"FLIGHT", "0", "0|1", RESTART}, {"FLIGHT_SPIKE_MS", "100", "0..60000", RESTART}, {"WB_FENCE_LIMIT", "65536", "0..1073741824", RESTART}, {"WB_EXACT", "1", "0|1", RESTART}, + {"PASS_CRUMBS", "", "0|1", RESTART}, // vk_crumbs.c pass marks; unset: VK_AMD_buffer_marker only {"INPUT_RECORD", "", NULL, RESTART}, }; diff --git a/runtime/ui/menu.cpp b/runtime/ui/menu.cpp index ecc75a9f..a4a6e33d 100644 --- a/runtime/ui/menu.cpp +++ b/runtime/ui/menu.cpp @@ -962,6 +962,7 @@ static void tab_advanced(float scale) { row_set_or_not("TOTK_TRACE", UI_MENU_TRACE, UI_MENU_TRACE_DESC, "perf"); opt_toggle("TOTK_FLIGHT", UI_MENU_FLIGHT, UI_MENU_FLIGHT_DESC); opt_slider("TOTK_FLIGHT_SPIKE_MS", UI_MENU_FLIGHT_SPIKE_MS, 20, 1000, UI_MENU_FLIGHT_SPIKE_MS_DESC, 10, "%.0f"); + opt_choice("TOTK_PASS_CRUMBS", UI_MENU_PASS_CRUMBS, dyn, 3, UI_MENU_PASS_CRUMBS_DESC); // vk_crumbs.c pass marks static char rec_path[600]; // the recording goes beside the log if (!rec_path[0]) { char dir[512]; diff --git a/runtime/ui_text.c b/runtime/ui_text.c index 719dd9df..03ca1186 100644 --- a/runtime/ui_text.c +++ b/runtime/ui_text.c @@ -390,6 +390,8 @@ static const char *const text_en[UI_TEXT_COUNT] = { [UI_MENU_FLIGHT_DESC] = "Keeps a short history and saves it when a frame freezes.", [UI_MENU_FLIGHT_SPIKE_MS] = "Freeze threshold (ms)", [UI_MENU_FLIGHT_SPIKE_MS_DESC] = "Frame time that counts as a freeze.", + [UI_MENU_PASS_CRUMBS] = "GPU pass marks", + [UI_MENU_PASS_CRUMBS_DESC] = "After a GPU crash, the log names the render pass that was running. Automatic: AMD only. On: also NVIDIA, at a small cost.", [UI_MENU_INPUT_RECORD] = "Input recording", [UI_MENU_INPUT_RECORD_DESC] = "Writes your inputs to a file for bug reports.", [UI_MENU_OPEN_LOG] = "Open log folder", [UI_MENU_OPEN_LOG_DESC] = "Shows the folder with the log files.", @@ -820,6 +822,8 @@ static const char *const text_ru[UI_TEXT_COUNT] = { [UI_MENU_FLIGHT_DESC] = "Хранит короткую историю и сохраняет её, когда кадр подвисает.", [UI_MENU_FLIGHT_SPIKE_MS] = "Порог подвисания (мс)", [UI_MENU_FLIGHT_SPIKE_MS_DESC] = "Время кадра, которое считается подвисанием.", + [UI_MENU_PASS_CRUMBS] = "Метки проходов GPU", + [UI_MENU_PASS_CRUMBS_DESC] = "После сбоя GPU журнал называет проход отрисовки, который выполнялся. Автоматически: только AMD. Вкл.: также NVIDIA, с небольшой нагрузкой.", [UI_MENU_INPUT_RECORD] = "Запись ввода", [UI_MENU_INPUT_RECORD_DESC] = "Пишет ваш ввод в файл для отчёта об ошибке.", [UI_MENU_OPEN_LOG] = "Открыть папку журналов", [UI_MENU_OPEN_LOG_DESC] = "Показывает папку с файлами журнала.", @@ -1168,6 +1172,8 @@ static const char *const text_pt_br[UI_TEXT_COUNT] = { [UI_MENU_FLIGHT_DESC] = "Guarda um histórico curto e o salva quando um quadro trava.", [UI_MENU_FLIGHT_SPIKE_MS] = "Limite de travamento (ms)", [UI_MENU_FLIGHT_SPIKE_MS_DESC] = "Tempo de quadro que conta como travamento.", + [UI_MENU_PASS_CRUMBS] = "Marcas de passagem da GPU", + [UI_MENU_PASS_CRUMBS_DESC] = "Após uma falha da GPU, o log indica a passagem de renderização que estava em execução. Automático: só AMD. Ligado: também NVIDIA, com um pequeno custo.", [UI_MENU_INPUT_RECORD] = "Gravação de comandos", [UI_MENU_INPUT_RECORD_DESC] = "Grava os seus comandos num arquivo para relatórios de bug.", [UI_MENU_OPEN_LOG] = "Abrir pasta de logs", [UI_MENU_OPEN_LOG_DESC] = "Mostra a pasta com os arquivos de log.", @@ -1750,6 +1756,8 @@ static const char *const text_zh_hans[UI_TEXT_COUNT] = { [UI_MENU_FLIGHT_DESC] = "保留一小段历史记录,在画面卡住时保存。", [UI_MENU_FLIGHT_SPIKE_MS] = "卡顿阈值(ms)", [UI_MENU_FLIGHT_SPIKE_MS_DESC] = "算作卡顿的帧时间。", + [UI_MENU_PASS_CRUMBS] = "GPU 渲染通道标记", + [UI_MENU_PASS_CRUMBS_DESC] = "GPU 崩溃后,日志会写出当时正在运行的渲染通道。自动:仅 AMD。开:NVIDIA 也启用,有少量开销。", [UI_MENU_INPUT_RECORD] = "输入录制", [UI_MENU_INPUT_RECORD_DESC] = "把你的输入写入文件,用于反馈问题。", [UI_MENU_OPEN_LOG] = "打开日志文件夹", diff --git a/runtime/ui_text.h b/runtime/ui_text.h index a7fc7fcf..702cdc4e 100644 --- a/runtime/ui_text.h +++ b/runtime/ui_text.h @@ -194,6 +194,7 @@ typedef enum { UI_MENU_TRACE, UI_MENU_TRACE_DESC, UI_MENU_FLIGHT, UI_MENU_FLIGHT_DESC, UI_MENU_FLIGHT_SPIKE_MS, UI_MENU_FLIGHT_SPIKE_MS_DESC, + UI_MENU_PASS_CRUMBS, UI_MENU_PASS_CRUMBS_DESC, UI_MENU_INPUT_RECORD, UI_MENU_INPUT_RECORD_DESC, UI_MENU_OPEN_LOG, UI_MENU_OPEN_LOG_DESC, UI_MENU_COPY_INFO, UI_MENU_COPY_INFO_DESC, UI_MENU_COPY_INFO_DONE, diff --git a/runtime/vk.h b/runtime/vk.h index 2751dad4..8119ca59 100644 --- a/runtime/vk.h +++ b/runtime/vk.h @@ -33,6 +33,7 @@ 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_nv_checkpoints, // VK_NV_device_diagnostic_checkpoints (TOTK_PASS_CRUMBS=1, vk_crumbs.c) has_astc_ldr, // textureCompressionASTC_LDR (enabled when reported) has_calibrated, // VK_KHR/EXT_calibrated_timestamps (GPU idle split in the perf line) has_hdr_metadata; // VK_EXT_hdr_metadata (vk_hdr.c vk_hdr_metadata) @@ -87,6 +88,45 @@ void vk_crumbs_release(void); void vk_crumb(VkCommandBuffer cb, int kind, uint64_t n); void vk_crumbs_report(void); // logs the two codes and what they name +// ---- pass marks (vk_crumbs.c): the replay (vk_exec.c vk_exec_pass_begin / vk_exec_pass_end, vk_exec_draw.c +// op_dispatch) marks where each render pass and dispatch starts and where it ends, so that a device loss names the +// pass the GPU was in. A mark is a number; a ring of VK_PASS_MARKS records keeps what it was. With +// VK_AMD_buffer_marker the GPU writes the number of the last mark it started (TOP_OF_PIPE, before vkCmdBeginRendering +// or the dispatch) and of the last it finished (BOTTOM_OF_PIPE, after vkCmdEndRendering or the dispatch) into the +// breadcrumb buffer; with VK_NV_device_diagnostic_checkpoints the same two points are checkpoints, read with +// vkGetQueueCheckpointData(2)NV after the loss. TOTK_PASS_CRUMBS: unset, AMD buffer marks only; 1, also NVIDIA +// checkpoints (the extension is enabled at device creation); 0, none. +#define VK_PASS_MARKS 4096 // power of two +enum { VK_MARK_PASS = 1, VK_MARK_DISPATCH }; +typedef struct { + uint32_t id; // the mark this record belongs to (0: never written) + uint8_t kind; // VK_MARK_* + uint8_t ncolor; // colour attachments + uint32_t step; // index of the pass, or of the dispatch, within its submission, from 0 + uint32_t w, h, d; // render area and layers; a dispatch: group counts (0 0 0: indirect) + uint32_t draws; // draws recorded in the pass; UINT32_MAX until its end is recorded + uint64_t fence; // the submission: the timeline value it signals + VkFormat color[8], depth; // attachment formats (VK_FORMAT_UNDEFINED: none) + const GfxShader *first[2], *last[2];// vertex and fragment shader of the first and last draw; a dispatch: first[0] +} VkPassMark; +// Pass marks wanted and possible (TOTK_PASS_CRUMBS and the extensions): set by vk_crumbs_init. +extern int vk_pass_marks_on; +// vk_device.c create_device, before vkCreateDevice: 1 when TOTK_PASS_CRUMBS asks for NVIDIA checkpoints. +int vk_pass_marks_want_nv(void); +// The next mark: records its start into cb (through the recorder thread when it owns cb) and returns its ring record, +// id, kind and fence set, for the caller to fill. NULL when pass marks are off. Replay thread only. +VkPassMark *vk_pass_mark_begin(VkCommandBuffer cb, int kind, uint64_t fence); +void vk_pass_mark_end(VkCommandBuffer cb, const VkPassMark *m); // records the end of mark m into cb +// The recorder thread's side of both (vk_rec.c): the marker and checkpoint commands themselves. +void vk_pass_mark_cmd(VkCommandBuffer cb, uint32_t id, int end); +// AMD only: the last mark the GPU started and the last it finished (0: none); 0 without buffer marks. +int vk_pass_marks_read(uint32_t *started, uint32_t *finished); +const VkPassMark *vk_pass_mark_record(uint32_t id); // the ring record of mark id; NULL once a later mark took its slot +// The report's text for a started and a finished mark, three lines without a trailing newline: which marks (source: +// the extension they came from), then each with its ring record. vk_pass_marks_report logs it; the probe checks it. +void vk_pass_marks_format(const char *source, uint32_t started, uint32_t finished, char *o, size_t size); +void vk_pass_marks_report(void); // vk_device_fault_report: the AMD words and the NVIDIA checkpoints, formatted + // ---- window and present (gfx_present.c). Host threads only. // vk_present_image: blits the crop rectangle {x, y, w, h} of src (NULL, or w/h <= 0: the whole w x h image), scaled // to the swapchain extent, into the acquired swapchain image and presents it. src is in layout, which is diff --git a/runtime/vk_crumbs.c b/runtime/vk_crumbs.c index 74a391a2..3d34e024 100644 --- a/runtime/vk_crumbs.c +++ b/runtime/vk_crumbs.c @@ -4,19 +4,31 @@ // device loss word 0 names the newest point the GPU reached and word 1 the newest point it had finished: the hang lies // between them. A code is the crumb kind in the top 4 bits and its number in the low 28. The markers cost two small // writes per crumb, and crumbs mark submissions, upload batches, ASTC chunks and presents, not draws. +// +// Pass marks (vk.h vk_pass_mark_begin) use words 2 and 3 of the same buffer: the replay marks the start and the end of +// every render pass and dispatch, and a ring of records says what each mark was. The design follows Savage Wind +// Recomp's GPU checkpoints (refs/SavageWindRecomp runtime/nvn/vulkan/exec.c ck_mark and vk_checkpoints_report: a mark +// per pass and dispatch, numbers in a ring of 4096, text only at the device loss); the code is ours. #include #include +#include +#include "cfg.h" #include "host.h" #include "vk.h" static PFN_vkCmdWriteBufferMarkerAMD write_marker; static VkBuffer buf; static VmaAllocation alloc; -static volatile uint32_t *words; +static volatile uint32_t *words; // 0, 1: crumbs; 2, 3: pass marks -void vk_crumbs_init(VkCtx *c) { - if (!c->has_buffer_marker) return; +// Pass marks (below) +int vk_pass_marks_on; +static int pm_amd; // marks into words 2 and 3 +static PFN_vkCmdSetCheckpointNV set_checkpoint; +static void pass_marks_init(VkCtx *c); + +static void buffer_init(VkCtx *c) { write_marker = (PFN_vkCmdWriteBufferMarkerAMD)vkGetDeviceProcAddr(c->device, "vkCmdWriteBufferMarkerAMD"); VkBufferCreateInfo bi = {.sType = VK_STRUCTURE_TYPE_BUFFER_CREATE_INFO, .size = 16, .usage = VK_BUFFER_USAGE_TRANSFER_DST_BIT}; @@ -30,14 +42,20 @@ void vk_crumbs_init(VkCtx *c) { return; } words = info.pMappedData; - words[0] = words[1] = 0; + words[0] = words[1] = words[2] = words[3] = 0; rt_log("vk: GPU breadcrumbs on (VK_AMD_buffer_marker)"); } +void vk_crumbs_init(VkCtx *c) { + if (c->has_buffer_marker) buffer_init(c); + pass_marks_init(c); +} + void vk_crumbs_release(void) { VkCtx *c = vk_ctx(); if (buf && c) vmaDestroyBuffer(c->vma, buf, alloc); buf = VK_NULL_HANDLE, alloc = NULL, words = NULL, write_marker = NULL; + vk_pass_marks_on = pm_amd = 0, set_checkpoint = NULL; } void vk_crumb(VkCommandBuffer cb, int kind, uint64_t n) { @@ -65,3 +83,183 @@ void vk_crumbs_report(void) { describe(words[1], finished, sizeof finished); rt_log("vk: GPU breadcrumbs: the GPU last reached %s; everything before %s had finished", reached, finished); } + +// ---- pass marks + +// Cost per pass or dispatch: about twenty stores into the ring and two commands, one at the start and one at the end, +// each a marker write or a checkpoint. Per draw nothing, except that the branch of vk_exec_draw.c prepare_draw that +// records changed pipeline state also notes the shaders of a pass's first draw. A full barrier already precedes every +// pass and dispatch (vk_exec.c vk_exec_pass_begin, vk_exec_draw.c op_dispatch), so the end-of-pipe write adds no wait. +static VkPassMark ring[VK_PASS_MARKS]; +static uint32_t seq; // marks made; only the replay thread writes it + +// TOTK_PASS_CRUMBS: unset, buffer marks where VK_AMD_buffer_marker exists; 1, also NVIDIA checkpoints; 0, neither. +int vk_pass_marks_want_nv(void) { + const char *e = cfg_get("TOTK_PASS_CRUMBS"); + return e && *e && strcmp(e, "0") != 0; +} + +static void pass_marks_init(VkCtx *c) { + const char *e = cfg_get("TOTK_PASS_CRUMBS"); + int off = e && !strcmp(e, "0"); + set_checkpoint = c->has_nv_checkpoints + ? (PFN_vkCmdSetCheckpointNV)vkGetDeviceProcAddr(c->device, "vkCmdSetCheckpointNV") : NULL; + pm_amd = !off && write_marker && words; + vk_pass_marks_on = pm_amd || set_checkpoint; + if (vk_pass_marks_on) + rt_log("vk: pass marks on (%s%s%s; TOTK_PASS_CRUMBS=0 turns them off%s)", pm_amd ? "VK_AMD_buffer_marker" : "", + pm_amd && set_checkpoint ? " and " : "", set_checkpoint ? "VK_NV_device_diagnostic_checkpoints" : "", + set_checkpoint ? "" : ", =1 adds NVIDIA checkpoints where the driver has them"); + else + rt_log("vk: pass marks off (%s)", off ? "TOTK_PASS_CRUMBS=0" + : "no VK_AMD_buffer_marker; TOTK_PASS_CRUMBS=1 asks for NVIDIA checkpoints"); +} + +void vk_pass_mark_cmd(VkCommandBuffer cb, uint32_t id, int end) { + if (pm_amd) + write_marker(cb, end ? VK_PIPELINE_STAGE_BOTTOM_OF_PIPE_BIT : VK_PIPELINE_STAGE_TOP_OF_PIPE_BIT, buf, + end ? 12 : 8, id); + if (set_checkpoint) set_checkpoint(cb, (const void *)(uintptr_t)((uint64_t)id << 1 | (end != 0))); +} + +VkPassMark *vk_pass_mark_begin(VkCommandBuffer cb, int kind, uint64_t fence) { + if (!vk_pass_marks_on || !cb) return NULL; + uint32_t id = ++seq; + if (!id) id = ++seq; // 0 means no mark + VkPassMark *m = &ring[id & (VK_PASS_MARKS - 1)]; + m->id = id, m->kind = (uint8_t)kind, m->fence = fence, m->draws = UINT32_MAX; + rec_pass_mark(cb, id, 0); + return m; +} + +void vk_pass_mark_end(VkCommandBuffer cb, const VkPassMark *m) { + if (m && cb) rec_pass_mark(cb, m->id, 1); +} + +int vk_pass_marks_read(uint32_t *started, uint32_t *finished) { + if (!pm_amd) return 0; + *started = words[2], *finished = words[3]; + return 1; +} + +const VkPassMark *vk_pass_mark_record(uint32_t id) { + const VkPassMark *m = &ring[id & (VK_PASS_MARKS - 1)]; + return id && m->id == id ? m : NULL; +} + +// The first 8 bytes of the shader's input id (gfx_shader.c), the start of its stored input's name /in/.in. +static unsigned long long shader_id(const GfxShader *s) { + if (!s) return 0; + const uint8_t *iid = gfx_shader_input_id(s); + unsigned long long v = 0; + for (int i = 0; i < 8; i++) v = v << 8 | iid[i]; + return v; +} + +static void describe_mark(uint32_t id, char *o, size_t size) { + const VkPassMark *m = vk_pass_mark_record(id); + if (!id) { + snprintf(o, size, "nothing yet"); + return; + } + if (!m) { + snprintf(o, size, "no record (a later mark took its slot)"); + return; + } + if (m->kind == VK_MARK_DISPATCH) { + snprintf(o, size, "dispatch %u of submission %llu: %ux%ux%u groups%s, cs %016llx", m->step, + (unsigned long long)m->fence, m->w, m->h, m->d, m->w ? "" : " (indirect)", shader_id(m->first[0])); + return; + } + size_t n = (size_t)snprintf(o, size, "pass %u of submission %llu: %ux%u, %u layer%s, colour formats", m->step, + (unsigned long long)m->fence, m->w, m->h, m->d, m->d == 1 ? "" : "s"); + for (int i = 0; i < m->ncolor && i < 8 && n < size; i++) + n += (size_t)snprintf(o + n, size - n, "%s%d", i ? "," : " ", (int)m->color[i]); + if (!m->ncolor && n < size) n += (size_t)snprintf(o + n, size - n, " none"); + if (n < size) n += (size_t)snprintf(o + n, size - n, ", depth format %d", (int)m->depth); + if (n >= size) return; + if (m->draws == UINT32_MAX) + snprintf(o + n, size - n, ", still recording; first draw vs %016llx fs %016llx", shader_id(m->first[0]), + shader_id(m->first[1])); + else if (!m->draws) + snprintf(o + n, size - n, ", no draws"); + else + snprintf(o + n, size - n, ", %u draws; first vs %016llx fs %016llx, last vs %016llx fs %016llx", m->draws, + shader_id(m->first[0]), shader_id(m->first[1]), shader_id(m->last[0]), shader_id(m->last[1])); +} + +void vk_pass_marks_format(const char *source, uint32_t started, uint32_t finished, char *o, size_t size) { + char a[640], b[640]; + describe_mark(started, a, sizeof a); + describe_mark(finished, b, sizeof b); + snprintf(o, size, + "vk: pass marks (%s, %u made): the GPU last started mark %u and last finished mark %u\n" + "vk: last started %u: %s\n" + "vk: last finished %u: %s", + source, (unsigned)seq, (unsigned)started, (unsigned)finished, (unsigned)started, a, (unsigned)finished, b); +} + +static void log_lines(char *t) { + for (char *line = t, *nl; line && *line; line = nl ? nl + 1 : NULL) { + nl = strchr(line, '\n'); + if (nl) *nl = 0; + rt_log("%s", line); + } +} + +// vkGetQueueCheckpointData2NV, else vkGetQueueCheckpointDataNV, on the graphics queue (the replay's): one entry per +// stage with the last checkpoint that stage executed. A checkpoint is the mark's id times 2, plus 1 at its end, so the +// top-of-pipe entry names the last start or end the GPU reached, and the bottom-of-pipe entry the last one before which +// everything had finished: at a start, that is the end of the mark before it. +static void nv_report(void) { + VkCtx *c = vk_ctx(); + if (!c || !set_checkpoint) return; + PFN_vkGetQueueCheckpointData2NV get2 = + (PFN_vkGetQueueCheckpointData2NV)vkGetDeviceProcAddr(c->device, "vkGetQueueCheckpointData2NV"); + PFN_vkGetQueueCheckpointDataNV get1 = + (PFN_vkGetQueueCheckpointDataNV)vkGetDeviceProcAddr(c->device, "vkGetQueueCheckpointDataNV"); + enum { MAXN = 32 }; + uint64_t stage[MAXN], marker[MAXN]; + uint32_t n = 0; + if (get2) { + VkCheckpointData2NV d[MAXN]; + get2(c->gfx_queue, &n, NULL); + if (n > MAXN) n = MAXN; + for (uint32_t i = 0; i < n; i++) d[i] = (VkCheckpointData2NV){.sType = VK_STRUCTURE_TYPE_CHECKPOINT_DATA_2_NV}; + get2(c->gfx_queue, &n, d); + for (uint32_t i = 0; i < n; i++) stage[i] = d[i].stage, marker[i] = (uint64_t)(uintptr_t)d[i].pCheckpointMarker; + } else if (get1) { + VkCheckpointDataNV d[MAXN]; + get1(c->gfx_queue, &n, NULL); + if (n > MAXN) n = MAXN; + for (uint32_t i = 0; i < n; i++) d[i] = (VkCheckpointDataNV){.sType = VK_STRUCTURE_TYPE_CHECKPOINT_DATA_NV}; + get1(c->gfx_queue, &n, d); + for (uint32_t i = 0; i < n; i++) stage[i] = d[i].stage, marker[i] = (uint64_t)(uintptr_t)d[i].pCheckpointMarker; + } else { + rt_log("vk: pass marks: no vkGetQueueCheckpointDataNV entry point"); + return; + } + uint32_t started = 0, finished = 0; + for (uint32_t i = 0; i < n; i++) { + uint32_t id = (uint32_t)(marker[i] >> 1); + int end = (int)(marker[i] & 1); + rt_log("vk: checkpoint of stage %#llx: the %s of mark %u", (unsigned long long)stage[i], end ? "end" : "start", id); + if (stage[i] == VK_PIPELINE_STAGE_2_TOP_OF_PIPE_BIT) started = id; + if (stage[i] == VK_PIPELINE_STAGE_2_BOTTOM_OF_PIPE_BIT) finished = end ? id : id ? id - 1 : 0; + } + if (!n) rt_log("vk: pass marks: the driver reported no checkpoints"); + char t[2048]; + vk_pass_marks_format("VK_NV_device_diagnostic_checkpoints", started, finished, t, sizeof t); + log_lines(t); +} + +void vk_pass_marks_report(void) { + if (!vk_pass_marks_on) return; + uint32_t started, finished; + char t[2048]; + if (vk_pass_marks_read(&started, &finished)) { + vk_pass_marks_format("VK_AMD_buffer_marker", started, finished, t, sizeof t); + log_lines(t); + } + nv_report(); +} diff --git a/runtime/vk_device.c b/runtime/vk_device.c index a0338f93..a063955e 100644 --- a/runtime/vk_device.c +++ b/runtime/vk_device.c @@ -261,7 +261,7 @@ static int create_device(void) { CHAIN(fbl, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ATTACHMENT_FEEDBACK_LOOP_LAYOUT_FEATURES_EXT); CHAIN(lr, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DYNAMIC_RENDERING_LOCAL_READ_FEATURES_KHR); } - vk_dlaa_device_exts(ep, ne, ext, &n_ext, 40); // NGX's; the eight slots after it stay for the ones below + vk_dlaa_device_exts(ep, ne, ext, &n_ext, 40); // NGX's; the eight slots after it stay for the seven below 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; } @@ -272,6 +272,12 @@ static int create_device(void) { } // 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; } + // Pass marks on NVIDIA (vk_crumbs.c): checkpoints only with TOTK_PASS_CRUMBS=1, since NVIDIA documents a cost for + // the extension. NVIDIA's drivers report it, AMD's do not. + if (vk_pass_marks_want_nv() && has_ext(ep, ne, VK_NV_DEVICE_DIAGNOSTIC_CHECKPOINTS_EXTENSION_NAME)) { + g_vk.has_nv_checkpoints = 1; + ext[n_ext++] = VK_NV_DEVICE_DIAGNOSTIC_CHECKPOINTS_EXTENSION_NAME; + } // Graphics pipeline library: chained last so it can be dropped again when vk_caps_gpl declines it. void **gpl_link = NULL; if (has_ext(ep, ne, VK_KHR_PIPELINE_LIBRARY_EXTENSION_NAME) && has_ext(ep, ne, VK_EXT_GRAPHICS_PIPELINE_LIBRARY_EXTENSION_NAME)) { @@ -430,6 +436,7 @@ void vk_device_fault_report(VkResult r) { if (done) { plat_mutex_unlock(&lock); return; } done = 1; vk_crumbs_report(); + vk_pass_marks_report(); VkCtx *c = vk_ctx(); PFN_vkGetDeviceFaultInfoEXT get = c && c->has_device_fault ? (PFN_vkGetDeviceFaultInfoEXT)vkGetDeviceProcAddr(c->device, "vkGetDeviceFaultInfoEXT") @@ -500,11 +507,11 @@ int probe_vkdevice(void) { c->device_index, c->props.deviceName, VK_API_VERSION_MAJOR(v), VK_API_VERSION_MINOR(v), VK_API_VERSION_PATCH(v), c->gfx_family, c->xfer_family, c->xfer_shared ? " (shared queue)" : "", c->min_imported_host_alignment); printf("probe-vkdevice: optional: custom_border=%d eds=%d eds2=%d eds3=%d vertex_input=%d cond_render=%d xfb=%d provoking=%d " - "robustness2=%d fault=%d budget=%d bda=%d interlock=%d validation=%d\n", + "robustness2=%d fault=%d budget=%d bda=%d interlock=%d buffer_marker=%d nv_checkpoints=%d validation=%d\n", c->has_custom_border_color, c->has_eds, c->has_eds2, c->has_eds3, c->has_vertex_input_dynamic_state, c->has_conditional_rendering, c->has_transform_feedback, c->has_provoking_vertex, c->has_robustness2, c->has_device_fault, c->has_memory_budget, c->has_buffer_device_address, c->has_fragment_shader_interlock, - c->validation); + c->has_buffer_marker, c->has_nv_checkpoints, c->validation); vk_shutdown(); printf("probe-vkdevice: %s (validation errors %ld)\n", g_errors_total ? "FAILED" : "passed", g_errors_total); return g_errors_total ? 1 : 0; diff --git a/runtime/vk_exec.c b/runtime/vk_exec.c index cf00d6b8..2709471d 100644 --- a/runtime/vk_exec.c +++ b/runtime/vk_exec.c @@ -612,6 +612,20 @@ void vk_exec_pass_begin(VkExec *ex) { if (d->aspect & VK_IMAGE_ASPECT_DEPTH_BIT) da = a; if (d->aspect & VK_IMAGE_ASPECT_STENCIL_BIT) sa = a; } + // The start mark goes between the barrier and vkCmdBeginRendering, its end right after vkCmdEndRendering + // (vk_exec_pass_end): outside the pass, and without breaking it. + VkPassMark *m = ex->mark = vk_pass_mark_begin(ex->cb, VK_MARK_PASS, ex->fence); + if (m) { + m->step = ex->mark_passes++; + m->w = ex->pass_w, m->h = ex->pass_h, m->d = ex->pass_layers; + m->ncolor = (uint8_t)(ex->pass_ncolor < 8 ? ex->pass_ncolor : 8); + for (int i = 0; i < m->ncolor; i++) m->color[i] = ex->pass_color[i]; + m->depth = ex->pass_depth ? ex->pass_depth : ex->pass_stencil; + // The shaders bound now are the first draw's when it repeats the pipeline state; when it does not, + // vk_exec_draw.c prepare_draw replaces them as it records the new state. + vk_exec_draw_shaders(&m->first[0], &m->first[1]); + ex->mark_draws0 = vk_exec_frame.draws; + } VkRenderingInfo ri = {.sType = VK_STRUCTURE_TYPE_RENDERING_INFO, .renderArea = {{0, 0}, {ex->pass_w, ex->pass_h}}, .layerCount = ex->pass_layers, .colorAttachmentCount = ex->pass_ncolor, .pColorAttachments = ca, @@ -629,6 +643,14 @@ void vk_exec_pass_end(VkExec *ex) { vkCmdEndRendering(ex->cb); ex->recorded++; ex->in_pass = 0; + if (ex->mark) { + // vk_exec_frame_log resets the frame counters at a present (TOTK_TRACE=gfx): then only the draws since it count + uint64_t d = vk_exec_frame.draws, d0 = ex->mark_draws0; + ex->mark->draws = (uint32_t)(d >= d0 ? d - d0 : d); + if (ex->mark->draws) vk_exec_draw_shaders(&ex->mark->last[0], &ex->mark->last[1]); + vk_pass_mark_end(ex->cb, ex->mark); + ex->mark = NULL; + } for (int i = 0; i < ex->pass_ncolor && i < 8; i++) // stand-ins of 3D BC targets go to their textures if (ex->color[i].image && ex->color[i].img && ex->color[i].img->image != ex->color[i].image) bc_copy_back(ex, &ex->color[i]); @@ -901,6 +923,8 @@ int vk_exec_record(VkCommandBuffer cb, const uint64_t *handles, int n, uint64_t ex->fence = fence; ex->recorded = 0; ex->in_pass = 0; + ex->mark = NULL; + ex->mark_passes = ex->mark_dispatches = 0; ex->dirty = VK_EXEC_DIRTY_ALL; ex->rt_resolved = 0; // images may have changed since the last command buffer ex->nviews = 0; diff --git a/runtime/vk_exec.h b/runtime/vk_exec.h index 4dd4a747..b0318a77 100644 --- a/runtime/vk_exec.h +++ b/runtime/vk_exec.h @@ -47,6 +47,11 @@ typedef struct VkExec { int recorded; // Vulkan commands recorded so far; every handler adds the ones it records int in_pass; // inside vkCmdBeginRendering uint32_t dirty; // VK_EXEC_DIRTY_* + // Pass marks (vk.h vk_pass_mark_begin): the open pass's record (NULL: none or marks off), vk_exec_frame.draws when + // it began, and the passes and dispatches this submission marked so far. + VkPassMark *mark; + uint64_t mark_draws0; + uint32_t mark_passes, mark_dispatches; // ---- render targets (OP_SET_RT) and the current pass p_set_rt rt; // last OP_SET_RT payload (a change ends the open pass); rt.n 0, no depth: none @@ -126,6 +131,8 @@ void vk_exec_inline_end(int reopen); // vk_exec_draw.c: forget what the command buffer being recorded has bound (pipeline, sets, dynamic state, vertex // buffers): the replay continues in a new one (vk_sync_split). void vk_exec_draw_new_cb(void); +// vk_exec_draw.c: the vertex and fragment shader of the last draw recorded into this command buffer (NULL: none yet). +void vk_exec_draw_shaders(const GfxShader **vs, const GfxShader **fs); VkBuffer vk_exec_inline_buffer(VkDeviceSize size); // vk_exec.c: the stand-in a 3D BC render target is drawn through goes with its image (vk_exec_image_gone). void vk_exec_bc_gone(VkImage image); diff --git a/runtime/vk_exec_draw.c b/runtime/vk_exec_draw.c index 8740ada4..58f03905 100644 --- a/runtime/vk_exec_draw.c +++ b/runtime/vk_exec_draw.c @@ -198,6 +198,21 @@ static void cb_done(void *arg) { // completion thread void vk_exec_draw_new_cb(void) { memset(&B, 0, sizeof B); } +void vk_exec_draw_shaders(const GfxShader **vs, const GfxShader **fs) { + *vs = B.st_valid ? B.st.vs : NULL; + *fs = B.st_valid ? B.st.fs : NULL; +} + +// Marks a dispatch about to be recorded (vk.h vk_pass_mark_begin); the caller ends it after the dispatch. +static VkPassMark *dispatch_mark(VkExec *ex, const GfxShader *cs, uint32_t x, uint32_t y, uint32_t z) { + VkPassMark *m = vk_pass_mark_begin(ex->cb, VK_MARK_DISPATCH, ex->fence); + if (!m) return NULL; + m->step = ex->mark_dispatches++; + m->w = x, m->h = y, m->d = z, m->draws = 0, m->ncolor = 0; + m->first[0] = cs, m->first[1] = m->last[0] = m->last[1] = NULL; + return m; +} + static CbRes *cb_res(VkExec *ex) { if (cur && cur_fence == ex->fence) return cur; cur = calloc(1, sizeof *cur); @@ -2167,6 +2182,7 @@ static int prepare_draw(VkExec *ex, int prim, int32_t count, int restart) { vk_pipeline_set_dynamic(ex->cb, &s); ex->recorded++; B.st = s, B.st_valid = 1; + if (ex->mark && vk_exec_frame.draws == ex->mark_draws0) ex->mark->first[0] = vs, ex->mark->first[1] = fs; } vk_dlaa_draw(ex); record_fixed(ex); @@ -2318,7 +2334,9 @@ static void op_dispatch(VkExec *ex, const p_dispatch *d) { twin_dispatch = 1; bind_resources(ex, info); twin_dispatch = 0; + VkPassMark *m = dispatch_mark(ex, cs, (uint32_t)d->x, (uint32_t)d->y, (uint32_t)d->z); vkCmdDispatch(ex->cb, (uint32_t)d->x, (uint32_t)d->y, (uint32_t)d->z); + vk_pass_mark_end(ex->cb, m); ex->recorded++; if (vk_dump_armed) vk_dump_dispatch(ex, cs, p, info, d); } @@ -2353,7 +2371,9 @@ static void op_dispatch_ind(VkExec *ex, const p_dispatch_ind *d) { vk_exec_barrier(ex); B.c0_valid[2] = 0; // the range no longer holds B.c0[2] } + VkPassMark *m = dispatch_mark(ex, cs, 0, 0, 0); vkCmdDispatchIndirect(ex->cb, ip.buffer, ip.offset); + vk_pass_mark_end(ex->cb, m); ex->recorded++; vk_mem_count(ip.cls, VK_MUSE_IND, sizeof(VkDispatchIndirectCommand)); VK_MEM_BOUND(ip); diff --git a/runtime/vk_exec_probe.c b/runtime/vk_exec_probe.c index a63fafce..fd6d9970 100644 --- a/runtime/vk_exec_probe.c +++ b/runtime/vk_exec_probe.c @@ -3,7 +3,8 @@ // the completion thread; a guest-memory word a callback writes is visible once fence_wait returns; finish drains every // submission; a present of a cleared vk_texture.c image (layout GENERAL) reads back exactly through the swapchain // capture. Clear part: a hand-built op stream (SET_RT to an RGBA8 and a D32 texture, whole-target clears, -// then scissored clears) through submit reads back exactly with read_texels. +// then scissored clears) through submit reads back exactly with read_texels. Pass marks part (test_marks): the GPU's +// buffer marks and the ring records name the last pass of a submission, and the device-lost report text says so. #include #include #include @@ -386,6 +387,74 @@ static uint8_t *draw_prefix(uint8_t *q, prog_t *prog, const pool_t *pool, tex_t return q; } +// ---- pass marks part (vk_crumbs.c): one submission with a pass of 2 draws into the draw part's target, a dispatch and +// a pass of 3 draws into a second target. Once its fence is done, the buffer marks must name the last pass as both +// started and finished, the ring records must hold what the three were, and vk_pass_marks_format (the text +// vk_device_fault_report logs) must name it. Without VK_AMD_buffer_marker or with TOTK_PASS_CRUMBS=0 it is skipped: +// NVIDIA's checkpoints can only be read once the device is lost. +static char marks_text[2048]; +static int marks_skipped; + +static int test_marks(const GfxBackend *b, pool_t *pool, tex_t *color, prog_t *gfx, prog_t *cs) { + uint32_t s0, f0; + if (!vk_pass_marks_read(&s0, &f0)) { + marks_skipped = 1; + return 0; + } + static tex_t second; + init_tex(&second, pool, 0x40000, NVN_FORMAT_RGBA8); + CHECK(0x40000 + second.L.size <= 0x80000, "pass-marks target exceeds its pool slot"); + static _Alignas(8) uint8_t stream[8192]; + uint8_t *q = draw_prefix(stream, gfx, pool, color); + const p_draw d = {NVN_DRAW_PRIMITIVE_TRIANGLES, 0, 3, 0, 0}; + for (int i = 0; i < 2; i++) q = put(q, OP_DRAW, &d, sizeof d); + const p_bind_program bc = {cs, 1 << 5}; + q = put(q, OP_BIND_PROGRAM, &bc, sizeof bc); + const p_dispatch dp = {2, 1, 1, 0}; + q = put(q, OP_DISPATCH, &dp, sizeof dp); + const p_bind_program bg = {gfx, 3}; + q = put(q, OP_BIND_PROGRAM, &bg, sizeof bg); + p_set_rt rt; + memset(&rt, 0, sizeof rt); + rt.n = 1, rt.color[0] = &second; + q = put(q, OP_SET_RT, &rt, sizeof rt); + for (int i = 0; i < 3; i++) q = put(q, OP_DRAW, &d, sizeof d); + q = put(q, OP_END, NULL, 0); + CHECK(q <= stream + sizeof stream, "pass-marks op stream overflow"); + uint64_t handle = (uint64_t)(uintptr_t)stream; + uint64_t f = b->submit(&handle, 1); + CHECK(b->fence_wait(f, 20000000000ull), "fence_wait of the pass-marks submission timed out"); + uint32_t started = 0, finished = 0; + vk_pass_marks_read(&started, &finished); + CHECK(started && started == finished, "after the fence the GPU last started mark %u and finished mark %u (before " + "the submission: %u and %u)", started, finished, s0, f0); + const VkPassMark *p1 = vk_pass_mark_record(finished), *dm = vk_pass_mark_record(finished - 1), + *p0 = vk_pass_mark_record(finished - 2); + CHECK(p1 && p1->kind == VK_MARK_PASS && p1->fence == f && p1->step == 1, + "the last finished mark %u is not pass 1 of submission %llu", finished, (unsigned long long)f); + CHECK(p1->w == TEX_W && p1->h == TEX_H && p1->d == 1 && p1->ncolor == 1 && + p1->color[0] == VK_FORMAT_R8G8B8A8_UNORM && p1->depth == VK_FORMAT_UNDEFINED, + "pass 1 has %ux%u, %u layers, %u colour targets, format %d, depth %d", p1->w, p1->h, p1->d, p1->ncolor, + (int)p1->color[0], (int)p1->depth); + CHECK(p1->draws == 3 && p1->first[0] && p1->first[1] && p1->first[0] == p1->last[0] && p1->first[1] == p1->last[1], + "pass 1 has %u draws (3 expected) and shaders %p %p ... %p %p", p1->draws, (const void *)p1->first[0], + (const void *)p1->first[1], (const void *)p1->last[0], (const void *)p1->last[1]); + CHECK(dm && dm->kind == VK_MARK_DISPATCH && dm->fence == f && dm->step == 0 && dm->w == 2 && dm->h == 1 && + dm->d == 1 && dm->first[0], + "the mark before pass 1 is not dispatch 0 of 2x1x1 groups of submission %llu", (unsigned long long)f); + CHECK(p0 && p0->kind == VK_MARK_PASS && p0->fence == f && p0->step == 0 && p0->draws == 2 && + p0->first[0] == p1->first[0], + "the mark before the dispatch is not pass 0 of submission %llu with 2 draws", (unsigned long long)f); + vk_pass_marks_format("VK_AMD_buffer_marker", started, finished, marks_text, sizeof marks_text); + char want[128]; + snprintf(want, sizeof want, "last finished %u: pass 1 of submission %llu: %ux%u, 1 layer, colour formats %d, ", + finished, (unsigned long long)f, TEX_W, TEX_H, (int)VK_FORMAT_R8G8B8A8_UNORM); + CHECK(strstr(marks_text, want) && strstr(marks_text, ", 3 draws; first vs "), + "the report text lacks \"%s\" or the draw count:\n%s", want, marks_text); + b->texture_release(&second); + return 0; +} + static int test_draw(const GfxBackend *b, uint8_t *guest, int *n_drawn, int *n_tries, int *n_cs) { char root[PLAT_PATH_MAX * 2], path[PLAT_PATH_MAX * 2 + 64]; CHECK(probe_census_dir(root, sizeof root), "no build/v%d/shaders/jobs.json above the exe (run tools/shader_census.py)", @@ -503,10 +572,12 @@ static int test_draw(const GfxBackend *b, uint8_t *guest, int *n_drawn, int *n_t // Compute: a few census compute shaders, one dispatch each, resources unbound (zero buffers and stand-in images). int dispatched = 0; + prog_t *cs_prog = NULL; for (int t = 0; t < 4 && t < nc; t++) { const DrawEnt *one[1] = {&e[cs[(long long)t * nc / (nc < 4 ? nc : 4)]]}; prog_t *prog = dr_prog(root, one, 1); CHECK(prog, "census code file of %.16s is missing", one[0]->key); + cs_prog = prog; uint8_t *q = stream; q = put(q, OP_BEGIN, NULL, 0); const p_bind_program bp = {prog, 1 << 5}; @@ -530,6 +601,7 @@ static int test_draw(const GfxBackend *b, uint8_t *guest, int *n_drawn, int *n_t dispatched++; ind_dispatches++; } + if (test_marks(b, &pool, &color, hit, cs_prog)) return 1; b->texture_release(&color); b->pool_fini(&pool); free(pairs), free(cs), free(e), free(jobs); @@ -936,6 +1008,11 @@ int probe_vkexec(void) { "between submissions mirrored, CPU bytes beside a fill kept, %d bytes compared)\n", mirror_bytes); else printf("probe-vkexec: mirror part skipped (memory mode import)\n"); + if (marks_skipped) + printf("probe-vkexec: pass marks part skipped (no VK_AMD_buffer_marker, or TOTK_PASS_CRUMBS=0)\n"); + else + printf("probe-vkexec: pass marks part passed (pass, dispatch, pass in one submission: the GPU's last started and " + "finished mark is the last pass, ring records exact); the report reads:\n%s\n", marks_text); printf("probe-vkexec: empty pool part passed (a zero-byte pool at the start of another: no Vulkan objects, lookups " "there find the other pool before and after its Finalize)\n"); return 0; diff --git a/runtime/vk_rec.c b/runtime/vk_rec.c index 969139c2..d48fa0b7 100644 --- a/runtime/vk_rec.c +++ b/runtime/vk_rec.c @@ -40,6 +40,7 @@ enum { R_SetRasterizerDiscardEnable, R_SetScissorWithCount, R_SetStencilCompareMask, R_SetStencilOp, R_SetStencilReference, R_SetStencilTestEnable, R_SetStencilWriteMask, R_SetViewportWithCount, R_WriteTimestamp, R_WriteTimestamp2, R_PushTpl, R_Push, R_VertexInput, R_Bool, R_PolygonMode, R_BlendEnable, R_BlendEquation, R_WriteMask, R_EndCb, + R_PassMark, }; static uint64_t now_ns(void) { return plat_now_ns(); } @@ -531,6 +532,14 @@ void rec_polygon_mode(PFN_vkCmdSetPolygonModeEXT fn, VkCommandBuffer cb, VkPolyg pub(); } +typedef struct { uint32_t id; int end; } A_PassMark; +void rec_pass_mark(VkCommandBuffer cb, uint32_t id, int end) { + if (!OWNED(cb)) { vk_pass_mark_cmd(cb, id, end); return; } + A_PassMark *a = put(R_PassMark, sizeof *a); + *a = (A_PassMark){id, end}; + pub(); +} + typedef struct { void *fn; uint32_t first, n; const void *v; } A_Targets; #define TARGET_CMD(fname, R, PFN, T) \ void fname(PFN fn, VkCommandBuffer cb, uint32_t first, uint32_t n, const T *v) { \ @@ -618,6 +627,7 @@ static void exec_packet(uint32_t op, void *p) { case R_BlendEnable: { A_Targets *a = p; ((PFN_vkCmdSetColorBlendEnableEXT)a->fn)(cb, a->first, a->n, a->v); break; } case R_BlendEquation: { A_Targets *a = p; ((PFN_vkCmdSetColorBlendEquationEXT)a->fn)(cb, a->first, a->n, a->v); break; } case R_WriteMask: { A_Targets *a = p; ((PFN_vkCmdSetColorWriteMaskEXT)a->fn)(cb, a->first, a->n, a->v); break; } + case R_PassMark: { A_PassMark *a = p; vk_pass_mark_cmd(cb, a->id, a->end); break; } case R_EndCb: { A_EndCb *a = p; if (a->kind) vk_crumb(cb, a->kind, a->n); diff --git a/runtime/vk_rec.h b/runtime/vk_rec.h index d4054e1e..53ae1464 100644 --- a/runtime/vk_rec.h +++ b/runtime/vk_rec.h @@ -38,6 +38,8 @@ void rec_blend_equation(PFN_vkCmdSetColorBlendEquationEXT fn, VkCommandBuffer cb const VkColorBlendEquationEXT *v); void rec_write_mask(PFN_vkCmdSetColorWriteMaskEXT fn, VkCommandBuffer cb, uint32_t first, uint32_t n, const VkColorComponentFlags *v); +// A pass mark (vk_crumbs.c vk_pass_mark_cmd: a buffer marker and a checkpoint), in order with the commands around it. +void rec_pass_mark(VkCommandBuffer cb, uint32_t id, int end); #define REC_CMDS(X) \ X(BeginQuery, (VkCommandBuffer cb, VkQueryPool p, uint32_t q, VkQueryControlFlags f), (cb, p, q, f)) \ diff --git a/totk.ini.example b/totk.ini.example index d326e511..e3e7f450 100644 --- a/totk.ini.example +++ b/totk.ini.example @@ -313,6 +313,10 @@ # takes longer than flight_spike_ms (0 to 60000). # flight = 0 # flight_spike_ms = 100 +# GPU pass marks: after a GPU crash (device lost) the log names the render pass or dispatch the GPU had started and the +# last one it finished. Unset: on AMD GPUs (VK_AMD_buffer_marker). 1: also on NVIDIA GPUs +# (VK_NV_device_diagnostic_checkpoints), which NVIDIA says costs a little. 0: off. +# pass_crumbs = 1 # Largest render target (bytes, 0 to 1073741824) that goes back to its game memory when the game waits for a GPU fence. # A game that reads a larger target without invalidating it sees stale bytes at the default. With trace = gfx the log # names each dirty target over the limit that stays on the GPU ("fence write-back skipped-for-size") and each one over