gpu_hw_vulkan: lock-free fast-path lookup in lazy shader / PSO helpers
User-reported regression after commit 9d2997a: in Lazy mode, the
runloop is still effectively frozen for many seconds after a
texture-filter change. The root cause is mutex contention between
the background precompile worker and the main thread's
DrawBatchVertices path, not the precompile work itself - which
is doing exactly what it should.
The shipped Vulkan code took m_batch_shader_mutex on every
GetBatchPipeline / GetBatchFragmentShader call, including the
fast-path (slot already filled). With a 2160-entry PSO matrix and
~50-200 ms per cold vkCreateGraphicsPipelines call on heavy
filters, the precompile worker holds m_batch_shader_mutex for the
duration of every cell's compile. Every concurrent main-thread
draw blocks behind the in-flight compile, so the frontend gets no
frames returned for as long as the worker is making progress.
With heavy filters at full resolution, that's the better part of a
minute - perceived as a freeze, undoing the entire point of
'Lazy' mode.
Fix is the standard atomic-fast-path / locked-slow-path pattern.
m_batch_pipelines, m_batch_fragment_shaders and
m_batch_vertex_shaders flip from plain VkPipeline / VkShaderModule
to std::atomic<VkPipeline> / std::atomic<VkShaderModule>:
GetBatchFragmentShader / GetBatchPipeline first do a lock-free
atomic acquire-load on the requested slot. If the slot is
non-null (i.e. the worker has already published it, or an
earlier main-thread fault-in did) the helper returns it
immediately with no kernel calls and no serialisation against
the worker. This is what DrawBatchVertices hits in steady
state, so once the matrix is mostly populated the draw path
runs at full speed regardless of background compile activity.
Only the slow path (slot still null after the atomic load)
takes m_batch_shader_mutex - to serialise the underlying
g_vulkan_shader_cache mutations and the VkPipelineCache passed
to vkCreateGraphicsPipelines (both of which the spec / the cache
implementation require external synchronisation for). Under the
lock we double-check the slot in case another thread already
filled it while we were waiting; if it's still null we compile,
publish the result via memory_order_release, return.
GetBatchPipeline's slow path now calls GetBatchFragmentShader
WITHOUT holding m_batch_shader_mutex, because the helper takes the
same lock internally and std::mutex isn't recursive. The call is
also semantically independent (the fragment-shader fetch doesn't
need the same atomic-instant snapshot of the matrix that the PSO
compile does) so the ordering is safe.
DestroyPipelines's enumerate sweep can no longer use
Vulkan::Util::SafeDestroyPipeline / SafeDestroyShaderModule
directly because those expect a VkPipeline& / VkShaderModule&,
not std::atomic<>. Replaced with inline lambdas that load the
slot relaxed (the worker is guaranteed stopped by this point via
StopShaderCompileThread), call vkDestroy*, and clear the slot.
Concurrency model validated against a standalone TSAN harness
modelling the exact same pattern: 4-thread random-access workload
against a 1680-cell matrix with full dedup, plus repeated
destroy/recreate cycles. Results: exactly 1680 PSO compiles and
112 fragment-shader compiles (no double-compilation), no data
races flagged by TSAN, no deadlocks, all 5 destroy/recreate cycles
pass clean.
Note on what this does NOT fix: a draw that lands on a still-empty
slot will still serialise behind one in-flight worker compile
(~50-200 ms) before getting the mutex and compiling its own
fault-in. That's the rare cold-cache stall and it's bounded; the
common case once the worker has filled the hot subset of the
matrix is the lock-free fast path. If the per-cell stall in the
cold case still ends up user-visible, the next step is a per-
thread VkPipelineCache merged into the global cache after each
compile so the worker and the main thread can call
vkCreateGraphicsPipelines truly in parallel.
Builds clean with zero warnings on linux platform=unix. .so size
8035864 unchanged (atomic operations on pointer-sized types
compile to plain MOVs on x86-64 - no instruction-count cost on
the fast path). 25 retro_* exports unchanged.
Files touched:
- src/core/gpu_hw_vulkan.h: m_batch_pipelines /
m_batch_fragment_shaders / m_batch_vertex_shaders flipped to
std::atomic<>, mutex comment updated to reflect 'slow path
only' role
- src/core/gpu_hw_vulkan.cpp: GetBatchFragmentShader and
GetBatchPipeline restructured with the double-checked-locking
pattern, vertex shader fill uses explicit atomic store,
DestroyPipelines uses atomic-aware lambdas in place of the
SafeDestroy* enumerate callbacks
This commit is contained in:
parent
9d2997a601
commit
3d9d624ad0
2 changed files with 126 additions and 43 deletions
|
|
@ -1493,7 +1493,7 @@ bool GPU_HW_Vulkan::CompilePipelines()
|
|||
return false;
|
||||
}
|
||||
|
||||
batch_vertex_shaders[textured] = shader;
|
||||
batch_vertex_shaders[textured].store(shader, std::memory_order_release);
|
||||
progress.Increment();
|
||||
}
|
||||
|
||||
|
|
@ -1982,30 +1982,45 @@ VkShaderModule GPU_HW_Vulkan::GetBatchFragmentShader(u8 render_mode, u8 texture_
|
|||
(texture_mode == static_cast<u8>(GPUTextureMode::Reserved_RawDirect16Bit)) ? 6u :
|
||||
texture_mode;
|
||||
|
||||
// Caller is responsible for holding m_batch_shader_mutex
|
||||
// (GetBatchPipeline takes the lock; the Enabled-mode precompile
|
||||
// path is single-threaded).
|
||||
VkShaderModule& slot = m_batch_fragment_shaders[render_mode][lookup_mode][BoolToUInt8(dithering)][BoolToUInt8(interlacing)];
|
||||
// Fast path: lock-free load. Both the precompile worker and the
|
||||
// main thread can read a slot concurrently without contending
|
||||
// with each other or with each other's slow-path compiles.
|
||||
std::atomic<VkShaderModule>& slot =
|
||||
m_batch_fragment_shaders[render_mode][lookup_mode][BoolToUInt8(dithering)][BoolToUInt8(interlacing)];
|
||||
VkShaderModule existing = slot.load(std::memory_order_acquire);
|
||||
if (existing != VK_NULL_HANDLE)
|
||||
return existing;
|
||||
|
||||
if (slot == VK_NULL_HANDLE)
|
||||
// Slow path: take the compile mutex, re-check, compile if still
|
||||
// unset. The double-checked-locking pattern means a main-thread
|
||||
// lazy fault-in won't redundantly compile a slot the worker
|
||||
// just finished publishing.
|
||||
std::lock_guard<std::mutex> lock(m_batch_shader_mutex);
|
||||
|
||||
existing = slot.load(std::memory_order_relaxed);
|
||||
if (existing != VK_NULL_HANDLE)
|
||||
return existing;
|
||||
|
||||
if (!m_shadergen)
|
||||
{
|
||||
if (!m_shadergen)
|
||||
{
|
||||
Log_ErrorPrint("GetBatchFragmentShader called before CompilePipelines constructed the shadergen");
|
||||
return VK_NULL_HANDLE;
|
||||
}
|
||||
const std::string fs = m_shadergen->GenerateBatchFragmentShader(
|
||||
static_cast<BatchRenderMode>(render_mode), static_cast<GPUTextureMode>(lookup_mode), dithering, interlacing);
|
||||
slot = g_vulkan_shader_cache->GetFragmentShader(fs);
|
||||
if (slot == VK_NULL_HANDLE)
|
||||
{
|
||||
Log_ErrorPrintf("Lazy batch fragment shader compile failed for (rm=%u, tm=%u, d=%u, i=%u)", render_mode,
|
||||
texture_mode, BoolToUInt8(dithering), BoolToUInt8(interlacing));
|
||||
return VK_NULL_HANDLE;
|
||||
}
|
||||
Log_ErrorPrint("GetBatchFragmentShader called before CompilePipelines constructed the shadergen");
|
||||
return VK_NULL_HANDLE;
|
||||
}
|
||||
const std::string fs = m_shadergen->GenerateBatchFragmentShader(
|
||||
static_cast<BatchRenderMode>(render_mode), static_cast<GPUTextureMode>(lookup_mode), dithering, interlacing);
|
||||
VkShaderModule shader = g_vulkan_shader_cache->GetFragmentShader(fs);
|
||||
if (shader == VK_NULL_HANDLE)
|
||||
{
|
||||
Log_ErrorPrintf("Lazy batch fragment shader compile failed for (rm=%u, tm=%u, d=%u, i=%u)", render_mode,
|
||||
texture_mode, BoolToUInt8(dithering), BoolToUInt8(interlacing));
|
||||
return VK_NULL_HANDLE;
|
||||
}
|
||||
|
||||
return slot;
|
||||
// Publish under release ordering so a subsequent acquire load
|
||||
// observes both the slot value and any consumer-side state
|
||||
// initialised before this store.
|
||||
slot.store(shader, std::memory_order_release);
|
||||
return shader;
|
||||
}
|
||||
|
||||
VkPipeline GPU_HW_Vulkan::GetBatchPipeline(u8 depth_test, u8 render_mode, u8 texture_mode, u8 transparency_mode,
|
||||
|
|
@ -2018,19 +2033,36 @@ VkPipeline GPU_HW_Vulkan::GetBatchPipeline(u8 depth_test, u8 render_mode, u8 tex
|
|||
(texture_mode == static_cast<u8>(GPUTextureMode::Reserved_RawDirect16Bit)) ? 6u :
|
||||
texture_mode;
|
||||
|
||||
std::lock_guard<std::mutex> lock(m_batch_shader_mutex);
|
||||
std::atomic<VkPipeline>& slot =
|
||||
m_batch_pipelines[depth_test][render_mode][lookup_mode][transparency_mode][BoolToUInt8(dithering)]
|
||||
[BoolToUInt8(interlacing)];
|
||||
|
||||
VkPipeline& slot = m_batch_pipelines[depth_test][render_mode][lookup_mode][transparency_mode][BoolToUInt8(dithering)]
|
||||
[BoolToUInt8(interlacing)];
|
||||
// Fast path: lock-free atomic load. This is what DrawBatchVertices
|
||||
// hits once a slot is filled (either by the precompile worker or
|
||||
// by an earlier main-thread fault-in). No kernel call, no
|
||||
// serialisation against the worker.
|
||||
VkPipeline existing = slot.load(std::memory_order_acquire);
|
||||
if (existing != VK_NULL_HANDLE)
|
||||
return existing;
|
||||
|
||||
if (slot != VK_NULL_HANDLE)
|
||||
return slot;
|
||||
|
||||
// Need the bound fragment shader first.
|
||||
// Slow path. The shader-cache / pipeline-cache mutations and the
|
||||
// m_batch_pipelines store all need to be serialised against the
|
||||
// worker, but the fragment-shader fetch is a separate independent
|
||||
// step with its own internal locking - we call it WITHOUT holding
|
||||
// m_batch_shader_mutex so a sibling helper isn't deadlocked when
|
||||
// it tries to take the same lock.
|
||||
VkShaderModule fs = GetBatchFragmentShader(render_mode, lookup_mode, dithering, interlacing);
|
||||
if (fs == VK_NULL_HANDLE)
|
||||
return VK_NULL_HANDLE;
|
||||
|
||||
std::lock_guard<std::mutex> lock(m_batch_shader_mutex);
|
||||
|
||||
// Double-check under the lock - some other thread may have
|
||||
// compiled this slot while we were waiting on m_batch_shader_mutex.
|
||||
existing = slot.load(std::memory_order_relaxed);
|
||||
if (existing != VK_NULL_HANDLE)
|
||||
return existing;
|
||||
|
||||
static constexpr std::array<VkCompareOp, 3> depth_test_values = {
|
||||
VK_COMPARE_OP_ALWAYS, VK_COMPARE_OP_GREATER_OR_EQUAL, VK_COMPARE_OP_LESS_OR_EQUAL};
|
||||
const bool textured = (static_cast<GPUTextureMode>(lookup_mode) != GPUTextureMode::Disabled);
|
||||
|
|
@ -2051,7 +2083,10 @@ VkPipeline GPU_HW_Vulkan::GetBatchPipeline(u8 depth_test, u8 render_mode, u8 tex
|
|||
}
|
||||
|
||||
gpbuilder.SetPrimitiveTopology(VK_PRIMITIVE_TOPOLOGY_TRIANGLE_LIST);
|
||||
gpbuilder.SetVertexShader(m_batch_vertex_shaders[BoolToUInt8(textured)]);
|
||||
// Vertex shaders are filled at CompilePipelines time before the
|
||||
// worker is spawned, so a relaxed load is sufficient - we're
|
||||
// strictly after that store in happens-before order.
|
||||
gpbuilder.SetVertexShader(m_batch_vertex_shaders[BoolToUInt8(textured)].load(std::memory_order_relaxed));
|
||||
gpbuilder.SetFragmentShader(fs);
|
||||
|
||||
gpbuilder.SetRasterizationState(VK_POLYGON_MODE_FILL, VK_CULL_MODE_NONE, VK_FRONT_FACE_CLOCKWISE);
|
||||
|
|
@ -2103,8 +2138,10 @@ VkPipeline GPU_HW_Vulkan::GetBatchPipeline(u8 depth_test, u8 render_mode, u8 tex
|
|||
return VK_NULL_HANDLE;
|
||||
}
|
||||
|
||||
slot = pipeline;
|
||||
return slot;
|
||||
// Publish under release ordering. DrawBatchVertices' acquire load
|
||||
// pairs with this store.
|
||||
slot.store(pipeline, std::memory_order_release);
|
||||
return pipeline;
|
||||
}
|
||||
|
||||
void GPU_HW_Vulkan::DestroyPipelines()
|
||||
|
|
@ -2115,9 +2152,34 @@ void GPU_HW_Vulkan::DestroyPipelines()
|
|||
StopShaderCompileThread();
|
||||
m_shadergen.reset();
|
||||
|
||||
m_batch_pipelines.enumerate(Vulkan::Util::SafeDestroyPipeline);
|
||||
m_batch_fragment_shaders.enumerate(Vulkan::Util::SafeDestroyShaderModule);
|
||||
m_batch_vertex_shaders.enumerate(Vulkan::Util::SafeDestroyShaderModule);
|
||||
// Atomic slot teardown. By this point the worker is stopped and
|
||||
// no other thread is touching the arrays, so memory_order_relaxed
|
||||
// is sufficient.
|
||||
VkDevice device = g_vulkan_context->GetDevice();
|
||||
m_batch_pipelines.enumerate([device](std::atomic<VkPipeline>& slot) {
|
||||
VkPipeline p = slot.load(std::memory_order_relaxed);
|
||||
if (p != VK_NULL_HANDLE)
|
||||
{
|
||||
vkDestroyPipeline(device, p, nullptr);
|
||||
slot.store(VK_NULL_HANDLE, std::memory_order_relaxed);
|
||||
}
|
||||
});
|
||||
m_batch_fragment_shaders.enumerate([device](std::atomic<VkShaderModule>& slot) {
|
||||
VkShaderModule m = slot.load(std::memory_order_relaxed);
|
||||
if (m != VK_NULL_HANDLE)
|
||||
{
|
||||
vkDestroyShaderModule(device, m, nullptr);
|
||||
slot.store(VK_NULL_HANDLE, std::memory_order_relaxed);
|
||||
}
|
||||
});
|
||||
m_batch_vertex_shaders.enumerate([device](std::atomic<VkShaderModule>& slot) {
|
||||
VkShaderModule m = slot.load(std::memory_order_relaxed);
|
||||
if (m != VK_NULL_HANDLE)
|
||||
{
|
||||
vkDestroyShaderModule(device, m, nullptr);
|
||||
slot.store(VK_NULL_HANDLE, std::memory_order_relaxed);
|
||||
}
|
||||
});
|
||||
|
||||
m_vram_fill_pipelines.enumerate(Vulkan::Util::SafeDestroyPipeline);
|
||||
|
||||
|
|
|
|||
|
|
@ -235,7 +235,24 @@ private:
|
|||
VkBufferView m_texture_stream_buffer_view = VK_NULL_HANDLE;
|
||||
|
||||
// [depth_test][render_mode][texture_mode][transparency_mode][dithering][interlacing]
|
||||
DimensionalArray<VkPipeline, 2, 2, 5, 9, 4, 3> m_batch_pipelines{};
|
||||
//
|
||||
// std::atomic<VkPipeline> rather than a plain VkPipeline so the
|
||||
// draw path can sample a slot without taking any lock. The slow
|
||||
// path (slot still null after the atomic load) takes the compile
|
||||
// mutex, re-checks the slot, compiles if still null, publishes
|
||||
// back to the slot. The fast path - which is what DrawBatchVertices
|
||||
// hits once a slot has been filled either by the precompile worker
|
||||
// or by an earlier main-thread fault-in - is a single
|
||||
// memory_order_acquire load with no kernel calls and no
|
||||
// serialisation against the worker. Without this, the user-visible
|
||||
// experience after a texture-filter change was a multi-second
|
||||
// hang: the precompile worker holds m_batch_shader_mutex for the
|
||||
// duration of each ~50-200 ms vkCreateGraphicsPipelines call, so
|
||||
// every concurrent main-thread DrawBatchVertices stalled behind
|
||||
// it for one PSO compile, and the runloop never made forward
|
||||
// progress until the worker finished the entire 2160-entry
|
||||
// matrix.
|
||||
DimensionalArray<std::atomic<VkPipeline>, 2, 2, 5, 9, 4, 3> m_batch_pipelines{};
|
||||
|
||||
// Persistent vertex / fragment shader modules and shadergen for
|
||||
// the lazy and background-thread compile paths. These used to be
|
||||
|
|
@ -248,22 +265,26 @@ private:
|
|||
// helper-entry remap (see GetBatchFragmentShader) routes all
|
||||
// accesses through the canonical slots 2 / 6.
|
||||
//
|
||||
// m_batch_shader_mutex serialises:
|
||||
// m_batch_shader_mutex serialises the SLOW path of the lazy
|
||||
// helpers:
|
||||
// - g_vulkan_shader_cache mutations (its unordered_map indices
|
||||
// aren't thread-safe on insert)
|
||||
// - the VkPipelineCache passed to vkCreateGraphicsPipelines
|
||||
// (Vulkan spec: must be externally synchronised when shared
|
||||
// across threads)
|
||||
// - the m_batch_fragment_shaders / m_batch_pipelines matrix
|
||||
// writes
|
||||
// Fast path: one uncontended mutex lock per DrawBatchVertices.
|
||||
// - the writes that publish a newly-compiled VkPipeline /
|
||||
// VkShaderModule back into the matrix slot
|
||||
// The FAST path - draw-time lookup of an already-filled slot -
|
||||
// does NOT take this mutex; it uses an atomic load on the slot
|
||||
// itself. See the comment on m_batch_pipelines above for why
|
||||
// this matters.
|
||||
std::mutex m_batch_shader_mutex;
|
||||
std::unique_ptr<GPU_HW_ShaderGen> m_shadergen;
|
||||
std::thread m_shader_compile_thread;
|
||||
std::atomic<bool> m_shader_compile_thread_quit{false};
|
||||
|
||||
DimensionalArray<VkShaderModule, 2> m_batch_vertex_shaders{}; // [textured]
|
||||
DimensionalArray<VkShaderModule, 2, 2, 9, 4> m_batch_fragment_shaders{}; // [render][texture][dither][interlace]
|
||||
DimensionalArray<std::atomic<VkShaderModule>, 2> m_batch_vertex_shaders{}; // [textured]
|
||||
DimensionalArray<std::atomic<VkShaderModule>, 2, 2, 9, 4> m_batch_fragment_shaders{}; // [render][texture][dither][interlace]
|
||||
|
||||
// [wrapped][interlaced]
|
||||
DimensionalArray<VkPipeline, 2, 2> m_vram_fill_pipelines{};
|
||||
|
|
|
|||
Loading…
Add table
Add a link
Reference in a new issue