VideoCore: implement channels on gpu caches.

1 files changed, 15 insertions, 13 deletions

diff --git a/src/video_core/fence_manager.h b/src/video_core/fence_manager.h
index 1e9832ddd..d658e038d 100644
--- a/src/video_core/fence_manager.h
+++ b/src/video_core/fence_manager.h
@@ -4,12 +4,13 @@
 #pragma once
 
 #include <algorithm>
+#include <cstring>
+#include <memory>
 #include <queue>
 
 #include "common/common_types.h"
 #include "video_core/delayed_destruction_ring.h"
 #include "video_core/gpu.h"
-#include "video_core/memory_manager.h"
 #include "video_core/rasterizer_interface.h"
 
 namespace VideoCommon {
@@ -19,10 +20,10 @@ public:
     explicit FenceBase(u32 payload_, bool is_stubbed_)
         : address{}, payload{payload_}, is_semaphore{false}, is_stubbed{is_stubbed_} {}
 
-    explicit FenceBase(GPUVAddr address_, u32 payload_, bool is_stubbed_)
+    explicit FenceBase(u8* address_, u32 payload_, bool is_stubbed_)
         : address{address_}, payload{payload_}, is_semaphore{true}, is_stubbed{is_stubbed_} {}
 
-    GPUVAddr GetAddress() const {
+    u8* GetAddress() const {
         return address;
     }
 
@@ -35,7 +36,7 @@ public:
     }
 
 private:
-    GPUVAddr address;
+    u8* address;
     u32 payload;
     bool is_semaphore;
 
@@ -57,7 +58,7 @@ public:
         buffer_cache.AccumulateFlushes();
     }
 
-    void SignalSemaphore(GPUVAddr addr, u32 value) {
+    void SignalSemaphore(u8* addr, u32 value) {
         TryReleasePendingFences();
         const bool should_flush = ShouldFlush();
         CommitAsyncFlushes();
@@ -91,8 +92,9 @@ public:
             }
             PopAsyncFlushes();
             if (current_fence->IsSemaphore()) {
-                gpu_memory.template Write<u32>(current_fence->GetAddress(),
-                                               current_fence->GetPayload());
+                char* address = reinterpret_cast<char*>(current_fence->GetAddress());
+                auto payload = current_fence->GetPayload();
+                std::memcpy(address, &payload, sizeof(payload));
             } else {
                 gpu.IncrementSyncPoint(current_fence->GetPayload());
             }
@@ -104,8 +106,8 @@ protected:
     explicit FenceManager(VideoCore::RasterizerInterface& rasterizer_, Tegra::GPU& gpu_,
                           TTextureCache& texture_cache_, TTBufferCache& buffer_cache_,
                           TQueryCache& query_cache_)
-        : rasterizer{rasterizer_}, gpu{gpu_}, gpu_memory{gpu.MemoryManager()},
-          texture_cache{texture_cache_}, buffer_cache{buffer_cache_}, query_cache{query_cache_} {}
+        : rasterizer{rasterizer_}, gpu{gpu_}, texture_cache{texture_cache_},
+          buffer_cache{buffer_cache_}, query_cache{query_cache_} {}
 
     virtual ~FenceManager() = default;
 
@@ -113,7 +115,7 @@ protected:
     /// true
     virtual TFence CreateFence(u32 value, bool is_stubbed) = 0;
     /// Creates a Semaphore Fence Interface, does not create a backend fence if 'is_stubbed' is true
-    virtual TFence CreateFence(GPUVAddr addr, u32 value, bool is_stubbed) = 0;
+    virtual TFence CreateFence(u8* addr, u32 value, bool is_stubbed) = 0;
     /// Queues a fence into the backend if the fence isn't stubbed.
     virtual void QueueFence(TFence& fence) = 0;
     /// Notifies that the backend fence has been signaled/reached in host GPU.
@@ -123,7 +125,6 @@ protected:
 
     VideoCore::RasterizerInterface& rasterizer;
     Tegra::GPU& gpu;
-    Tegra::MemoryManager& gpu_memory;
     TTextureCache& texture_cache;
     TTBufferCache& buffer_cache;
     TQueryCache& query_cache;
@@ -137,8 +138,9 @@ private:
             }
             PopAsyncFlushes();
             if (current_fence->IsSemaphore()) {
-                gpu_memory.template Write<u32>(current_fence->GetAddress(),
-                                               current_fence->GetPayload());
+                char* address = reinterpret_cast<char*>(current_fence->GetAddress());
+                const auto payload = current_fence->GetPayload();
+                std::memcpy(address, &payload, sizeof(payload));
             } else {
                 gpu.IncrementSyncPoint(current_fence->GetPayload());
             }