Deglobalize Memory Manager on texture cahe and Implement Invalidation and Flushing using GPUVAddr

src/video_core/gpu.cpp

@@ -32,6 +32,7 @@ u32 FramebufferConfig::BytesPerPixel(PixelFormat format) {
 GPU::GPU(Core::System& system, VideoCore::RendererBase& renderer) : renderer{renderer} {
     auto& rasterizer{renderer.Rasterizer()};
     memory_manager = std::make_unique<Tegra::MemoryManager>(rasterizer);
+    rasterizer.InitMemoryMananger(*memory_manager);
     dma_pusher = std::make_unique<Tegra::DmaPusher>(*this);
     maxwell_3d = std::make_unique<Engines::Maxwell3D>(system, rasterizer, *memory_manager);
     fermi_2d = std::make_unique<Engines::Fermi2D>(rasterizer, *memory_manager);

src/video_core/memory_manager.cpp

@@ -69,7 +69,7 @@ GPUVAddr MemoryManager::UnmapBuffer(GPUVAddr gpu_addr, u64 size) {
     const u64 aligned_size{Common::AlignUp(size, page_size)};
     const CacheAddr cache_addr{ToCacheAddr(GetPointer(gpu_addr))};
 
-    rasterizer.FlushAndInvalidateRegion(cache_addr, aligned_size);
+    rasterizer.FlushAndInvalidateRegionEx(gpu_addr, cache_addr, aligned_size);
     UnmapRange(gpu_addr, aligned_size);
 
     return gpu_addr;

src/video_core/rasterizer_interface.h

@@ -10,6 +10,10 @@
 #include "video_core/engines/fermi_2d.h"
 #include "video_core/gpu.h"
 
+namespace Tegra {
+class MemoryManager;
+}
+
 namespace VideoCore {
 
 enum class LoadCallbackStage {
@@ -24,6 +28,8 @@ class RasterizerInterface {
 public:
     virtual ~RasterizerInterface() {}
 
+    virtual void InitMemoryMananger(Tegra::MemoryManager& memory_manager) = 0;
+
     /// Draw the current batch of vertex arrays
     virtual void DrawArrays() = 0;
 
@@ -43,6 +49,10 @@ public:
     /// and invalidated
     virtual void FlushAndInvalidateRegion(CacheAddr addr, u64 size) = 0;
 
+    /// Notify rasterizer that any caches of the specified region should be flushed to Switch memory
+    /// and invalidated
+    virtual void FlushAndInvalidateRegionEx(GPUVAddr gpu_addr, CacheAddr addr, u64 size) = 0;
+
     /// Attempt to use a faster method to perform a surface copy
     virtual bool AccelerateSurfaceCopy(const Tegra::Engines::Fermi2D::Regs::Surface& src,
                                        const Tegra::Engines::Fermi2D::Regs::Surface& dst,

src/video_core/renderer_opengl/gl_rasterizer.h

@@ -41,6 +41,10 @@ namespace Core::Frontend {
 class EmuWindow;
 }
 
+namespace Tegra {
+class MemoryManager;
+}
+
 namespace OpenGL {
 
 struct ScreenInfo;
@@ -53,12 +57,16 @@ public:
                               ScreenInfo& info);
     ~RasterizerOpenGL() override;
 
+    void InitMemoryMananger(Tegra::MemoryManager& memory_manager) override;
+
     void DrawArrays() override;
     void Clear() override;
     void FlushAll() override;
     void FlushRegion(CacheAddr addr, u64 size) override;
     void InvalidateRegion(CacheAddr addr, u64 size) override;
+    void InvalidateRegionEx(GPUVAddr gpu_addr, CacheAddr addr, u64 size);
     void FlushAndInvalidateRegion(CacheAddr addr, u64 size) override;
+    void FlushAndInvalidateRegionEx(GPUVAddr gpu_addr, CacheAddr addr, u64 size) override;
     bool AccelerateSurfaceCopy(const Tegra::Engines::Fermi2D::Regs::Surface& src,
                                const Tegra::Engines::Fermi2D::Regs::Surface& dst,
                                const Common::Rectangle<u32>& src_rect,