mirror of
https://github.com/valentderah/totk-pc-recomp.git
synced 2026-11-21 04:55:56 +00:00
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 <noreply@anthropic.com>
This commit is contained in:
1 parent
3e87747031
commit
710b7f5dd0
15 files changed
+414
-10
No files matched your search
@@ -39,6 +39,10 @@ build\<ver>\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.
|
||||
|
||||
+3
-2
@@ -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},
|
||||
};
|
||||
|
||||
|
||||
@@ -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];
|
||||
|
||||
@@ -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] = "打开日志文件夹",
|
||||
|
||||
@@ -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,
|
||||
|
||||
@@ -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
|
||||
|
||||
+202
-4
@@ -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 <stdint.h>
|
||||
#include <stdio.h>
|
||||
#include <string.h>
|
||||
|
||||
#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 <cache>/in/<id>.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();
|
||||
}
|
||||
+10
-3
@@ -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;
|
||||
|
||||
@@ -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;
|
||||
|
||||
@@ -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);
|
||||
|
||||
@@ -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);
|
||||
|
||||
+78
-1
@@ -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 <stdio.h>
|
||||
#include <stdlib.h>
|
||||
#include <string.h>
|
||||
@@ -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;
|
||||
|
||||
@@ -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);
|
||||
|
||||
@@ -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)) \
|
||||
|
||||
@@ -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
|
||||
|
||||
Reference in new issue
Block a user