shader_cache: batch memory-write invalidations without skipping ranges

Adapt the batching from ymatrix1/Eglantine PR #237, retaining all CPU invalidations. Acquire the lock once and remove pending shaders once per write batch. Compare real cache contents with sequential invalidation across randomized overlapping writes and pending removals.

Assisted-by: Codex (implementation, review, commit text and automated validation)
(cherry picked from commit b65f818d7789ffadfb58fe4543b18060fd88ce53)

5 files changed, 139 insertions, 5 deletions

diff --git a/src/tests/CMakeLists.txt b/src/tests/CMakeLists.txt
index 49fc646dea..be5528ef46 100644
--- a/src/tests/CMakeLists.txt
+++ b/src/tests/CMakeLists.txt
@@ -23,6 +23,7 @@ add_executable(tests
     video_core/vertex_repack.cpp
     video_core/ampere_returns.cpp
     video_core/native_macro_fifo.cpp
+    video_core/shader_invalidation.cpp
     input_common/calibration_configuration_job.cpp
 )
 
diff --git a/src/tests/video_core/shader_invalidation.cpp b/src/tests/video_core/shader_invalidation.cpp
new file mode 100644
index 0000000000..806fb5c58d
--- /dev/null
+++ b/src/tests/video_core/shader_invalidation.cpp
@@ -0,0 +1,120 @@
+// SPDX-License-Identifier: GPL-3.0-or-later
+
+#include <array>
+#include <chrono>
+#include <iostream>
+#include <memory>
+#include <random>
+#include <vector>
+#include <catch2/catch_test_macros.hpp>
+#include "core/device_memory.h"
+#include "video_core/shader_cache.h"
+
+namespace VideoCommon {
+struct ShaderCacheTestAccess {
+    static std::unique_ptr<ShaderCache> Create(Tegra::MaxwellDeviceMemoryManager& memory) {
+        return std::unique_ptr<ShaderCache>{new ShaderCache{memory}};
+    }
+    static void Register(ShaderCache& cache, VAddr address, size_t size, u64 hash) {
+        auto data = std::make_unique<ShaderInfo>();
+        data->unique_hash = hash;
+        cache.Register(std::move(data), address, size);
+    }
+    static const ShaderInfo* Find(const ShaderCache& cache, VAddr address) {
+        return cache.TryGet(address);
+    }
+};
+} // namespace VideoCommon
+
+using VideoCommon::ShaderCacheTestAccess;
+
+TEST_CASE("Shader batch invalidation matches sequential cache contents", "[shader_invalidation]") {
+    Core::DeviceMemory memory;
+    Tegra::MaxwellDeviceMemoryManager device_memory{memory};
+    auto batched = ShaderCacheTestAccess::Create(device_memory);
+    auto sequential = ShaderCacheTestAccess::Create(device_memory);
+    std::mt19937 random{0x16'67};
+    constexpr VAddr base = 0x100000;
+    for (unsigned iteration = 0; iteration < 600; ++iteration) {
+        for (unsigned slot = 0; slot < 128; ++slot) {
+            const auto address = base + slot * 4096;
+            if (!ShaderCacheTestAccess::Find(*batched, address)) {
+                const auto size = 1 + random() % 65536;
+                ShaderCacheTestAccess::Register(*batched, address, size, iteration + slot);
+                ShaderCacheTestAccess::Register(*sequential, address, size, iteration + slot);
+            }
+        }
+        std::vector<std::pair<DAddr, size_t>> writes;
+        for (unsigned i = 0, count = random() % 24; i < count; ++i) {
+            writes.emplace_back(base + random() % (128 * 4096), random() % 32768);
+            if (i % 4 == 0) {
+                writes.push_back(writes.back());
+            }
+        }
+        for (const auto& [address, size] : writes) {
+            sequential->InvalidateRegion(address, size);
+        }
+        batched->InvalidateRegions(writes);
+        for (unsigned slot = 0; slot < 128; ++slot) {
+            const auto address = base + slot * 4096;
+            const auto actual = ShaderCacheTestAccess::Find(*batched, address);
+            const auto expected = ShaderCacheTestAccess::Find(*sequential, address);
+            REQUIRE(bool(actual) == bool(expected));
+            if (actual) {
+                REQUIRE(actual->unique_hash == expected->unique_hash);
+            }
+        }
+    }
+}
+
+TEST_CASE("Shader empty batches preserve pending invalidations", "[shader_invalidation]") {
+    Core::DeviceMemory memory;
+    Tegra::MaxwellDeviceMemoryManager device_memory{memory};
+    auto cache = ShaderCacheTestAccess::Create(device_memory);
+    constexpr VAddr address = 0x100000;
+    ShaderCacheTestAccess::Register(*cache, address, 32768, 123);
+    cache->OnCacheInvalidation(address, 1);
+    cache->InvalidateRegions({});
+    REQUIRE(ShaderCacheTestAccess::Find(*cache, address));
+    const std::array unrelated{std::pair<DAddr, size_t>{address + 0x100000, 4096}};
+    cache->InvalidateRegions(unrelated);
+    REQUIRE_FALSE(ShaderCacheTestAccess::Find(*cache, address));
+}
+
+TEST_CASE("Shader invalidation CPU benchmark", "[.][cache_bench]") {
+    Core::DeviceMemory memory;
+    Tegra::MaxwellDeviceMemoryManager device_memory{memory};
+    auto batched = ShaderCacheTestAccess::Create(device_memory);
+    auto sequential = ShaderCacheTestAccess::Create(device_memory);
+    std::vector<std::pair<DAddr, size_t>> writes;
+    constexpr VAddr base = 0x100000;
+    for (unsigned slot = 0; slot < 768; ++slot) {
+        writes.emplace_back(base + slot * 65536, 1);
+    }
+    double sequential_ms{}, batched_ms{};
+    for (unsigned repeat = 0; repeat < 20; ++repeat) {
+        for (unsigned slot = 0; slot < 1024; ++slot) {
+            const auto address = base + slot * 65536;
+            if (!ShaderCacheTestAccess::Find(*batched, address)) {
+                ShaderCacheTestAccess::Register(*batched, address, 64, slot);
+                ShaderCacheTestAccess::Register(*sequential, address, 64, slot);
+            }
+        }
+        auto start = std::chrono::steady_clock::now();
+        for (const auto& [address, size] : writes) {
+            sequential->InvalidateRegion(address, size);
+        }
+        sequential_ms +=
+            std::chrono::duration<double, std::milli>(std::chrono::steady_clock::now() - start)
+                .count();
+        start = std::chrono::steady_clock::now();
+        batched->InvalidateRegions(writes);
+        batched_ms +=
+            std::chrono::duration<double, std::milli>(std::chrono::steady_clock::now() - start)
+                .count();
+        REQUIRE_FALSE(ShaderCacheTestAccess::Find(*batched, base));
+        REQUIRE(ShaderCacheTestAccess::Find(*batched, base + 1023 * 65536));
+    }
+    std::cout << "Shader invalidation: sequential=" << sequential_ms << " ms batched=" << batched_ms
+              << " ms (CPU only, not gameplay FPS)\n";
+}
diff --git a/src/video_core/renderer_vulkan/vk_rasterizer.cpp b/src/video_core/renderer_vulkan/vk_rasterizer.cpp
index 978f8be547..dc34260de5 100644
--- a/src/video_core/renderer_vulkan/vk_rasterizer.cpp
+++ b/src/video_core/renderer_vulkan/vk_rasterizer.cpp
@@ -1127,12 +1127,10 @@ void RasterizerVulkan::InnerInvalidation(std::span<const std::pair<DAddr, std::s
             buffer_cache.WriteMemory(addr, size);
         }
     }
