diff --git a/runtime/vk_pipeline.c b/runtime/vk_pipeline.c index dedf7a37..031ee897 100644 --- a/runtime/vk_pipeline.c +++ b/runtime/vk_pipeline.c @@ -101,6 +101,12 @@ static struct { VkPipeStats stats; } P = {.lock = PLAT_MUTEX_INIT}; +// Builds into P.cache take it shared, vk_pipeline_save takes it to copy the cache out. Vulkan lets +// vkGetPipelineCacheData run alongside builds into a cache created without the EXTERNALLY_SYNCHRONIZED bit, but +// Intel's Windows driver (101.7085, Iris Xe) faults in it (igvk64.dll, reading 0x170) when the first autosave meets the +// boot's pipeline builds (#681). Nothing is taken while it is held. +static PlatMutex cache_use = PLAT_MUTEX_INIT; + typedef struct Layout { struct Layout *next; uint64_t hash; @@ -1440,7 +1446,9 @@ static VkPipeline create_graphics(const VkPipeState *s, const GKey *k, const Lay if (k->fbl & 1) pi.flags |= VK_PIPELINE_CREATE_COLOR_ATTACHMENT_FEEDBACK_LOOP_BIT_EXT; if (k->fbl & 2) pi.flags |= VK_PIPELINE_CREATE_DEPTH_STENCIL_ATTACHMENT_FEEDBACK_LOOP_BIT_EXT; uint64_t p0 = perf_begin(); + plat_mutex_lock_shared(&cache_use); VkResult r = vkCreateGraphicsPipelines(P.device, P.cache, 1, &pi, NULL, &pipe); + plat_mutex_unlock_shared(&cache_use); perf_end(PERF_PIPE, p0); // counts on the render thread only, so background builds stay out of it if (r != VK_SUCCESS) { rt_log("vk_pipeline: vkCreateGraphicsPipelines failed (%d)", (int)r); @@ -1591,7 +1599,9 @@ static VkPipeline lib_create(int kind, const VkPipeState *s, const GKey *k, VkPi ri.depthAttachmentFormat = (VkFormat)k->depth, ri.stencilAttachmentFormat = (VkFormat)k->stencil; pi.pColorBlendState = &cb, pi.pMultisampleState = &ms; } + plat_mutex_lock_shared(&cache_use); if (vkCreateGraphicsPipelines(P.device, P.cache, 1, &pi, NULL, &pipe) != VK_SUCCESS) pipe = VK_NULL_HANDLE; + plat_mutex_unlock_shared(&cache_use); out: if (m) vkDestroyShaderModule(P.device, m, NULL); free(patched); @@ -1803,7 +1813,8 @@ static VkPipeline gpl_link(const VkPipeState *s, const GKey *k, const Layout *lc // shaders (gfx_shader_get results) live for the process (gfx_shader_drop_memory is the shader probe's, which builds no // pipelines), layouts until vk_pipeline_shutdown, which drains the queue first. Workers call vkCreateGraphicsPipelines // without P.lock: P.cache is created without VK_PIPELINE_CACHE_CREATE_EXTERNALLY_SYNCHRONIZED_BIT, so the driver -// synchronises it, vkGetPipelineCacheData in vk_pipeline_save included. Compute pipelines stay synchronous: a skipped +// synchronises the builds among themselves. vk_pipeline_save still keeps them apart from vkGetPipelineCacheData (see +// cache_use). Compute pipelines stay synchronous: a skipped // dispatch can change what the game computes. // // Two queues: draws' misses (A.head) and the boot prebuild (A.low, see "pipeline keys" below). Workers take the low @@ -2512,7 +2523,7 @@ static void prebuild_start(void) { plat_mutex_unlock(&P.lock); } -// A compute pipeline for cs in layout l; VK_NULL_HANDLE on failure. No lock needed (P.cache is driver-synchronised). +// A compute pipeline for cs in layout l; VK_NULL_HANDLE on failure. Takes cache_use shared, like the graphics builds. static VkPipeline compute_create(const GfxShader *cs, const Layout *l) { uint64_t words; const uint32_t *code = gfx_shader_spirv(cs, &words); @@ -2525,7 +2536,9 @@ static VkPipeline compute_create(const GfxShader *cs, const Layout *l) { .layout = l->layout}; pin_subgroup32(&ci.stage, &rqc, code, words); VkPipeline pipe = VK_NULL_HANDLE; + plat_mutex_lock_shared(&cache_use); if (vkCreateComputePipelines(P.device, P.cache, 1, &ci, NULL, &pipe) != VK_SUCCESS) pipe = VK_NULL_HANDLE; + plat_mutex_unlock_shared(&cache_use); vkDestroyShaderModule(P.device, m, NULL); return pipe; } @@ -3290,7 +3303,8 @@ void vk_pipeline_stats(VkPipeStats *s) { static PlatMutex save_lock = PLAT_MUTEX_INIT; // one cache save at a time; shutdown takes it to destroy the cache -void vk_pipeline_save(void) { +// One cache save; wait: queue for cache_use (the exit saves) rather than try for it (the autosave). +static void cache_save(int wait) { if (P.ready) keys_flush(); if (P.ready && P.gpl) { rt_log("vk_pipeline: gpl: %llu fast links (%llu by workers; avg %.2f ms, max %.2f ms, %llu failed), %llu draws " @@ -3317,23 +3331,39 @@ void vk_pipeline_save(void) { } gfx_shader_record_flush(1); if (!P.ready || !P.cache || !P.cache_path[0]) return; - // Not under P.lock: the driver synchronises P.cache, and holding P.lock through the copy and the file write (about - // 60 ms on the 1.4.3 fight) stopped every pipeline lookup of the replay, a freeze at each 20 s autosave. + // Not under P.lock: holding it through the copy and the file write (about 60 ms on the 1.4.3 fight) stopped every + // pipeline lookup of the replay, a freeze at each 20 s autosave. Only the copy takes cache_use, so no pipeline is + // being built into P.cache while the driver reads it. plat_mutex_lock(&save_lock); if (!P.cache) { // vk_pipeline_shutdown destroyed it plat_mutex_unlock(&save_lock); return; } + if (wait) { + plat_mutex_lock(&cache_use); + } else { + // The autosave never queues for cache_use: a queued exclusive request on an SRW lock holds back new shared + // ones, so the drawing thread's next build would wait for a worker's build to end. It tries for about 2 s + // and otherwise saves on its next round. + int got = 0; + for (int i = 0; i < 1000 && !(got = plat_mutex_trylock(&cache_use)); i++) plat_sleep_ms(2); + if (!got) { + plat_mutex_unlock(&save_lock); + return; + } + } size_t size = 0; void *data = NULL; - if (vkGetPipelineCacheData(P.device, P.cache, &size, NULL) == VK_SUCCESS && size && (data = malloc(size)) && - vkGetPipelineCacheData(P.device, P.cache, &size, data) == VK_SUCCESS) { - if (!plat_file_write_atomic(P.cache_path, data, size)) rt_log("vk_pipeline: cannot write %s", P.cache_path); - } + int ok = vkGetPipelineCacheData(P.device, P.cache, &size, NULL) == VK_SUCCESS && size && (data = malloc(size)) && + vkGetPipelineCacheData(P.device, P.cache, &size, data) == VK_SUCCESS; + plat_mutex_unlock(&cache_use); + if (ok && !plat_file_write_atomic(P.cache_path, data, size)) rt_log("vk_pipeline: cannot write %s", P.cache_path); free(data); plat_mutex_unlock(&save_lock); } +void vk_pipeline_save(void) { cache_save(1); } + // The game never shuts the device down (boot.c and the window end the process), so the cache is saved while it // runs: at most every 20 s, and only after new pipelines were built. New pipeline keys are appended every 2 s. static void autosave_once(void) { @@ -3347,7 +3377,7 @@ static void autosave_once(void) { vk_pipeline_stats(&s); if (s.graphics + s.compute == last_n) return; last_n = s.graphics + s.compute, last_ms = now; - vk_pipeline_save(); + cache_save(0); } // On its own thread: the save (vkGetPipelineCacheData and the file write, about 60 ms) and the key appends (a flush to