fix: vertex buffer leaks

SamoZ256 · SamoZ256 · commit c6ab45a098b8 · 2024-08-11T14:17:40.000+02:00
diff --git a/src/Cafe/HW/Latte/Renderer/Metal/MetalCommon.h b/src/Cafe/HW/Latte/Renderer/Metal/MetalCommon.h
@@ -1,5 +1,9 @@
 #pragma once
 
+#include <Metal/Metal.hpp>
+
+constexpr size_t INVALID_OFFSET = std::numeric_limits<size_t>::max();
+
 inline size_t Align(size_t size, size_t alignment)
 {
     return (size + alignment - 1) & ~(alignment - 1);
diff --git a/src/Cafe/HW/Latte/Renderer/Metal/MetalMemoryManager.cpp b/src/Cafe/HW/Latte/Renderer/Metal/MetalMemoryManager.cpp
@@ -70,11 +70,11 @@ MetalVertexBufferCache::~MetalVertexBufferCache()
     for (uint32 i = 0; i < LATTE_MAX_VERTEX_BUFFERS; i++)
     {
         auto vertexBufferRange = m_bufferRanges[i];
-        if (vertexBufferRange)
+        if (vertexBufferRange.offset != INVALID_OFFSET)
         {
-            if (vertexBufferRange->restrideInfo.buffer)
+            if (vertexBufferRange.restrideInfo->buffer)
             {
-                vertexBufferRange->restrideInfo.buffer->release();
+                vertexBufferRange.restrideInfo->buffer->release();
             }
         }
     }
@@ -83,29 +83,30 @@ MetalVertexBufferCache::~MetalVertexBufferCache()
 MetalRestridedBufferRange MetalVertexBufferCache::RestrideBufferIfNeeded(MTL::Buffer* bufferCache, uint32 bufferIndex, size_t stride)
 {
     auto vertexBufferRange = m_bufferRanges[bufferIndex];
-    auto& restrideInfo = vertexBufferRange->restrideInfo;
+    auto& restrideInfo = *vertexBufferRange.restrideInfo;
 
     if (stride % 4 == 0)
     {
         // No restride needed
-        return {bufferCache, vertexBufferRange->offset};
+        return {bufferCache, vertexBufferRange.offset};
     }
 
     if (restrideInfo.memoryInvalidated || stride != restrideInfo.lastStride)
     {
         // TODO: use compute/void vertex function instead
         size_t newStride = Align(stride, 4);
-        size_t newSize = vertexBufferRange->size / stride * newStride;
+        size_t newSize = vertexBufferRange.size / stride * newStride;
         restrideInfo.buffer = m_mtlr->GetDevice()->newBuffer(newSize, MTL::StorageModeShared);
 
-        uint8* oldPtr = (uint8*)bufferCache->contents() + vertexBufferRange->offset;
+        uint8* oldPtr = (uint8*)bufferCache->contents() + vertexBufferRange.offset;
         uint8* newPtr = (uint8*)restrideInfo.buffer->contents();
 
-        for (size_t elem = 0; elem < vertexBufferRange->size / stride; elem++)
+        for (size_t elem = 0; elem < vertexBufferRange.size / stride; elem++)
     	{
     		memcpy(newPtr + elem * newStride, oldPtr + elem * stride, stride);
     	}
-        debug_printf("Restrided vertex buffer (old stride: %zu, new stride: %zu, old size: %zu, new size: %zu)\n", stride, newStride, vertexBufferRange->size, newSize);
+        // TODO: remove
+        debug_printf("Restrided vertex buffer (old stride: %zu, new stride: %zu, old size: %zu, new size: %zu)\n", stride, newStride, vertexBufferRange.size, newSize);
 
         restrideInfo.memoryInvalidated = false;
         restrideInfo.lastStride = newStride;
@@ -119,15 +120,15 @@ void MetalVertexBufferCache::MemoryRangeChanged(size_t offset, size_t size)
     for (uint32 i = 0; i < LATTE_MAX_VERTEX_BUFFERS; i++)
     {
         auto vertexBufferRange = m_bufferRanges[i];
-        if (vertexBufferRange)
+        if (vertexBufferRange.offset != INVALID_OFFSET)
         {
-            if ((offset < vertexBufferRange->offset && (offset + size) < (vertexBufferRange->offset + vertexBufferRange->size)) ||
-                (offset > vertexBufferRange->offset && (offset + size) > (vertexBufferRange->offset + vertexBufferRange->size)))
+            if ((offset < vertexBufferRange.offset && (offset + size) < (vertexBufferRange.offset + vertexBufferRange.size)) ||
+                (offset > vertexBufferRange.offset && (offset + size) > (vertexBufferRange.offset + vertexBufferRange.size)))
             {
                 continue;
             }
 
-            vertexBufferRange->restrideInfo.memoryInvalidated = true;
+            vertexBufferRange.restrideInfo->memoryInvalidated = true;
         }
     }
 }
diff --git a/src/Cafe/HW/Latte/Renderer/Metal/MetalMemoryManager.h b/src/Cafe/HW/Latte/Renderer/Metal/MetalMemoryManager.h
@@ -1,9 +1,8 @@
 #pragma once
 
-#include <Metal/Metal.hpp>
-
 #include "Cafe/HW/Latte/ISA/LatteReg.h"
 #include "Cafe/HW/Latte/Core/LatteConst.h"
+#include "Cafe/HW/Latte/Renderer/Metal/MetalCommon.h"
 
 //const uint32 bufferAllocatorIndexShift = 24;
 
@@ -68,9 +67,9 @@ struct MetalRestrideInfo
 
 struct MetalVertexBufferRange
 {
-    size_t offset;
+    size_t offset = INVALID_OFFSET;
     size_t size;
-    MetalRestrideInfo& restrideInfo;
+    MetalRestrideInfo* restrideInfo;
 };
 
 class MetalVertexBufferCache
@@ -82,27 +81,27 @@ class MetalVertexBufferCache
     ~MetalVertexBufferCache();
 
     // Vertex buffer cache
-    void TrackVertexBuffer(uint32 bufferIndex, size_t offset, size_t size, MetalRestrideInfo& restrideInfo)
+    void TrackVertexBuffer(uint32 bufferIndex, size_t offset, size_t size, MetalRestrideInfo* restrideInfo)
     {
-        m_bufferRanges[bufferIndex] = new MetalVertexBufferRange{offset, size, restrideInfo};
+        m_bufferRanges[bufferIndex] = MetalVertexBufferRange{offset, size, restrideInfo};
     }
 
     void UntrackVertexBuffer(uint32 bufferIndex)
     {
         auto& range = m_bufferRanges[bufferIndex];
-        if (range->restrideInfo.buffer)
+        if (range.restrideInfo->buffer)
         {
-            range->restrideInfo.buffer->release();
+            range.restrideInfo->buffer->release();
         }
-        range = nullptr;
+        range.offset = INVALID_OFFSET;
     }
 
     MetalRestridedBufferRange RestrideBufferIfNeeded(MTL::Buffer* bufferCache, uint32 bufferIndex, size_t stride);
 
 private:
     class MetalRenderer* m_mtlr;
 
-    MetalVertexBufferRange* m_bufferRanges[LATTE_MAX_VERTEX_BUFFERS] = {nullptr};
+    MetalVertexBufferRange m_bufferRanges[LATTE_MAX_VERTEX_BUFFERS] = {};
 
     void MemoryRangeChanged(size_t offset, size_t size);
 };
@@ -147,7 +146,7 @@ class MetalMemoryManager
     void CopyBufferCache(size_t srcOffset, size_t dstOffset, size_t size);
 
     // Vertex buffer cache
-    void TrackVertexBuffer(uint32 bufferIndex, size_t offset, size_t size, MetalRestrideInfo& restrideInfo)
+    void TrackVertexBuffer(uint32 bufferIndex, size_t offset, size_t size, MetalRestrideInfo* restrideInfo)
     {
         m_vertexBufferCache.TrackVertexBuffer(bufferIndex, offset, size, restrideInfo);
     }
diff --git a/src/Cafe/HW/Latte/Renderer/Metal/MetalRenderer.cpp b/src/Cafe/HW/Latte/Renderer/Metal/MetalRenderer.cpp
@@ -77,6 +77,7 @@ void MetalRenderer::InitializeLayer(const Vector2i& size, bool mainWindow)
 
     m_metalLayer = (CA::MetalLayer*)CreateMetalLayer(windowInfo.handle);
     m_metalLayer->setDevice(m_device);
+    // TODO: don't always force sRGB
     // TODO: shouldn't this be handled differently?
     m_metalLayer->setPixelFormat(MTL::PixelFormatRGBA8Unorm_sRGB);
 
@@ -476,7 +477,7 @@ void MetalRenderer::buffer_bindVertexBuffer(uint32 bufferIndex, uint32 offset, u
 	buffer.size = size;
 	buffer.restrideInfo = {};
 
-	m_memoryManager->TrackVertexBuffer(bufferIndex, offset, size, buffer.restrideInfo);
+	m_memoryManager->TrackVertexBuffer(bufferIndex, offset, size, &buffer.restrideInfo);
 }
 
 void MetalRenderer::buffer_bindUniformBuffer(LatteConst::ShaderType shaderType, uint32 bufferIndex, uint32 offset, uint32 size)
diff --git a/src/Cafe/HW/Latte/Renderer/Metal/MetalRenderer.h b/src/Cafe/HW/Latte/Renderer/Metal/MetalRenderer.h
@@ -16,8 +16,6 @@
 #define MAX_MTL_TEXTURES 31
 #define MAX_MTL_SAMPLERS 16
 
-constexpr size_t INVALID_OFFSET = std::numeric_limits<size_t>::max();
-
 struct MetalBoundBuffer
 {
     bool needsRebind = false;

Original file line number	Diff line number	Diff line change
`@@ -1,5 +1,9 @@`
`1`	`1`	`#pragma once`
`2`	`2`
	`3`	`+#include <Metal/Metal.hpp>`
	`4`	`+`
	`5`	`+constexpr size_t INVALID_OFFSET = std::numeric_limits<size_t>::max();`
	`6`	`+`
`3`	`7`	`inline size_t Align(size_t size, size_t alignment)`
`4`	`8`	`{`
`5`	`9`	`return (size + alignment - 1) & ~(alignment - 1);`
Original file line number	Diff line number	Diff line change
`@@ -70,11 +70,11 @@ MetalVertexBufferCache::~MetalVertexBufferCache()`
`70`	`70`	`for (uint32 i = 0; i < LATTE_MAX_VERTEX_BUFFERS; i++)`
`71`	`71`	`{`
`72`	`72`	`auto vertexBufferRange = m_bufferRanges[i];`
`73`		`- if (vertexBufferRange)`
	`73`	`+ if (vertexBufferRange.offset != INVALID_OFFSET)`
`74`	`74`	`{`
`75`		`- if (vertexBufferRange->restrideInfo.buffer)`
	`75`	`+ if (vertexBufferRange.restrideInfo->buffer)`
`76`	`76`	`{`
`77`		`- vertexBufferRange->restrideInfo.buffer->release();`
	`77`	`+ vertexBufferRange.restrideInfo->buffer->release();`
`78`	`78`	`}`
`79`	`79`	`}`
`80`	`80`	`}`
`@@ -83,29 +83,30 @@ MetalVertexBufferCache::~MetalVertexBufferCache()`
`83`	`83`	`MetalRestridedBufferRange MetalVertexBufferCache::RestrideBufferIfNeeded(MTL::Buffer* bufferCache, uint32 bufferIndex, size_t stride)`
`84`	`84`	`{`
`85`	`85`	`auto vertexBufferRange = m_bufferRanges[bufferIndex];`
`86`		`- auto& restrideInfo = vertexBufferRange->restrideInfo;`
	`86`	`+ auto& restrideInfo = *vertexBufferRange.restrideInfo;`
`87`	`87`
`88`	`88`	`if (stride % 4 == 0)`
`89`	`89`	`{`
`90`	`90`	`// No restride needed`
`91`		`- return {bufferCache, vertexBufferRange->offset};`
	`91`	`+ return {bufferCache, vertexBufferRange.offset};`
`92`	`92`	`}`
`93`	`93`
`94`	`94`	`if (restrideInfo.memoryInvalidated \|\| stride != restrideInfo.lastStride)`
`95`	`95`	`{`
`96`	`96`	`// TODO: use compute/void vertex function instead`
`97`	`97`	`size_t newStride = Align(stride, 4);`
`98`		`- size_t newSize = vertexBufferRange->size / stride * newStride;`
	`98`	`+ size_t newSize = vertexBufferRange.size / stride * newStride;`
`99`	`99`	`restrideInfo.buffer = m_mtlr->GetDevice()->newBuffer(newSize, MTL::StorageModeShared);`
`100`	`100`
`101`		`- uint8* oldPtr = (uint8*)bufferCache->contents() + vertexBufferRange->offset;`
	`101`	`+ uint8* oldPtr = (uint8*)bufferCache->contents() + vertexBufferRange.offset;`
`102`	`102`	`uint8* newPtr = (uint8*)restrideInfo.buffer->contents();`
`103`	`103`
`104`		`- for (size_t elem = 0; elem < vertexBufferRange->size / stride; elem++)`
	`104`	`+ for (size_t elem = 0; elem < vertexBufferRange.size / stride; elem++)`
`105`	`105`	`{`
`106`	`106`	`memcpy(newPtr + elem * newStride, oldPtr + elem * stride, stride);`
`107`	`107`	`}`
`108`		`- debug_printf("Restrided vertex buffer (old stride: %zu, new stride: %zu, old size: %zu, new size: %zu)\n", stride, newStride, vertexBufferRange->size, newSize);`
	`108`	`+ // TODO: remove`
	`109`	`+ debug_printf("Restrided vertex buffer (old stride: %zu, new stride: %zu, old size: %zu, new size: %zu)\n", stride, newStride, vertexBufferRange.size, newSize);`
`109`	`110`
`110`	`111`	`restrideInfo.memoryInvalidated = false;`
`111`	`112`	`restrideInfo.lastStride = newStride;`
`@@ -119,15 +120,15 @@ void MetalVertexBufferCache::MemoryRangeChanged(size_t offset, size_t size)`
`119`	`120`	`for (uint32 i = 0; i < LATTE_MAX_VERTEX_BUFFERS; i++)`
`120`	`121`	`{`
`121`	`122`	`auto vertexBufferRange = m_bufferRanges[i];`
`122`		`- if (vertexBufferRange)`
	`123`	`+ if (vertexBufferRange.offset != INVALID_OFFSET)`
`123`	`124`	`{`
`124`		`- if ((offset < vertexBufferRange->offset && (offset + size) < (vertexBufferRange->offset + vertexBufferRange->size)) \|\|`
`125`		`- (offset > vertexBufferRange->offset && (offset + size) > (vertexBufferRange->offset + vertexBufferRange->size)))`
	`125`	`+ if ((offset < vertexBufferRange.offset && (offset + size) < (vertexBufferRange.offset + vertexBufferRange.size)) \|\|`
	`126`	`+ (offset > vertexBufferRange.offset && (offset + size) > (vertexBufferRange.offset + vertexBufferRange.size)))`
`126`	`127`	`{`
`127`	`128`	`continue;`
`128`	`129`	`}`
`129`	`130`
`130`		`- vertexBufferRange->restrideInfo.memoryInvalidated = true;`
	`131`	`+ vertexBufferRange.restrideInfo->memoryInvalidated = true;`
`131`	`132`	`}`
`132`	`133`	`}`
`133`	`134`	`}`
Original file line number	Diff line number	Diff line change
`@@ -16,8 +16,6 @@`
`16`	`16`	`#define MAX_MTL_TEXTURES 31`
`17`	`17`	`#define MAX_MTL_SAMPLERS 16`
`18`	`18`
`19`		`-constexpr size_t INVALID_OFFSET = std::numeric_limits<size_t>::max();`
`20`		`-`
`21`	`19`	`struct MetalBoundBuffer`
`22`	`20`	`{`
`23`	`21`	`bool needsRebind = false;`