Merge pull request #3610 from FernandoS27/gpu-caches

Refactor all the GPU Caches to use VAddr for cache addressing

3 files changed, 109 insertions, 90 deletions

diff --git a/src/video_core/buffer_cache/buffer_block.h b/src/video_core/buffer_cache/buffer_block.h
index 4b9193182..e35ee0b67 100644
--- a/src/video_core/buffer_cache/buffer_block.h
+++ b/src/video_core/buffer_cache/buffer_block.h
@@ -15,37 +15,29 @@ namespace VideoCommon {
 
 class BufferBlock {
 public:
-    bool Overlaps(const CacheAddr start, const CacheAddr end) const {
-        return (cache_addr < end) && (cache_addr_end > start);
+    bool Overlaps(const VAddr start, const VAddr end) const {
+        return (cpu_addr < end) && (cpu_addr_end > start);
     }
 
-    bool IsInside(const CacheAddr other_start, const CacheAddr other_end) const {
-        return cache_addr <= other_start && other_end <= cache_addr_end;
+    bool IsInside(const VAddr other_start, const VAddr other_end) const {
+        return cpu_addr <= other_start && other_end <= cpu_addr_end;
     }
 
-    u8* GetWritableHostPtr() const {
-        return FromCacheAddr(cache_addr);
+    std::size_t GetOffset(const VAddr in_addr) {
+        return static_cast<std::size_t>(in_addr - cpu_addr);
     }
 
-    u8* GetWritableHostPtr(std::size_t offset) const {
-        return FromCacheAddr(cache_addr + offset);
+    VAddr GetCpuAddr() const {
+        return cpu_addr;
     }
 
-    std::size_t GetOffset(const CacheAddr in_addr) {
-        return static_cast<std::size_t>(in_addr - cache_addr);
+    VAddr GetCpuAddrEnd() const {
+        return cpu_addr_end;
     }
 
-    CacheAddr GetCacheAddr() const {
-        return cache_addr;
-    }
-
-    CacheAddr GetCacheAddrEnd() const {
-        return cache_addr_end;
-    }
-
-    void SetCacheAddr(const CacheAddr new_addr) {
-        cache_addr = new_addr;
-        cache_addr_end = new_addr + size;
+    void SetCpuAddr(const VAddr new_addr) {
+        cpu_addr = new_addr;
+        cpu_addr_end = new_addr + size;
     }
 
     std::size_t GetSize() const {
@@ -61,14 +53,14 @@ public:
     }
 
 protected:
-    explicit BufferBlock(CacheAddr cache_addr, const std::size_t size) : size{size} {
-        SetCacheAddr(cache_addr);
+    explicit BufferBlock(VAddr cpu_addr, const std::size_t size) : size{size} {
+        SetCpuAddr(cpu_addr);
     }
     ~BufferBlock() = default;
 
 private:
-    CacheAddr cache_addr{};
-    CacheAddr cache_addr_end{};
+    VAddr cpu_addr{};
+    VAddr cpu_addr_end{};
     std::size_t size{};
     u64 epoch{};
 };
diff --git a/src/video_core/buffer_cache/buffer_cache.h b/src/video_core/buffer_cache/buffer_cache.h
index 186aca61d..b57c0d4d4 100644
--- a/src/video_core/buffer_cache/buffer_cache.h
+++ b/src/video_core/buffer_cache/buffer_cache.h
@@ -19,6 +19,7 @@
 #include "common/alignment.h"
 #include "common/common_types.h"
 #include "core/core.h"
+#include "core/memory.h"
 #include "video_core/buffer_cache/buffer_block.h"
 #include "video_core/buffer_cache/map_interval.h"
 #include "video_core/memory_manager.h"
@@ -37,28 +38,45 @@ public:
                             bool is_written = false, bool use_fast_cbuf = false) {
         std::lock_guard lock{mutex};
 
-        auto& memory_manager = system.GPU().MemoryManager();
-        const auto host_ptr = memory_manager.GetPointer(gpu_addr);
-        if (!host_ptr) {
+        const std::optional<VAddr> cpu_addr_opt =
+            system.GPU().MemoryManager().GpuToCpuAddress(gpu_addr);
+
+        if (!cpu_addr_opt) {
             return {GetEmptyBuffer(size), 0};
         }
-        const auto cache_addr = ToCacheAddr(host_ptr);
+
+        VAddr cpu_addr = *cpu_addr_opt;
 
         // Cache management is a big overhead, so only cache entries with a given size.
         // TODO: Figure out which size is the best for given games.
         constexpr std::size_t max_stream_size = 0x800;
         if (use_fast_cbuf || size < max_stream_size) {
-            if (!is_written && !IsRegionWritten(cache_addr, cache_addr + size - 1)) {
+            if (!is_written && !IsRegionWritten(cpu_addr, cpu_addr + size - 1)) {
+                auto& memory_manager = system.GPU().MemoryManager();
                 if (use_fast_cbuf) {
-                    return ConstBufferUpload(host_ptr, size);
+                    if (memory_manager.IsGranularRange(gpu_addr, size)) {
+                        const auto host_ptr = memory_manager.GetPointer(gpu_addr);
+                        return ConstBufferUpload(host_ptr, size);
+                    } else {
+                        staging_buffer.resize(size);
+                        memory_manager.ReadBlockUnsafe(gpu_addr, staging_buffer.data(), size);
+                        return ConstBufferUpload(staging_buffer.data(), size);
+                    }
                 } else {
-                    return StreamBufferUpload(host_ptr, size, alignment);
+                    if (memory_manager.IsGranularRange(gpu_addr, size)) {
+                        const auto host_ptr = memory_manager.GetPointer(gpu_addr);
+                        return StreamBufferUpload(host_ptr, size, alignment);
+                    } else {
+                        staging_buffer.resize(size);
+                        memory_manager.ReadBlockUnsafe(gpu_addr, staging_buffer.data(), size);
+                        return StreamBufferUpload(staging_buffer.data(), size, alignment);
+                    }
                 }
             }
         }
 
-        auto block = GetBlock(cache_addr, size);
-        auto map = MapAddress(block, gpu_addr, cache_addr, size);
+        auto block = GetBlock(cpu_addr, size);
+        auto map = MapAddress(block, gpu_addr, cpu_addr, size);
         if (is_written) {
             map->MarkAsModified(true, GetModifiedTicks());
             if (!map->IsWritten()) {
@@ -71,7 +89,7 @@ public:
             }
         }
 
-        const u64 offset = static_cast<u64>(block->GetOffset(cache_addr));
+        const u64 offset = static_cast<u64>(block->GetOffset(cpu_addr));
 
         return {ToHandle(block), offset};
     }
@@ -112,7 +130,7 @@ public:
     }
 
     /// Write any cached resources overlapping the specified region back to memory
-    void FlushRegion(CacheAddr addr, std::size_t size) {
+    void FlushRegion(VAddr addr, std::size_t size) {
         std::lock_guard lock{mutex};
 
         std::vector<MapInterval> objects = GetMapsInRange(addr, size);
@@ -127,7 +145,7 @@ public:
     }
 
     /// Mark the specified region as being invalidated
-    void InvalidateRegion(CacheAddr addr, u64 size) {
+    void InvalidateRegion(VAddr addr, u64 size) {
         std::lock_guard lock{mutex};
 
         std::vector<MapInterval> objects = GetMapsInRange(addr, size);
@@ -152,7 +170,7 @@ protected:
 
     virtual void WriteBarrier() = 0;
 
-    virtual TBuffer CreateBlock(CacheAddr cache_addr, std::size_t size) = 0;
+    virtual TBuffer CreateBlock(VAddr cpu_addr, std::size_t size) = 0;
 
     virtual void UploadBlockData(const TBuffer& buffer, std::size_t offset, std::size_t size,
                                  const u8* data) = 0;
@@ -169,20 +187,17 @@ protected:
 
     /// Register an object into the cache
     void Register(const MapInterval& new_map, bool inherit_written = false) {
-        const CacheAddr cache_ptr = new_map->GetStart();
-        const std::optional<VAddr> cpu_addr =
-            system.GPU().MemoryManager().GpuToCpuAddress(new_map->GetGpuAddress());
-        if (!cache_ptr || !cpu_addr) {
+        const VAddr cpu_addr = new_map->GetStart();
+        if (!cpu_addr) {
             LOG_CRITICAL(HW_GPU, "Failed to register buffer with unmapped gpu_address 0x{:016x}",
                          new_map->GetGpuAddress());
             return;
         }
         const std::size_t size = new_map->GetEnd() - new_map->GetStart();
-        new_map->SetCpuAddress(*cpu_addr);
         new_map->MarkAsRegistered(true);
         const IntervalType interval{new_map->GetStart(), new_map->GetEnd()};
         mapped_addresses.insert({interval, new_map});
-        rasterizer.UpdatePagesCachedCount(*cpu_addr, size, 1);
+        rasterizer.UpdatePagesCachedCount(cpu_addr, size, 1);
         if (inherit_written) {
             MarkRegionAsWritten(new_map->GetStart(), new_map->GetEnd() - 1);
             new_map->MarkAsWritten(true);
@@ -192,7 +207,7 @@ protected:
     /// Unregisters an object from the cache
     void Unregister(MapInterval& map) {
         const std::size_t size = map->GetEnd() - map->GetStart();
-        rasterizer.UpdatePagesCachedCount(map->GetCpuAddress(), size, -1);
+        rasterizer.UpdatePagesCachedCount(map->GetStart(), size, -1);
         map->MarkAsRegistered(false);
         if (map->IsWritten()) {
             UnmarkRegionAsWritten(map->GetStart(), map->GetEnd() - 1);
@@ -202,32 +217,39 @@ protected:
     }
 
 private:
-    MapInterval CreateMap(const CacheAddr start, const CacheAddr end, const GPUVAddr gpu_addr) {
+    MapInterval CreateMap(const VAddr start, const VAddr end, const GPUVAddr gpu_addr) {
         return std::make_shared<MapIntervalBase>(start, end, gpu_addr);
     }
 
-    MapInterval MapAddress(const TBuffer& block, const GPUVAddr gpu_addr,
-                           const CacheAddr cache_addr, const std::size_t size) {
+    MapInterval MapAddress(const TBuffer& block, const GPUVAddr gpu_addr, const VAddr cpu_addr,
+                           const std::size_t size) {
 
-        std::vector<MapInterval> overlaps = GetMapsInRange(cache_addr, size);
+        std::vector<MapInterval> overlaps = GetMapsInRange(cpu_addr, size);
         if (overlaps.empty()) {
-            const CacheAddr cache_addr_end = cache_addr + size;
-            MapInterval new_map = CreateMap(cache_addr, cache_addr_end, gpu_addr);
-            u8* host_ptr = FromCacheAddr(cache_addr);
-            UploadBlockData(block, block->GetOffset(cache_addr), size, host_ptr);
+            auto& memory_manager = system.GPU().MemoryManager();
+            const VAddr cpu_addr_end = cpu_addr + size;
+            MapInterval new_map = CreateMap(cpu_addr, cpu_addr_end, gpu_addr);
+            if (memory_manager.IsGranularRange(gpu_addr, size)) {
+                u8* host_ptr = memory_manager.GetPointer(gpu_addr);
+                UploadBlockData(block, block->GetOffset(cpu_addr), size, host_ptr);
+            } else {
+                staging_buffer.resize(size);
+                memory_manager.ReadBlockUnsafe(gpu_addr, staging_buffer.data(), size);
+                UploadBlockData(block, block->GetOffset(cpu_addr), size, staging_buffer.data());
+            }
             Register(new_map);
             return new_map;
         }
 
-        const CacheAddr cache_addr_end = cache_addr + size;
+        const VAddr cpu_addr_end = cpu_addr + size;
         if (overlaps.size() == 1) {
             MapInterval& current_map = overlaps[0];
-            if (current_map->IsInside(cache_addr, cache_addr_end)) {
+            if (current_map->IsInside(cpu_addr, cpu_addr_end)) {
                 return current_map;
             }
         }
-        CacheAddr new_start = cache_addr;
-        CacheAddr new_end = cache_addr_end;
+        VAddr new_start = cpu_addr;
+        VAddr new_end = cpu_addr_end;
         bool write_inheritance = false;
         bool modified_inheritance = false;
         // Calculate new buffer parameters
@@ -237,7 +259,7 @@ private:
             write_inheritance |= overlap->IsWritten();
             modified_inheritance |= overlap->IsModified();
         }
-        GPUVAddr new_gpu_addr = gpu_addr + new_start - cache_addr;
+        GPUVAddr new_gpu_addr = gpu_addr + new_start - cpu_addr;
         for (auto& overlap : overlaps) {
             Unregister(overlap);
         }
@@ -250,7 +272,7 @@ private:
         return new_map;
     }
 
-    void UpdateBlock(const TBuffer& block, CacheAddr start, CacheAddr end,
+    void UpdateBlock(const TBuffer& block, VAddr start, VAddr end,
                      std::vector<MapInterval>& overlaps) {
         const IntervalType base_interval{start, end};
         IntervalSet interval_set{};
@@ -262,13 +284,15 @@ private:
         for (auto& interval : interval_set) {
             std::size_t size = interval.upper() - interval.lower();
             if (size > 0) {
-                u8* host_ptr = FromCacheAddr(interval.lower());
-                UploadBlockData(block, block->GetOffset(interval.lower()), size, host_ptr);
+                staging_buffer.resize(size);
+                system.Memory().ReadBlockUnsafe(interval.lower(), staging_buffer.data(), size);
+                UploadBlockData(block, block->GetOffset(interval.lower()), size,
+                                staging_buffer.data());
             }
         }
     }
 
-    std::vector<MapInterval> GetMapsInRange(CacheAddr addr, std::size_t size) {
+    std::vector<MapInterval> GetMapsInRange(VAddr addr, std::size_t size) {
         if (size == 0) {
             return {};
         }
@@ -290,8 +314,9 @@ private:
     void FlushMap(MapInterval map) {
         std::size_t size = map->GetEnd() - map->GetStart();
         TBuffer block = blocks[map->GetStart() >> block_page_bits];
-        u8* host_ptr = FromCacheAddr(map->GetStart());
-        DownloadBlockData(block, block->GetOffset(map->GetStart()), size, host_ptr);
+        staging_buffer.resize(size);
+        DownloadBlockData(block, block->GetOffset(map->GetStart()), size, staging_buffer.data());
+        system.Memory().WriteBlockUnsafe(map->GetStart(), staging_buffer.data(), size);
         map->MarkAsModified(false, 0);
     }
 
@@ -316,14 +341,14 @@ private:
     TBuffer EnlargeBlock(TBuffer buffer) {
         const std::size_t old_size = buffer->GetSize();
         const std::size_t new_size = old_size + block_page_size;
-        const CacheAddr cache_addr = buffer->GetCacheAddr();
-        TBuffer new_buffer = CreateBlock(cache_addr, new_size);
+        const VAddr cpu_addr = buffer->GetCpuAddr();
+        TBuffer new_buffer = CreateBlock(cpu_addr, new_size);
         CopyBlock(buffer, new_buffer, 0, 0, old_size);
         buffer->SetEpoch(epoch);
         pending_destruction.push_back(buffer);
-        const CacheAddr cache_addr_end = cache_addr + new_size - 1;
-        u64 page_start = cache_addr >> block_page_bits;
-        const u64 page_end = cache_addr_end >> block_page_bits;
+        const VAddr cpu_addr_end = cpu_addr + new_size - 1;
+        u64 page_start = cpu_addr >> block_page_bits;
+        const u64 page_end = cpu_addr_end >> block_page_bits;
         while (page_start <= page_end) {
             blocks[page_start] = new_buffer;
             ++page_start;
@@ -334,9 +359,9 @@ private:
     TBuffer MergeBlocks(TBuffer first, TBuffer second) {
         const std::size_t size_1 = first->GetSize();
         const std::size_t size_2 = second->GetSize();
-        const CacheAddr first_addr = first->GetCacheAddr();
-        const CacheAddr second_addr = second->GetCacheAddr();
-        const CacheAddr new_addr = std::min(first_addr, second_addr);
+        const VAddr first_addr = first->GetCpuAddr();
+        const VAddr second_addr = second->GetCpuAddr();
+        const VAddr new_addr = std::min(first_addr, second_addr);
         const std::size_t new_size = size_1 + size_2;
         TBuffer new_buffer = CreateBlock(new_addr, new_size);
         CopyBlock(first, new_buffer, 0, new_buffer->GetOffset(first_addr), size_1);
@@ -345,9 +370,9 @@ private:
         second->SetEpoch(epoch);
         pending_destruction.push_back(first);
         pending_destruction.push_back(second);
-        const CacheAddr cache_addr_end = new_addr + new_size - 1;
+        const VAddr cpu_addr_end = new_addr + new_size - 1;
         u64 page_start = new_addr >> block_page_bits;
-        const u64 page_end = cache_addr_end >> block_page_bits;
+        const u64 page_end = cpu_addr_end >> block_page_bits;
         while (page_start <= page_end) {
             blocks[page_start] = new_buffer;
             ++page_start;
@@ -355,18 +380,18 @@ private:
         return new_buffer;
     }
 
-    TBuffer GetBlock(const CacheAddr cache_addr, const std::size_t size) {
+    TBuffer GetBlock(const VAddr cpu_addr, const std::size_t size) {
         TBuffer found{};
-        const CacheAddr cache_addr_end = cache_addr + size - 1;
-        u64 page_start = cache_addr >> block_page_bits;
-        const u64 page_end = cache_addr_end >> block_page_bits;
+        const VAddr cpu_addr_end = cpu_addr + size - 1;
+        u64 page_start = cpu_addr >> block_page_bits;
+        const u64 page_end = cpu_addr_end >> block_page_bits;
         while (page_start <= page_end) {
             auto it = blocks.find(page_start);
             if (it == blocks.end()) {
                 if (found) {
                     found = EnlargeBlock(found);
                 } else {
-                    const CacheAddr start_addr = (page_start << block_page_bits);
+                    const VAddr start_addr = (page_start << block_page_bits);
                     found = CreateBlock(start_addr, block_page_size);
                     blocks[page_start] = found;
                 }
@@ -386,7 +411,7 @@ private:
         return found;
     }
 
-    void MarkRegionAsWritten(const CacheAddr start, const CacheAddr end) {
+    void MarkRegionAsWritten(const VAddr start, const VAddr end) {
         u64 page_start = start >> write_page_bit;
         const u64 page_end = end >> write_page_bit;
         while (page_start <= page_end) {
@@ -400,7 +425,7 @@ private:
         }
     }
 
-    void UnmarkRegionAsWritten(const CacheAddr start, const CacheAddr end) {
+    void UnmarkRegionAsWritten(const VAddr start, const VAddr end) {
         u64 page_start = start >> write_page_bit;
         const u64 page_end = end >> write_page_bit;
         while (page_start <= page_end) {
@@ -416,7 +441,7 @@ private:
         }
     }
 
-    bool IsRegionWritten(const CacheAddr start, const CacheAddr end) const {
+    bool IsRegionWritten(const VAddr start, const VAddr end) const {
         u64 page_start = start >> write_page_bit;
         const u64 page_end = end >> write_page_bit;
         while (page_start <= page_end) {
@@ -440,8 +465,8 @@ private:
     u64 buffer_offset = 0;
     u64 buffer_offset_base = 0;
 
-    using IntervalSet = boost::icl::interval_set<CacheAddr>;
-    using IntervalCache = boost::icl::interval_map<CacheAddr, MapInterval>;
+    using IntervalSet = boost::icl::interval_set<VAddr>;
+    using IntervalCache = boost::icl::interval_map<VAddr, MapInterval>;
     using IntervalType = typename IntervalCache::interval_type;
     IntervalCache mapped_addresses;
 
@@ -456,6 +481,8 @@ private:
     u64 epoch = 0;
     u64 modified_ticks = 0;
 
+    std::vector<u8> staging_buffer;
+
     std::recursive_mutex mutex;
 };
 
diff --git a/src/video_core/buffer_cache/map_interval.h b/src/video_core/buffer_cache/map_interval.h
index 3a104d5cd..b0956029d 100644
--- a/src/video_core/buffer_cache/map_interval.h
+++ b/src/video_core/buffer_cache/map_interval.h
@@ -11,7 +11,7 @@ namespace VideoCommon {
 
 class MapIntervalBase {
 public:
-    MapIntervalBase(const CacheAddr start, const CacheAddr end, const GPUVAddr gpu_addr)
+    MapIntervalBase(const VAddr start, const VAddr end, const GPUVAddr gpu_addr)
         : start{start}, end{end}, gpu_addr{gpu_addr} {}
 
     void SetCpuAddress(VAddr new_cpu_addr) {
@@ -26,7 +26,7 @@ public:
         return gpu_addr;
     }
 
-    bool IsInside(const CacheAddr other_start, const CacheAddr other_end) const {
+    bool IsInside(const VAddr other_start, const VAddr other_end) const {
         return (start <= other_start && other_end <= end);
     }
 
@@ -46,11 +46,11 @@ public:
         return is_registered;
     }
 
-    CacheAddr GetStart() const {
+    VAddr GetStart() const {
         return start;
     }
 
-    CacheAddr GetEnd() const {
+    VAddr GetEnd() const {
         return end;
     }
 
@@ -76,8 +76,8 @@ public:
     }
 
 private:
-    CacheAddr start;
-    CacheAddr end;
+    VAddr start;
+    VAddr end;
     GPUVAddr gpu_addr;
     VAddr cpu_addr{};
     bool is_written{};