-    {
-        for (const auto& [addr, size] : sequences) {
-            query_cache.InvalidateRegion(addr, size);
-            pipeline_cache.InvalidateRegion(addr, size);
-        }
+    for (const auto& [addr, size] : sequences) {
+        query_cache.InvalidateRegion(addr, size);
     }
+    pipeline_cache.InvalidateRegions(sequences);
 }
 
 bool RasterizerVulkan::OnCPUWrite(DAddr addr, u64 size) {
diff --git a/src/video_core/shader_cache.cpp b/src/video_core/shader_cache.cpp
index 5faed0dba9..cafebaa56f 100644
--- a/src/video_core/shader_cache.cpp
+++ b/src/video_core/shader_cache.cpp
@@ -36,6 +36,17 @@ void ShaderCache::InvalidateRegion(VAddr addr, size_t size) {
     RemovePendingShaders();
 }
 
+void ShaderCache::InvalidateRegions(std::span<const std::pair<DAddr, size_t>> sequences) {
+    if (sequences.empty()) {
+        return;
+    }
+    std::scoped_lock lock{invalidation_mutex};
+    for (const auto& [addr, size] : sequences) {
+        InvalidatePagesInRegion(addr, size);
+    }
+    RemovePendingShaders();
+}
+
 void ShaderCache::OnCacheInvalidation(VAddr addr, size_t size) {
     std::scoped_lock lock{invalidation_mutex};
     InvalidatePagesInRegion(addr, size);
diff --git a/src/video_core/shader_cache.h b/src/video_core/shader_cache.h
index 281a90cb6f..7c370e217c 100644
--- a/src/video_core/shader_cache.h
+++ b/src/video_core/shader_cache.h
@@ -67,6 +67,8 @@ public:
     /// @param size Number of bytes of the invalidation
     void InvalidateRegion(VAddr addr, size_t size);
 
+    void InvalidateRegions(std::span<const std::pair<DAddr, size_t>> sequences);
+
     /// @brief Unmarks a memory region as cached and marks it for removal
     /// @param addr Start address of the CPU write operation
     /// @param size Number of bytes of the CPU write operation
@@ -104,6 +106,8 @@ protected:
     bool last_shaders_valid = false;
 
 private:
+    friend struct ShaderCacheTestAccess;
+
     /// @brief Tries to obtain a cached shader starting in a given address
     /// @note Doesn't check for ranges, the given address has to be the start of the shader
     /// @param addr Start address of the shader, this doesn't cache for region