video_core: Crucial buffer cache fixes + proper GPU clears (#414)

* translator: Use templates for stronger type guarantees

* spirv: Define buffer offsets upfront

* Saves a lot of shader instructions

* buffer_cache: Use dynamic vertex input when available

* Fixes issues when games like dark souls rebind vertex buffers with different stride

* externals: Update boost

* spirv: Use runtime array for ssbos

* ssbos can be large and typically their size will vary, especially in generic copy/clear cs shaders

* fs: Lock when doing case insensitive search

* Dark Souls does fs lookups from different threads

* texture_cache: More precise invalidation from compute

* Fixes unrelated render targets being cleared

* texture_cache: Use hashes for protect gpu modified images from reupload

* translator: Treat V_CNDMASK as float

* Sometimes it can have input modifiers. Worst this will cause is some extra calls to uintBitsToFloat and opposite. But most often this is used as float anyway

* translator: Small optimization for V_SAD_U32

* Fix review

* clang format

src/video_core/texture_cache/image.cpp

@@ -117,6 +117,7 @@ Image::Image(const Vulkan::Instance& instance_, Vulkan::Scheduler& scheduler_,
     : instance{&instance_}, scheduler{&scheduler_}, info{info_},
       image{instance->GetDevice(), instance->GetAllocator()}, cpu_addr{info.guest_address},
       cpu_addr_end{cpu_addr + info.guest_size_bytes} {
+    mip_hashes.resize(info.resources.levels);
     ASSERT(info.pixel_format != vk::Format::eUndefined);
     // Here we force `eExtendedUsage` as don't know all image usage cases beforehand. In normal case
     // the texture cache should re-create the resource with the usage requested

src/video_core/texture_cache/image.h

@@ -111,6 +111,7 @@ struct Image {
     vk::Flags<vk::PipelineStageFlagBits> pl_stage = vk::PipelineStageFlagBits::eAllCommands;
     vk::Flags<vk::AccessFlagBits> access_mask = vk::AccessFlagBits::eNone;
     vk::ImageLayout layout = vk::ImageLayout::eUndefined;
+    boost::container::small_vector<u64, 14> mip_hashes;
 };
 
 } // namespace VideoCore

src/video_core/texture_cache/texture_cache.cpp

@@ -3,6 +3,7 @@
 
 #include <xxhash.h>
 #include "common/assert.h"
+#include "video_core/buffer_cache/buffer_cache.h"
 #include "video_core/page_manager.h"
 #include "video_core/renderer_vulkan/vk_instance.h"
 #include "video_core/renderer_vulkan/vk_scheduler.h"
@@ -11,13 +12,11 @@
 
 namespace VideoCore {
 
-static constexpr u64 StreamBufferSize = 512_MB;
 static constexpr u64 PageShift = 12;
 
 TextureCache::TextureCache(const Vulkan::Instance& instance_, Vulkan::Scheduler& scheduler_,
                            BufferCache& buffer_cache_, PageManager& tracker_)
     : instance{instance_}, scheduler{scheduler_}, buffer_cache{buffer_cache_}, tracker{tracker_},
-      staging{instance, scheduler, MemoryUsage::Upload, StreamBufferSize},
       tile_manager{instance, scheduler} {
     ImageInfo info;
     info.pixel_format = vk::Format::eR8G8B8A8Unorm;
@@ -31,9 +30,12 @@ TextureCache::TextureCache(const Vulkan::Instance& instance_, Vulkan::Scheduler&
 
 TextureCache::~TextureCache() = default;
 
-void TextureCache::InvalidateMemory(VAddr address, size_t size) {
+void TextureCache::InvalidateMemory(VAddr address, size_t size, bool from_compute) {
     std::unique_lock lock{mutex};
     ForEachImageInRegion(address, size, [&](ImageId image_id, Image& image) {
+        if (from_compute && !image.Overlaps(address, size)) {
+            return;
+        }
         // Ensure image is reuploaded when accessed again.
         image.flags |= ImageFlagBits::CpuModified;
         // Untrack image, so the range is unprotected and the guest can write freely.
@@ -57,7 +59,7 @@ void TextureCache::UnmapMemory(VAddr cpu_addr, size_t size) {
     }
 }
 
-ImageId TextureCache::FindImage(const ImageInfo& info, bool refresh_on_create) {
+ImageId TextureCache::FindImage(const ImageInfo& info) {
     if (info.guest_address == 0) [[unlikely]] {
         return NULL_IMAGE_VIEW_ID;
     }
@@ -87,12 +89,6 @@ ImageId TextureCache::FindImage(const ImageInfo& info, bool refresh_on_create) {
         image_id = image_ids[image_ids.size() > 1 ? 1 : 0];
     }
 
-    Image& image = slot_images[image_id];
-    if (True(image.flags & ImageFlagBits::CpuModified) && refresh_on_create) {
-        RefreshImage(image);
-        TrackImage(image, image_id);
-    }
-
     return image_id;
 }
 
@@ -119,6 +115,7 @@ ImageView& TextureCache::RegisterImageView(ImageId image_id, const ImageViewInfo
 
 ImageView& TextureCache::FindTexture(const ImageInfo& info, const ImageViewInfo& view_info) {
     const ImageId image_id = FindImage(info);
+    UpdateImage(image_id);
     Image& image = slot_images[image_id];
     auto& usage = image.info.usage;
 
@@ -165,7 +162,8 @@ ImageView& TextureCache::FindRenderTarget(const ImageInfo& image_info,
                                           const ImageViewInfo& view_info) {
     const ImageId image_id = FindImage(image_info);
     Image& image = slot_images[image_id];
-    image.flags &= ~ImageFlagBits::CpuModified;
+    image.flags |= ImageFlagBits::GpuModified;
+    UpdateImage(image_id);
 
     image.Transit(vk::ImageLayout::eColorAttachmentOptimal,
                   vk::AccessFlagBits::eColorAttachmentWrite |
@@ -198,8 +196,9 @@ ImageView& TextureCache::FindRenderTarget(const ImageInfo& image_info,
 
 ImageView& TextureCache::FindDepthTarget(const ImageInfo& image_info,
                                          const ImageViewInfo& view_info) {
-    const ImageId image_id = FindImage(image_info, false);
+    const ImageId image_id = FindImage(image_info);
     Image& image = slot_images[image_id];
+    image.flags |= ImageFlagBits::GpuModified;
     image.flags &= ~ImageFlagBits::CpuModified;
 
     const auto new_layout = view_info.is_storage ? vk::ImageLayout::eDepthStencilAttachmentOptimal
@@ -228,22 +227,6 @@ void TextureCache::RefreshImage(Image& image) {
     // Mark image as validated.
     image.flags &= ~ImageFlagBits::CpuModified;
 
-    scheduler.EndRendering();
-
-    const auto cmdbuf = scheduler.CommandBuffer();
-    image.Transit(vk::ImageLayout::eTransferDstOptimal, vk::AccessFlagBits::eTransferWrite);
-
-    vk::Buffer buffer{staging.Handle()};
-    u32 offset{0};
-
-    auto upload_buffer = tile_manager.TryDetile(image);
-    if (upload_buffer) {
-        buffer = *upload_buffer;
-    } else {
-        // Upload data to the staging buffer.
-        offset = staging.Copy(image.info.guest_address, image.info.guest_size_bytes, 16);
-    }
-
     const auto& num_layers = image.info.resources.layers;
     const auto& num_mips = image.info.resources.levels;
     ASSERT(num_mips == image.info.mips_layout.size());
@@ -254,12 +237,23 @@ void TextureCache::RefreshImage(Image& image) {
         const u32 height = std::max(image.info.size.height >> m, 1u);
         const u32 depth =
             image.info.props.is_volume ? std::max(image.info.size.depth >> m, 1u) : 1u;
-        const auto& [_, mip_pitch, mip_height, mip_ofs] = image.info.mips_layout[m];
+        const auto& [mip_size, mip_pitch, mip_height, mip_ofs] = image.info.mips_layout[m];
+
+        // Protect GPU modified resources from accidental reuploads.
+        if (True(image.flags & ImageFlagBits::GpuModified) &&
+            !buffer_cache.IsRegionGpuModified(image.info.guest_address + mip_ofs, mip_size)) {
+            const u8* addr = std::bit_cast<u8*>(image.info.guest_address);
+            const u64 hash = XXH3_64bits(addr + mip_ofs, mip_size);
+            if (image.mip_hashes[m] == hash) {
+                continue;
+            }
+            image.mip_hashes[m] = hash;
+        }
 
         image_copy.push_back({
-            .bufferOffset = offset + mip_ofs * num_layers,
-            .bufferRowLength = static_cast<uint32_t>(mip_pitch),
-            .bufferImageHeight = static_cast<uint32_t>(mip_height),
+            .bufferOffset = mip_ofs * num_layers,
+            .bufferRowLength = static_cast<u32>(mip_pitch),
+            .bufferImageHeight = static_cast<u32>(mip_height),
             .imageSubresource{
                 .aspectMask = vk::ImageAspectFlagBits::eColor,
                 .mipLevel = m,
@@ -271,6 +265,30 @@ void TextureCache::RefreshImage(Image& image) {
         });
     }
 
+    if (image_copy.empty()) {
+        return;
+    }
+
+    scheduler.EndRendering();
+    const auto cmdbuf = scheduler.CommandBuffer();
+    image.Transit(vk::ImageLayout::eTransferDstOptimal, vk::AccessFlagBits::eTransferWrite, cmdbuf);
+
+    const VAddr image_addr = image.info.guest_address;
+    const size_t image_size = image.info.guest_size_bytes;
+    vk::Buffer buffer{};
+    u32 offset{};
+    if (auto upload_buffer = tile_manager.TryDetile(image); upload_buffer) {
+        buffer = *upload_buffer;
+    } else {
+        const auto [vk_buffer, buf_offset] = buffer_cache.ObtainTempBuffer(image_addr, image_size);
+        buffer = vk_buffer->Handle();
+        offset = buf_offset;
+    }
+
+    for (auto& copy : image_copy) {
+        copy.bufferOffset += offset;
+    }
+
     cmdbuf.copyBufferToImage(buffer, image.image, vk::ImageLayout::eTransferDstOptimal, image_copy);
 }
 

src/video_core/texture_cache/texture_cache.h

@@ -38,13 +38,13 @@ public:
     ~TextureCache();
 
     /// Invalidates any image in the logical page range.
-    void InvalidateMemory(VAddr address, size_t size);
+    void InvalidateMemory(VAddr address, size_t size, bool from_compute = false);
 
     /// Evicts any images that overlap the unmapped range.
     void UnmapMemory(VAddr cpu_addr, size_t size);
 
     /// Retrieves the image handle of the image with the provided attributes.
-    [[nodiscard]] ImageId FindImage(const ImageInfo& info, bool refresh_on_create = true);
+    [[nodiscard]] ImageId FindImage(const ImageInfo& info);
 
     /// Retrieves an image view with the properties of the specified image descriptor.
     [[nodiscard]] ImageView& FindTexture(const ImageInfo& image_info,
@@ -58,6 +58,16 @@ public:
     [[nodiscard]] ImageView& FindDepthTarget(const ImageInfo& image_info,
                                              const ImageViewInfo& view_info);
 
+    /// Updates image contents if it was modified by CPU.
+    void UpdateImage(ImageId image_id) {
+        Image& image = slot_images[image_id];
+        if (False(image.flags & ImageFlagBits::CpuModified)) {
+            return;
+        }
+        RefreshImage(image);
+        TrackImage(image, image_id);
+    }
+
     /// Reuploads image contents.
     void RefreshImage(Image& image);
 
@@ -170,7 +180,6 @@ private:
     Vulkan::Scheduler& scheduler;
     BufferCache& buffer_cache;
     PageManager& tracker;
-    StreamBuffer staging;
     TileManager tile_manager;
     Common::SlotVector<Image> slot_images;
     Common::SlotVector<ImageView> slot_image_views;

src/video_core/texture_cache/tile_manager.cpp

@@ -5,7 +5,6 @@
 #include "video_core/renderer_vulkan/vk_scheduler.h"
 #include "video_core/renderer_vulkan/vk_shader_util.h"
 #include "video_core/texture_cache/image_view.h"
-#include "video_core/texture_cache/texture_cache.h"
 #include "video_core/texture_cache/tile_manager.h"
 
 #include "video_core/host_shaders/detile_m32x1_comp.h"