Verify memory allocators cannot leak, ever.

src/gpgmm/MemoryAllocator.cpp

@@ -72,6 +72,16 @@ namespace gpgmm {
         AppendChild(std::move(child));
     }
 
+    MemoryAllocator::~MemoryAllocator() {
+        // If memory cannot be reused by a (parent) allocator, ensure no used memory leaked.
+        if (GetParent() == nullptr) {
+            ASSERT(mInfo.UsedBlockUsage == 0u);
+            ASSERT(mInfo.UsedBlockCount == 0u);
+            ASSERT(mInfo.UsedMemoryCount == 0u);
+            ASSERT(mInfo.UsedMemoryUsage == 0u);
+        }
+    }
+
     std::unique_ptr<MemoryAllocation> MemoryAllocator::TryAllocateMemory(uint64_t requestSize,
                                                                          uint64_t alignment,
                                                                          bool neverAllocate,

src/gpgmm/MemoryAllocator.h

@@ -83,7 +83,7 @@ namespace gpgmm {
         // Constructs a MemoryAllocator that owns a single child allocator.
         explicit MemoryAllocator(std::unique_ptr<MemoryAllocator> child);
 
-        virtual ~MemoryAllocator() override = default;
+        virtual ~MemoryAllocator() override;
 
         // Attempts to allocate memory and return an allocation that has at-least
         // |requestedSize| allocated space whose value is a multiple of |alignment|. If it cannot,

src/gpgmm/PooledMemoryAllocator.cpp

@@ -64,7 +64,10 @@ namespace gpgmm {
         mInfo.UsedMemoryCount--;
         mInfo.UsedMemoryUsage -= allocationSize;
 
-        mPool->ReturnToPool(std::move(allocation));
+        MemoryBase* memory = allocation->GetMemory();
+        ASSERT(memory != nullptr);
+
+        mPool->ReturnToPool(std::make_unique<MemoryAllocation>(GetFirstChild(), memory));
     }
 
     uint64_t PooledMemoryAllocator::GetMemorySize() const {

src/gpgmm/StandaloneMemoryAllocator.cpp

@@ -45,15 +45,17 @@ namespace gpgmm {
                                                   new MemoryBlock{0, requestSize});
     }
 
-    void StandaloneMemoryAllocator::DeallocateMemory(
-        std::unique_ptr<MemoryAllocation> subAllocation) {
+    void StandaloneMemoryAllocator::DeallocateMemory(std::unique_ptr<MemoryAllocation> allocation) {
         TRACE_EVENT0(TraceEventCategory::Default, "StandaloneMemoryAllocator.DeallocateMemory");
 
         std::lock_guard<std::mutex> lock(mMutex);
+
+        MemoryBlock* block = allocation->GetBlock();
         mInfo.UsedBlockCount--;
-        mInfo.UsedBlockUsage -= subAllocation->GetSize();
-        SafeDelete(subAllocation->GetBlock());
-        GetFirstChild()->DeallocateMemory(std::move(subAllocation));
+        mInfo.UsedBlockUsage -= block->Size;
+
+        SafeDelete(block);
+        GetFirstChild()->DeallocateMemory(std::move(allocation));
     }
 
     MEMORY_ALLOCATOR_INFO StandaloneMemoryAllocator::GetInfo() const {

src/gpgmm/d3d12/ResourceAllocatorD3D12.cpp

@@ -846,6 +846,8 @@ namespace gpgmm { namespace d3d12 {
 
     HRESULT ResourceAllocator::CreateResource(ComPtr<ID3D12Resource> resource,
                                               ResourceAllocation** resourceAllocationOut) {
+        std::lock_guard<std::mutex> lock(mMutex);
+
         if (!resourceAllocationOut) {
             return E_POINTER;
         }
@@ -865,6 +867,10 @@ namespace gpgmm { namespace d3d12 {
             resource, GetPreferredMemorySegmentGroup(mDevice.Get(), mIsUMA, heapProperties.Type),
             resourceInfo.SizeInBytes);
 
+        mInfo.UsedMemoryUsage += resourceInfo.SizeInBytes;
+        mInfo.UsedMemoryCount++;
+        mInfo.UsedBlockUsage += resourceInfo.SizeInBytes;
+
         *resourceAllocationOut = new ResourceAllocation{/*residencyManager*/ nullptr,
                                                         /*allocator*/ this,
                                                         /*offsetFromHeap*/ kInvalidOffset,

src/tests/unittests/SlabMemoryAllocatorTests.cpp

@@ -74,6 +74,8 @@ TEST(SlabMemoryAllocatorTests, SingleSlab) {
         EXPECT_EQ(allocation->GetOffset(), 0u);
         EXPECT_EQ(allocation->GetMethod(), AllocationMethod::kSubAllocated);
         EXPECT_GE(allocation->GetSize(), kBlockSize);
+
+        allocator.DeallocateMemory(std::move(allocation));
     }
 
     // Verify allocation cannot exceed the fragmentation threshold.
@@ -97,6 +99,8 @@ TEST(SlabMemoryAllocatorTests, SingleSlab) {
         EXPECT_EQ(allocation->GetOffset(), 0u);
         EXPECT_EQ(allocation->GetMethod(), AllocationMethod::kSubAllocated);
         EXPECT_GE(allocation->GetSize(), kBlockSize);
+
+        allocator.DeallocateMemory(std::move(allocation));
     }
 
     // Verify allocation succeeds when specifying a slab size.
@@ -113,6 +117,8 @@ TEST(SlabMemoryAllocatorTests, SingleSlab) {
         ASSERT_NE(allocation, nullptr);
         EXPECT_GE(allocation->GetSize(), kBlockSize);
         EXPECT_GE(allocation->GetMemory()->GetSize(), kSlabSize);
+
+        allocator.DeallocateMemory(std::move(allocation));
     }
 
     // Verify allocation succeeds when specifying a NPOT slab size.
@@ -129,6 +135,8 @@ TEST(SlabMemoryAllocatorTests, SingleSlab) {
         ASSERT_NE(allocation, nullptr);
         EXPECT_GE(allocation->GetSize(), kBlockSize);
         EXPECT_GE(allocation->GetMemory()->GetSize(), kSlabSize);
+
+        allocator.DeallocateMemory(std::move(allocation));
     }
 
     // Verify requesting an allocation without memory will not return a valid allocation.