Free allocations in 2MB heaps

Related-To: NEO-5750
Signed-off-by: Maciej Dziuban <[email protected]>

Author: DziubanMaciejIntel

opencl/test/unit_test/memory_manager/gfx_partition_tests.inl

@@ -402,3 +402,51 @@ TEST(GfxPartitionTest, givenInternalHeapWhenAllocatingSmallOrBigChunkThenAddress
         gfxPartition.heapFree(heaps[i], address, sizeToAlloc);
     }
 }
+
+using GfxPartitionTestForAllHeapTypes = ::testing::TestWithParam<HeapIndex>;
+
+TEST_P(GfxPartitionTestForAllHeapTypes, givenHeapIndexWhenFreeGpuAddressRangeIsCalledThenFreeMemory) {
+    MockGfxPartition gfxPartition;
+    gfxPartition.init(maxNBitValue(48), reservedCpuAddressRangeSize, 0, 1);
+    const HeapIndex heapIndex = GetParam();
+    const size_t allocationSize = static_cast<size_t>(gfxPartition.getHeapSize(heapIndex)) * 3 / 4;
+    if (allocationSize == 0) {
+        GTEST_SKIP();
+    }
+    if (is32bit) {
+        auto it = std::find(GfxPartition::heap32Names.begin(), GfxPartition::heap32Names.end(), heapIndex);
+        auto is64bitHeap = it == GfxPartition::heap32Names.end();
+        if (is64bitHeap) {
+            GTEST_SKIP();
+        }
+    }
+    size_t sizeToAllocate{};
+
+    // Allocate majority of the heap
+    sizeToAllocate = allocationSize;
+    auto address = gfxPartition.heapAllocate(heapIndex, sizeToAllocate);
+    const size_t sizeAllocated = sizeToAllocate;
+    EXPECT_NE(0ull, address);
+    EXPECT_GE(sizeAllocated, allocationSize);
+
+    // Another one cannot be allocated
+    sizeToAllocate = allocationSize;
+    EXPECT_EQ(0ull, gfxPartition.heapAllocate(heapIndex, sizeToAllocate));
+
+    // Allocation is possible again after freeing
+    gfxPartition.freeGpuAddressRange(address, sizeAllocated);
+    sizeToAllocate = allocationSize;
+    EXPECT_NE(0ull, gfxPartition.heapAllocate(heapIndex, sizeToAllocate));
+}
+
+INSTANTIATE_TEST_SUITE_P(
+    GfxPartitionTestForAllHeapTypesTests,
+    GfxPartitionTestForAllHeapTypes,
+    ::testing::Values(HeapIndex::HEAP_INTERNAL_DEVICE_MEMORY,
+                      HeapIndex::HEAP_INTERNAL,
+                      HeapIndex::HEAP_EXTERNAL_DEVICE_MEMORY,
+                      HeapIndex::HEAP_EXTERNAL,
+                      HeapIndex::HEAP_STANDARD,
+                      HeapIndex::HEAP_STANDARD64KB,
+                      HeapIndex::HEAP_STANDARD2MB,
+                      HeapIndex::HEAP_EXTENDED));

opencl/test/unit_test/mocks/mock_gfx_partition.h

@@ -48,8 +48,6 @@ class MockGfxPartition : public GfxPartition {
         }
     }
 
-    MOCK_METHOD(void, freeGpuAddressRange, (uint64_t gpuAddress, size_t size), (override));
-
     static std::array<HeapIndex, static_cast<uint32_t>(HeapIndex::TOTAL_HEAPS)> allHeapNames;
 
     OSMemory::ReservedCpuAddressRange reservedCpuAddressRange;
@@ -58,6 +56,11 @@ class MockGfxPartition : public GfxPartition {
     const uint64_t mockGpuVa = std::numeric_limits<uint64_t>::max();
 };
 
+struct GmockGfxPartition : MockGfxPartition {
+    using MockGfxPartition::MockGfxPartition;
+    MOCK_METHOD(void, freeGpuAddressRange, (uint64_t gpuAddress, size_t size), (override));
+};
+
 class MockGfxPartitionBasic : public GfxPartition {
   public:
     MockGfxPartitionBasic() : GfxPartition(reservedCpuAddressRange) {}

opencl/test/unit_test/os_interface/linux/drm_memory_manager_tests.cpp

@@ -3899,7 +3899,7 @@ TEST_F(DrmMemoryManagerTest, givenSvmCpuAllocationWhenSizeAndAlignmentProvidedBu
 TEST_F(DrmMemoryManagerTest, givenDrmMemoryManagerAndReleaseGpuRangeIsCalledThenGpuAddressIsDecanonized) {
     constexpr size_t reservedCpuAddressRangeSize = is64bit ? (6 * 4 * GB) : 0;
     auto hwInfo = defaultHwInfo.get();
-    auto mockGfxPartition = std::make_unique<MockGfxPartition>();
+    auto mockGfxPartition = std::make_unique<GmockGfxPartition>();
     mockGfxPartition->init(hwInfo->capabilityTable.gpuAddressSpace, reservedCpuAddressRangeSize, 0, 1);
     auto size = 2 * MemoryConstants::megaByte;
     auto gpuAddress = mockGfxPartition->heapAllocate(HeapIndex::HEAP_STANDARD, size);

shared/source/memory_manager/gfx_partition.cpp

@@ -19,12 +19,13 @@ const std::array<HeapIndex, 4> GfxPartition::heap32Names{{HeapIndex::HEAP_INTERN
                                                           HeapIndex::HEAP_EXTERNAL_DEVICE_MEMORY,
                                                           HeapIndex::HEAP_EXTERNAL}};
 
-const std::array<HeapIndex, 7> GfxPartition::heapNonSvmNames{{HeapIndex::HEAP_INTERNAL_DEVICE_MEMORY,
+const std::array<HeapIndex, 8> GfxPartition::heapNonSvmNames{{HeapIndex::HEAP_INTERNAL_DEVICE_MEMORY,
                                                               HeapIndex::HEAP_INTERNAL,
                                                               HeapIndex::HEAP_EXTERNAL_DEVICE_MEMORY,
                                                               HeapIndex::HEAP_EXTERNAL,
                                                               HeapIndex::HEAP_STANDARD,
                                                               HeapIndex::HEAP_STANDARD64KB,
+                                                              HeapIndex::HEAP_STANDARD2MB,
                                                               HeapIndex::HEAP_EXTENDED}};
 
 GfxPartition::GfxPartition(OSMemory::ReservedCpuAddressRange &sharedReservedCpuAddressRange) : reservedCpuAddressRange(sharedReservedCpuAddressRange), osMemory(OSMemory::create()) {}

shared/source/memory_manager/gfx_partition.h

@@ -113,7 +113,7 @@ class GfxPartition {
     static constexpr size_t internalFrontWindowPoolSize = 1 * MemoryConstants::megaByte;
 
     static const std::array<HeapIndex, 4> heap32Names;
-    static const std::array<HeapIndex, 7> heapNonSvmNames;
+    static const std::array<HeapIndex, 8> heapNonSvmNames;
 
   protected:
     bool initAdditionalRange(uint32_t cpuAddressWidth, uint64_t gpuAddressSpace, uint64_t &gfxBase, uint64_t &gfxTop, uint32_t rootDeviceIndex, size_t numRootDevices);