[vk] StreamBuffer Changes (#2684)

Tighter ring allocation + sync tracking with correct wrap/no-wrap, alignment, and per-range sync_ticks; update head/tail only when needed (wrap to 0 if tail won’t fit).

Adds safer sizing under debug tools by preferring device-local host-visible heaps with fallback.

Expected result: fewer stalls, steadier reuse, higher upload throughput.

Co-authored-by: Ribbit <ribbit@placeholder.com>
Reviewed-on: https://git.eden-emu.dev/eden-emu/eden/pulls/2684
Reviewed-by: MaranBr <maranbr@eden-emu.dev>
Reviewed-by: Lizzie <lizzie@eden-emu.dev>
Reviewed-by: CamilleLaVey <camillelavey99@gmail.com>
Co-authored-by: Ribbit <ribbit@eden-emu.dev>
Co-committed-by: Ribbit <ribbit@eden-emu.dev>

1 files changed, 46 insertions, 14 deletions

diff --git a/src/video_core/renderer_vulkan/vk_staging_buffer_pool.cpp b/src/video_core/renderer_vulkan/vk_staging_buffer_pool.cpp
index 08513d1534..ecc4f77dc7 100644
--- a/src/video_core/renderer_vulkan/vk_staging_buffer_pool.cpp
+++ b/src/video_core/renderer_vulkan/vk_staging_buffer_pool.cpp
@@ -33,19 +33,29 @@ constexpr VkDeviceSize MAX_STREAM_BUFFER_SIZE = 128_MiB;
 size_t GetStreamBufferSize(const Device& device) {
     VkDeviceSize size{0};
     if (device.HasDebuggingToolAttached()) {
-        ForEachDeviceLocalHostVisibleHeap(device, [&size](size_t index, VkMemoryHeap& heap) {
+        bool found_heap = false;
+        ForEachDeviceLocalHostVisibleHeap(device, [&size, &found_heap](size_t /*index*/, VkMemoryHeap& heap) {
             size = (std::max)(size, heap.size);
+            found_heap = true;
         });
-        // If rebar is not supported, cut the max heap size to 40%. This will allow 2 captures to be
-        // loaded at the same time in RenderDoc. If rebar is supported, this shouldn't be an issue
-        // as the heap will be much larger.
-        if (size <= 256_MiB) {
+        // If no suitable heap was found fall back to the default cap to avoid creating a zero-sized stream buffer.
+        if (!found_heap) {
+            size = MAX_STREAM_BUFFER_SIZE;
+        } else if (size <= 256_MiB) {
+            // If rebar is not supported, cut the max heap size to 40%. This will allow 2 captures to be
+            // loaded at the same time in RenderDoc. If rebar is supported, this shouldn't be an issue
+            // as the heap will be much larger.
             size = size * 40 / 100;
         }
     } else {
         size = MAX_STREAM_BUFFER_SIZE;
     }
-    return (std::min)(Common::AlignUp(size, MAX_ALIGNMENT), MAX_STREAM_BUFFER_SIZE);
+
+    // Clamp to the configured maximum, align up for safety, and ensure a sane minimum so
+    // region_size (stream_buffer_size / NUM_SYNCS) never becomes zero.
+    const VkDeviceSize aligned = (std::min)(Common::AlignUp(size, MAX_ALIGNMENT), MAX_STREAM_BUFFER_SIZE);
+    const VkDeviceSize min_size = MAX_ALIGNMENT * StagingBufferPool::NUM_SYNCS;
+    return static_cast<size_t>((std::max)(aligned, min_size));
 }
 } // Anonymous namespace
 
@@ -106,31 +116,53 @@ void StagingBufferPool::TickFrame() {
 }
 
 StagingBufferRef StagingBufferPool::GetStreamBuffer(size_t size) {
-    if (AreRegionsActive(Region(free_iterator) + 1,
-                         (std::min)(Region(iterator + size) + 1, NUM_SYNCS))) {
+    const size_t aligned_size = Common::AlignUp(size, MAX_ALIGNMENT);
+    const bool wraps = iterator + size >= stream_buffer_size;
+    const size_t new_iterator =
+        wraps ? aligned_size : Common::AlignUp(iterator + size, MAX_ALIGNMENT);
+    const size_t begin_region = wraps ? 0 : Region(iterator);
+    const size_t last_byte = new_iterator == 0 ? 0 : new_iterator - 1;
+    const size_t end_region = (std::min)(Region(last_byte) + 1, NUM_SYNCS);
+    const size_t guard_begin = (std::min)(Region(free_iterator) + 1, NUM_SYNCS);
+
+    if (!wraps) {
+        if (guard_begin < end_region && AreRegionsActive(guard_begin, end_region)) {
+            // Avoid waiting for the previous usages to be free
+            return GetStagingBuffer(size, MemoryUsage::Upload);
+        }
+    } else if (guard_begin < NUM_SYNCS && AreRegionsActive(guard_begin, NUM_SYNCS)) {
         // Avoid waiting for the previous usages to be free
         return GetStagingBuffer(size, MemoryUsage::Upload);
     }
+
     const u64 current_tick = scheduler.CurrentTick();
     std::fill(sync_ticks.begin() + Region(used_iterator), sync_ticks.begin() + Region(iterator),
               current_tick);
     used_iterator = iterator;
-    free_iterator = (std::max)(free_iterator, iterator + size);
 
-    if (iterator + size >= stream_buffer_size) {
+    if (wraps) {
         std::fill(sync_ticks.begin() + Region(used_iterator), sync_ticks.begin() + NUM_SYNCS,
                   current_tick);
         used_iterator = 0;
         iterator = 0;
         free_iterator = size;
-
-        if (AreRegionsActive(0, Region(size) + 1)) {
+        const size_t head_last_byte = aligned_size == 0 ? 0 : aligned_size - 1;
+        const size_t head_end_region = (std::min)(Region(head_last_byte) + 1, NUM_SYNCS);
+        if (AreRegionsActive(0, head_end_region)) {
             // Avoid waiting for the previous usages to be free
             return GetStagingBuffer(size, MemoryUsage::Upload);
         }
     }
-    const size_t offset = iterator;
-    iterator = Common::AlignUp(iterator + size, MAX_ALIGNMENT);
+
+    std::fill(sync_ticks.begin() + begin_region, sync_ticks.begin() + end_region, current_tick);
+
+    const size_t offset = wraps ? 0 : iterator;
+    iterator = new_iterator;
+
+    if (!wraps) {
+        free_iterator = (std::max)(free_iterator, offset + size);
+    }
+
     return StagingBufferRef{
         .buffer = *stream_buffer,
         .offset = static_cast<VkDeviceSize>(offset),