From 0e8cf38f392f2ea6f7f5195070ad721b78590c04 Mon Sep 17 00:00:00 2001
From: Fernando Sahmkow <fsahmkow27@gmail.com>
Date: Mon, 26 Jul 2021 09:33:00 +0200
Subject: Texture Cache: Implement Blacklisting.

---
 .../renderer_vulkan/vk_compute_pipeline.cpp        | 29 ++++++++++++++++++++--
 .../renderer_vulkan/vk_graphics_pipeline.cpp       | 28 ++++++++++++++++++++-
 2 files changed, 54 insertions(+), 3 deletions(-)

(limited to 'src/video_core/renderer_vulkan')

diff --git a/src/video_core/renderer_vulkan/vk_compute_pipeline.cpp b/src/video_core/renderer_vulkan/vk_compute_pipeline.cpp
index bda75788c..5c591e345 100644
--- a/src/video_core/renderer_vulkan/vk_compute_pipeline.cpp
+++ b/src/video_core/renderer_vulkan/vk_compute_pipeline.cpp
@@ -111,6 +111,7 @@ void ComputePipeline::Configure(Tegra::Engines::KeplerCompute& kepler_compute,
     std::array<ImageId, max_elements> image_view_ids;
     boost::container::static_vector<u32, max_elements> image_view_indices;
     boost::container::static_vector<VkSampler, max_elements> samplers;
+    boost::container::static_vector<bool, max_elements> image_view_blacklist;
 
     const auto& qmd{kepler_compute.launch_description};
     const auto& cbufs{qmd.const_buffer_config};
@@ -151,10 +152,34 @@ void ComputePipeline::Configure(Tegra::Engines::KeplerCompute& kepler_compute,
             samplers.push_back(sampler->Handle());
         }
     }
-    std::ranges::for_each(info.image_descriptors, add_image);
+    const u32 black_list_base = image_view_indices.size();
+    bool atleast_one_blacklisted = false;
+    for (const auto& desc : info.image_descriptors) {
+        const bool is_black_listed =
+            desc.is_written && (desc.type == Shader::TextureType::Color2D ||
+                                desc.type == Shader::TextureType::ColorArray2D);
+        for (u32 index = 0; index < desc.count; ++index) {
+            image_view_blacklist.push_back(is_black_listed);
+        }
+        atleast_one_blacklisted |= is_black_listed;
+        add_image(desc);
+    }
 
     const std::span indices_span(image_view_indices.data(), image_view_indices.size());
-    texture_cache.FillComputeImageViews(indices_span, image_view_ids);
+    bool has_listed_stuffs;
+    do {
+        has_listed_stuffs = false;
+        texture_cache.FillComputeImageViews(indices_span, image_view_ids);
+        if (atleast_one_blacklisted) {
+            for (u32 index = 0; index < image_view_blacklist.size(); index++) {
+                if (image_view_blacklist[index]) {
+                    ImageView& image_view{
+                        texture_cache.GetImageView(image_view_ids[index + black_list_base])};
+                    has_listed_stuffs |= texture_cache.BlackListImage(image_view.image_id);
+                }
+            }
+        }
+    } while (has_listed_stuffs);
 
     buffer_cache.UnbindComputeTextureBuffers();
     ImageId* texture_buffer_ids{image_view_ids.data()};
diff --git a/src/video_core/renderer_vulkan/vk_graphics_pipeline.cpp b/src/video_core/renderer_vulkan/vk_graphics_pipeline.cpp
index 967762c37..4d966ee4b 100644
--- a/src/video_core/renderer_vulkan/vk_graphics_pipeline.cpp
+++ b/src/video_core/renderer_vulkan/vk_graphics_pipeline.cpp
@@ -280,6 +280,7 @@ template <typename Spec>
 void GraphicsPipeline::ConfigureImpl(bool is_indexed) {
     std::array<ImageId, MAX_IMAGE_ELEMENTS> image_view_ids;
     std::array<u32, MAX_IMAGE_ELEMENTS> image_view_indices;
+    std::array<bool, MAX_IMAGE_ELEMENTS> image_view_blacklist;
     std::array<VkSampler, MAX_IMAGE_ELEMENTS> samplers;
     size_t sampler_index{};
     size_t image_index{};
@@ -290,6 +291,8 @@ void GraphicsPipeline::ConfigureImpl(bool is_indexed) {
 
     const auto& regs{maxwell3d.regs};
     const bool via_header_index{regs.sampler_index == Maxwell::SamplerIndex::ViaHeaderIndex};
+    u32 start_black_list = std::numeric_limits<u32>::max();
+    u32 end_black_list = 0;
     const auto config_stage{[&](size_t stage) LAMBDA_FORCEINLINE {
         const Shader::Info& info{stage_infos[stage]};
         buffer_cache.UnbindGraphicsStorageBuffers(stage);
@@ -350,6 +353,15 @@ void GraphicsPipeline::ConfigureImpl(bool is_indexed) {
         }
         if constexpr (Spec::has_images) {
             for (const auto& desc : info.image_descriptors) {
+                if (desc.is_written && (desc.type == Shader::TextureType::Color2D ||
+                                        desc.type == Shader::TextureType::ColorArray2D)) {
+                    auto index_copy = image_index;
+                    for (u32 index = 0; index < desc.count; ++index) {
+                        start_black_list = std::min<u32>(start_black_list, index_copy);
+                        image_view_blacklist[index_copy++] = true;
+                        end_black_list = std::max<u32>(end_black_list, index_copy);
+                    }
+                }
                 add_image(desc);
             }
         }
@@ -370,7 +382,21 @@ void GraphicsPipeline::ConfigureImpl(bool is_indexed) {
         config_stage(4);
     }
     const std::span indices_span(image_view_indices.data(), image_index);
-    texture_cache.FillGraphicsImageViews(indices_span, image_view_ids);
+    bool has_listed_stuffs;
+    do {
+        has_listed_stuffs = false;
+        texture_cache.FillGraphicsImageViews(indices_span, image_view_ids);
+        if constexpr (Spec::has_images) {
+            if (start_black_list < end_black_list) {
+                for (u32 index = start_black_list; index < end_black_list; index++) {
+                    if (image_view_blacklist[index]) {
+                        ImageView& image_view{texture_cache.GetImageView(image_view_ids[index])};
+                        has_listed_stuffs |= texture_cache.BlackListImage(image_view.image_id);
+                    }
+                }
+            }
+        }
+    } while (has_listed_stuffs);
 
     ImageId* texture_buffer_index{image_view_ids.data()};
     const auto bind_stage_info{[&](size_t stage) LAMBDA_FORCEINLINE {
-- 
cgit v1.2.3