[vk] More identation fix

Signed-off-by: Caio Oliveira <caiooliveirafarias0@gmail.com>

src/video_core/renderer_vulkan/vk_descriptor_pool.cpp

@@ -20,7 +20,7 @@
 namespace Vulkan {
 
 // Prefer small grow rates to avoid saturating the descriptor pool with barely used pipelines
-//constexpr size_t SETS_GROW_RATE = 32; //test difference between 16 and 32
+constexpr size_t SETS_GROW_RATE = 16;
 constexpr s32 SCORE_THRESHOLD = 3;
 
 struct DescriptorBank {
@@ -29,12 +29,9 @@ struct DescriptorBank {
 };
 
 bool DescriptorBankInfo::IsSuperset(const DescriptorBankInfo& subset) const noexcept {
-    return uniform_buffers >= subset.uniform_buffers &&
-           storage_buffers >= subset.storage_buffers &&
-           texture_buffers >= subset.texture_buffers &&
-           image_buffers >= subset.image_buffers &&
-           textures >= subset.textures &&
-           images >= subset.images;
+    return uniform_buffers >= subset.uniform_buffers && storage_buffers >= subset.storage_buffers &&
+           texture_buffers >= subset.texture_buffers && image_buffers >= subset.image_buffers &&
+           textures >= subset.textures && images >= subset.images;
 }
 
 template <typename Descriptors>
@@ -48,19 +45,6 @@ static u32 Accumulate(const Descriptors& descriptors) {
 
 static DescriptorBankInfo MakeBankInfo(std::span<const Shader::Info> infos) {
     DescriptorBankInfo bank;
-    if (infos.size() == 1) {
-        const auto& info = infos.front();
-        const auto acc = [](const auto& ds){ u32 c=0; for (const auto& d: ds) c+=d.count; return c; };
-        bank.uniform_buffers += acc(info.constant_buffer_descriptors);
-        bank.storage_buffers += acc(info.storage_buffers_descriptors);
-        bank.texture_buffers += acc(info.texture_buffer_descriptors);
-        bank.image_buffers   += acc(info.image_buffer_descriptors);
-        bank.textures        += acc(info.texture_descriptors);
-        bank.images          += acc(info.image_descriptors);
-        bank.score = bank.uniform_buffers + bank.storage_buffers + bank.texture_buffers +
-        bank.image_buffers + bank.textures + bank.images;
-        return bank;
-    }
     for (const Shader::Info& info : infos) {
         bank.uniform_buffers += Accumulate(info.constant_buffer_descriptors);
         bank.storage_buffers += Accumulate(info.storage_buffers_descriptors);
@@ -103,58 +87,48 @@ static void AllocatePool(const Device& device, DescriptorBank& bank) {
     }));
 }
 
-static size_t GetGrowRate() {
-    if (Settings::getDebugKnobAt(0))
-        return 8;
-    else if (Settings::getDebugKnobAt(1))
-        return 16;
-    else if (Settings::getDebugKnobAt(2))
-        return 24;
-    else if (Settings::getDebugKnobAt(3))
-        return 32;
-    else if (Settings::getDebugKnobAt(4))
-        return 40;
-    else if (Settings::getDebugKnobAt(5))
-        return 48;
-    else if (Settings::getDebugKnobAt(6))
-        return 56;
-    else if (Settings::getDebugKnobAt(7))
-        return 64;
-    else
-        return 16;
-}
-
 DescriptorAllocator::DescriptorAllocator(const Device& device_, MasterSemaphore& master_semaphore_,
                                          DescriptorBank& bank_, VkDescriptorSetLayout layout_)
-    : ResourcePool(master_semaphore_, /*SETS_GROW_RATE*/ GetGrowRate()), device{&device_}, bank{&bank_},
-      layout{layout_}, grow_rate{GetGrowRate()} {}
+    : ResourcePool(master_semaphore_, SETS_GROW_RATE), device{&device_}, bank{&bank_},
+      layout{layout_} {}
 
 VkDescriptorSet DescriptorAllocator::Commit() {
     const size_t index = CommitResource();
-    return sets[index / grow_rate][index % grow_rate];
+    return sets[index / SETS_GROW_RATE][index % SETS_GROW_RATE];
+}
+
+VkDescriptorSet DescriptorAllocator::CommitWithTracking(u64 current_frame, const void* descriptor_data) {
+     const size_t index = CommitResource();
+     const size_t group = index / SETS_GROW_RATE;
+     const size_t slot  = index % SETS_GROW_RATE;
+     set_states[group][slot].set               = sets[group][slot];
+     set_states[group][slot].last_update_frame = current_frame;
+     set_states[group][slot].last_data_ptr     = descriptor_data;
+     return set_states[group][slot].set;
+}
+
+bool DescriptorAllocator::NeedsUpdate(VkDescriptorSet set, u64 current_frame, const void* descriptor_data) const {
+     for (const auto& group : set_states)
+          for (const auto& st : group)
+               if (st.set == set) // Update if pointer changed or the set hasn't been updated this frame
+                    return st.last_data_ptr != descriptor_data || st.last_update_frame != current_frame;
+     return true;
 }
 
 void DescriptorAllocator::Allocate(size_t begin, size_t end) {
-    sets.push_back(AllocateDescriptors(end - begin));
+    const size_t count = end - begin;
+    sets.push_back(AllocateDescriptors(count));
+    set_states.emplace_back(count); // create parallel state storage
 }
 
 vk::DescriptorSets DescriptorAllocator::AllocateDescriptors(size_t count) {
-    std::array<VkDescriptorSetLayout, 64> stack{};
-    const VkDescriptorSetLayout* p_layouts = nullptr;
-    std::vector<VkDescriptorSetLayout> heap;
-    if (count <= stack.size()) {
-        stack.fill(layout);
-        p_layouts = stack.data();
-    } else {
-        heap.assign(count, layout);
-        p_layouts = heap.data();
-        }
+    const std::vector<VkDescriptorSetLayout> layouts(count, layout);
     VkDescriptorSetAllocateInfo allocate_info{
         .sType = VK_STRUCTURE_TYPE_DESCRIPTOR_SET_ALLOCATE_INFO,
         .pNext = nullptr,
         .descriptorPool = *bank->pools.back(),
         .descriptorSetCount = static_cast<u32>(count),
-        .pSetLayouts = p_layouts,
+        .pSetLayouts = layouts.data(),
     };
     vk::DescriptorSets new_sets = bank->pools.back().Allocate(allocate_info);
     if (!new_sets.IsOutOfPoolMemory()) {
@@ -192,58 +166,21 @@ DescriptorAllocator DescriptorPool::Allocator(VkDescriptorSetLayout layout,
 }
 
 DescriptorBank& DescriptorPool::Bank(const DescriptorBankInfo& reqs) {
-    {
-        std::scoped_lock lk(cache_mutex);
-        DescriptorBank* best = nullptr; u64 best_stamp = 0;
-        for (const auto& e : cache_) {
-            if (!e.bank) continue;
-            if (std::abs(e.info.score - reqs.score) < SCORE_THRESHOLD && e.info.IsSuperset(reqs)) {
-                if (e.stamp >= best_stamp) { best_stamp = e.stamp; best = e.bank; }
-            }
-        }
-        if (best) return *best;
-    }
     std::shared_lock read_lock{banks_mutex};
     const auto it = std::ranges::find_if(bank_infos, [&reqs](const DescriptorBankInfo& bank) {
         return std::abs(bank.score - reqs.score) < SCORE_THRESHOLD && bank.IsSuperset(reqs);
     });
     if (it != bank_infos.end()) {
-        DescriptorBank& found = *banks[std::distance(bank_infos.begin(), it)].get();
-        read_lock.unlock();
-        // update cache
-        std::scoped_lock lk(cache_mutex);
-        size_t victim = 0; u64 oldest = UINT64_MAX;
-        for (size_t i=0;i<cache_.size();++i) if (cache_[i].stamp < oldest) { oldest = cache_[i].stamp; victim = i; }
-             cache_[victim] = CacheEntry{found.info, &found, ++cache_tick_};
-        return found;
+        return *banks[std::distance(bank_infos.begin(), it)].get();
     }
     read_lock.unlock();
 
     std::unique_lock write_lock{banks_mutex};
-    auto it2 = std::ranges::find_if(bank_infos, [&reqs](const DescriptorBankInfo& bank) {
-          return std::abs(bank.score - reqs.score) < SCORE_THRESHOLD && bank.IsSuperset(reqs);
-    });
-    if (it2 != bank_infos.end()) {
-        DescriptorBank& found = *banks[std::distance(bank_infos.begin(), it2)].get();
-        // update cache
-        std::scoped_lock lk(cache_mutex);
-        size_t victim = 0; u64 oldest = UINT64_MAX;
-        for (size_t i=0;i<cache_.size();++i) if (cache_[i].stamp < oldest) { oldest = cache_[i].stamp; victim = i; }
-        cache_[victim] = CacheEntry{found.info, &found, ++cache_tick_};
-        return found;
-    }
     bank_infos.push_back(reqs);
 
     auto& bank = *banks.emplace_back(std::make_unique<DescriptorBank>());
     bank.info = reqs;
     AllocatePool(device, bank);
-    // update cache
-    {
-         std::scoped_lock lk(cache_mutex);
-         size_t victim = 0; u64 oldest = UINT64_MAX;
-         for (size_t i=0;i<cache_.size();++i) if (cache_[i].stamp < oldest) { oldest = cache_[i].stamp; victim = i; }
-         cache_[victim] = CacheEntry{bank.info, &bank, ++cache_tick_};
-    }
     return bank;
 }
 

src/video_core/renderer_vulkan/vk_descriptor_pool.h

@@ -9,8 +9,7 @@
 #include <shared_mutex>
 #include <span>
 #include <vector>
-#include <array>
-#include <mutex>
+#include "common/common_types.h"
 #include "shader_recompiler/shader_info.h"
 #include "video_core/renderer_vulkan/vk_resource_pool.h"
 #include "video_core/vulkan_common/vulkan_wrapper.h"
@@ -48,7 +47,15 @@ public:
     DescriptorAllocator(const DescriptorAllocator&) = delete;
 
     VkDescriptorSet Commit();
+    // commit + remember when/with what we last updated this set
+    struct DescriptorSetState {
+           VkDescriptorSet set = VK_NULL_HANDLE;
+           u64 last_update_frame = 0;
+           const void* last_data_ptr = nullptr; // fast pointer compare
+    };
 
+    VkDescriptorSet CommitWithTracking(u64 current_frame, const void* descriptor_data);
+    bool NeedsUpdate(VkDescriptorSet set, u64 current_frame, const void* descriptor_data) const;
 private:
     explicit DescriptorAllocator(const Device& device_, MasterSemaphore& master_semaphore_,
                                  DescriptorBank& bank_, VkDescriptorSetLayout layout_);
@@ -62,7 +69,7 @@ private:
     VkDescriptorSetLayout layout{};
 
     std::vector<vk::DescriptorSets> sets;
-    size_t grow_rate = 32;
+    std::vector<std::vector<DescriptorSetState>> set_states;
 };
 
 class DescriptorPool {
@@ -80,14 +87,6 @@ public:
 
 private:
     DescriptorBank& Bank(const DescriptorBankInfo& reqs);
-    struct CacheEntry {
-        DescriptorBankInfo info{};
-        DescriptorBank* bank{nullptr};
-        u64 stamp{0};
-    };
-    std::mutex cache_mutex{};
-    std::array<CacheEntry, 8> cache_{}; //test and then adjust
-    u64 cache_tick_{0};
 
     const Device& device;
     MasterSemaphore& master_semaphore;

src/video_core/renderer_vulkan/vk_graphics_pipeline.cpp

@@ -515,7 +515,20 @@ void GraphicsPipeline::ConfigureDraw(const RescalingPushConstant& rescaling,
     const bool update_rescaling{scheduler.UpdateRescaling(is_rescaling)};
     const bool bind_pipeline{scheduler.UpdateGraphicsPipeline(this)};
     const void* const descriptor_data{guest_descriptor_queue.UpdateData()};
-    scheduler.Record([this, descriptor_data, bind_pipeline, rescaling_data = rescaling.Data(),
+
+    // allocate/bind descriptor set and only update if needed
+    VkDescriptorSet descriptor_set = VK_NULL_HANDLE;
+    bool needs_update = false;
+    if (descriptor_set_layout && !uses_push_descriptor) {
+        descriptor_set = descriptor_allocator.CommitWithTracking(current_frame_number, descriptor_data);
+        needs_update = descriptor_allocator.NeedsUpdate(descriptor_set, current_frame_number, descriptor_data);
+        if (needs_update) {
+            const vk::Device& dev{device.GetLogical()};
+            dev.UpdateDescriptorSet(descriptor_set, *descriptor_update_template, descriptor_data);
+        }
+    }
+
+    scheduler.Record([this, descriptor_data, descriptor_set, bind_pipeline, rescaling_data = rescaling.Data(),
                       is_rescaling, update_rescaling,
                       uses_render_area = render_area.uses_render_area,
                       render_area_data = render_area.words](vk::CommandBuffer cmdbuf) {
@@ -541,12 +554,8 @@ void GraphicsPipeline::ConfigureDraw(const RescalingPushConstant& rescaling,
             return;
         }
         if (uses_push_descriptor) {
-            cmdbuf.PushDescriptorSetWithTemplateKHR(*descriptor_update_template, *pipeline_layout,
-                                                    0, descriptor_data);
+            cmdbuf.PushDescriptorSetWithTemplateKHR(*descriptor_update_template, *pipeline_layout, 0, descriptor_data);
         } else {
-            const VkDescriptorSet descriptor_set{descriptor_allocator.Commit()};
-            const vk::Device& dev{device.GetLogical()};
-            dev.UpdateDescriptorSet(descriptor_set, *descriptor_update_template, descriptor_data);
             cmdbuf.BindDescriptorSets(VK_PIPELINE_BIND_POINT_GRAPHICS, *pipeline_layout, 0,
                                       descriptor_set, nullptr);
         }

src/video_core/renderer_vulkan/vk_graphics_pipeline.h

@@ -116,7 +116,7 @@ public:
         maxwell3d = maxwell3d_;
         gpu_memory = gpu_memory_;
     }
-
+    void SetFrameNumber(u64 frame) { current_frame_number = frame; }
 private:
     template <typename Spec>
     bool ConfigureImpl(bool is_indexed);
@@ -160,6 +160,7 @@ private:
     std::mutex build_mutex;
     std::atomic_bool is_built{false};
     bool uses_push_descriptor{false};
+    u64 current_frame_number{0};
 };
 
 } // namespace Vulkan

src/video_core/renderer_vulkan/vk_rasterizer.cpp

@@ -234,6 +234,7 @@ void RasterizerVulkan::PrepareDraw(bool is_indexed, Func&& draw_func) {
     std::scoped_lock lock{buffer_cache.mutex, texture_cache.mutex};
     // update engine as channel may be different.
     pipeline->SetEngine(maxwell3d, gpu_memory);
+    pipeline->SetFrameNumber(current_frame_number);
     if (!pipeline->Configure(is_indexed))
         return;
 
@@ -771,6 +772,7 @@ void RasterizerVulkan::FlushCommands() {
 }
 
 void RasterizerVulkan::TickFrame() {
+    current_frame_number++;
     draw_counter = 0;
     guest_descriptor_queue.TickFrame();
     compute_pass_descriptor_queue.TickFrame();

src/video_core/renderer_vulkan/vk_rasterizer.h

@@ -160,7 +160,7 @@ private:
     void UpdateDynamicStates();
 
     void HandleTransformFeedback();
-
+    u64 current_frame_number{0};
     void UpdateViewportsState(Tegra::Engines::Maxwell3D::Regs& regs);
     void UpdateScissorsState(Tegra::Engines::Maxwell3D::Regs& regs);
     void UpdateDepthBias(Tegra::Engines::Maxwell3D::Regs& regs);