Rename preferredGpuAddress -> reservedGpuVirtualAddress

Use reservedSizeForGpuVirtualAddress for freeGpuVirtualAddress call

Related-To: NEO-2881

Change-Id: Ieafa6ad33f3f9922cbfa414c7f40b4f3a28e7fc5
Signed-off-by: Mateusz Jablonski <[email protected]>

Author: JablonskiMateusz

runtime/os_interface/windows/wddm_allocation.h

@@ -75,7 +75,8 @@ class WddmAllocation : public GraphicsAllocation {
     // OS assigned fields
     D3DKMT_HANDLE resourceHandle = 0u; // used by shared resources
     bool needsMakeResidentBeforeLock = false;
-    D3DGPU_VIRTUAL_ADDRESS preferredGpuAddress = 0u;
+    D3DGPU_VIRTUAL_ADDRESS reservedGpuVirtualAddress = 0u;
+    uint64_t reservedSizeForGpuVirtualAddress = 0u;
 
   protected:
     std::string getHandleInfoString() const {

runtime/os_interface/windows/wddm_memory_manager.cpp

@@ -344,8 +344,8 @@ void WddmMemoryManager::freeGraphicsMemoryImpl(GraphicsAllocation *gfxAllocation
     if (input->getReservedAddressPtr()) {
         releaseReservedCpuAddressRange(input->getReservedAddressPtr(), input->getReservedAddressSize());
     }
-    if (input->preferredGpuAddress) {
-        wddm->freeGpuVirtualAddress(input->preferredGpuAddress, input->getAlignedSize());
+    if (input->reservedGpuVirtualAddress) {
+        wddm->freeGpuVirtualAddress(input->reservedGpuVirtualAddress, input->reservedSizeForGpuVirtualAddress);
     }
     delete gfxAllocation;
 }
@@ -506,8 +506,8 @@ bool WddmMemoryManager::createWddmAllocation(WddmAllocation *allocation, void *r
     obtainGpuAddressIfNeeded(allocation);
     bool mapSuccess = mapGpuVirtualAddressWithRetry(allocation, requiredGpuPtr);
     if (!mapSuccess) {
-        if (allocation->preferredGpuAddress) {
-            wddm->freeGpuVirtualAddress(allocation->preferredGpuAddress, allocation->getAlignedSize());
+        if (allocation->reservedGpuVirtualAddress) {
+            wddm->freeGpuVirtualAddress(allocation->reservedGpuVirtualAddress, allocation->reservedSizeForGpuVirtualAddress);
         }
         wddm->destroyAllocations(allocation->getHandles().data(), allocation->getNumHandles(), allocation->resourceHandle);
         return false;
@@ -546,8 +546,8 @@ uint32_t WddmMemoryManager::mapGpuVirtualAddress(WddmAllocation *graphicsAllocat
     if (!executionEnvironment.isFullRangeSvm()) {
         addressToMap = 0u;
     }
-    if (graphicsAllocation->preferredGpuAddress) {
-        addressToMap = graphicsAllocation->preferredGpuAddress;
+    if (graphicsAllocation->reservedGpuVirtualAddress) {
+        addressToMap = graphicsAllocation->reservedGpuVirtualAddress;
     }
     for (auto handleId = startingIndex; handleId < graphicsAllocation->getNumHandles(); handleId++) {
 
@@ -564,8 +564,10 @@ uint32_t WddmMemoryManager::mapGpuVirtualAddress(WddmAllocation *graphicsAllocat
 void WddmMemoryManager::obtainGpuAddressIfNeeded(WddmAllocation *allocation) {
     if (allocation->getNumHandles() > 1u) {
         auto heapIndex = selectHeap(allocation, false, executionEnvironment.isFullRangeSvm());
-        allocation->preferredGpuAddress = wddm->reserveGpuVirtualAddress(gfxPartition.getHeapMinimalAddress(heapIndex),
-                                                                         gfxPartition.getHeapLimit(heapIndex), allocation->getAlignedSize());
+        allocation->reservedSizeForGpuVirtualAddress = allocation->getAlignedSize();
+        allocation->reservedGpuVirtualAddress = wddm->reserveGpuVirtualAddress(gfxPartition.getHeapMinimalAddress(heapIndex),
+                                                                               gfxPartition.getHeapLimit(heapIndex),
+                                                                               allocation->reservedSizeForGpuVirtualAddress);
     }
 }
 

unit_tests/mocks/mock_wddm.cpp

@@ -59,6 +59,7 @@ bool WddmMock::mapGpuVirtualAddress(Gmm *gmm, D3DKMT_HANDLE handle, D3DGPU_VIRTU
 bool WddmMock::freeGpuVirtualAddress(D3DGPU_VIRTUAL_ADDRESS &gpuPtr, uint64_t size) {
     freeGpuVirtualAddressResult.called++;
     freeGpuVirtualAddressResult.uint64ParamPassed = gpuPtr;
+    freeGpuVirtualAddressResult.sizePassed = size;
     return freeGpuVirtualAddressResult.success = Wddm::freeGpuVirtualAddress(gpuPtr, size);
 }
 NTSTATUS WddmMock::createAllocation(WddmAllocation *wddmAllocation) {

unit_tests/mocks/mock_wddm.h

@@ -41,6 +41,9 @@ struct KmDafLockCall : CallResult {
 struct WaitFromCpuResult : CallResult {
     const MonitoredFence *monitoredFence = nullptr;
 };
+struct FreeGpuVirtualAddressCall : CallResult {
+    uint64_t sizePassed = -1;
+};
 } // namespace WddmMockHelpers
 
 class WddmMock : public Wddm {
@@ -119,7 +122,7 @@ class WddmMock : public Wddm {
     WddmMockHelpers::MakeResidentCall makeResidentResult;
     WddmMockHelpers::CallResult makeNonResidentResult;
     WddmMockHelpers::CallResult mapGpuVirtualAddressResult;
-    WddmMockHelpers::CallResult freeGpuVirtualAddressResult;
+    WddmMockHelpers::FreeGpuVirtualAddressCall freeGpuVirtualAddressResult;
     WddmMockHelpers::CallResult createAllocationResult;
     WddmMockHelpers::CallResult destroyAllocationResult;
     WddmMockHelpers::CallResult destroyContextResult;

unit_tests/os_interface/windows/wddm_memory_manager_tests.cpp

@@ -1646,27 +1646,33 @@ TEST_F(WddmMemoryManagerSimpleTest, whenDestroyingNotLockedAllocationThatNeedsMa
     memoryManager->freeGraphicsMemory(allocation);
     EXPECT_EQ(0u, wddm->evictTemporaryResourceResult.called);
 }
-TEST_F(WddmMemoryManagerSimpleTest, whenDestroyingAllocationWithPreferredGpuAddressThenReleaseTheAddress) {
+TEST_F(WddmMemoryManagerSimpleTest, whenDestroyingAllocationWithReservedGpuVirtualAddressThenReleaseTheAddress) {
     auto allocation = static_cast<WddmAllocation *>(memoryManager->allocateGraphicsMemoryWithProperties(MockAllocationProperties{MemoryConstants::pageSize}));
     uint64_t gpuAddress = 0x123;
-    allocation->preferredGpuAddress = gpuAddress;
+    uint64_t sizeForFree = 0x1234;
+    allocation->reservedGpuVirtualAddress = gpuAddress;
+    allocation->reservedSizeForGpuVirtualAddress = sizeForFree;
     memoryManager->freeGraphicsMemory(allocation);
     EXPECT_EQ(1u, wddm->freeGpuVirtualAddressResult.called);
     EXPECT_EQ(gpuAddress, wddm->freeGpuVirtualAddressResult.uint64ParamPassed);
+    EXPECT_EQ(sizeForFree, wddm->freeGpuVirtualAddressResult.sizePassed);
 }
 
-TEST_F(WddmMemoryManagerSimpleTest, givenAllocationWithPreferredGpuAddressWhenMapCallFailsDuringCreateWddmAllocationThenReleasePreferredAddress) {
+TEST_F(WddmMemoryManagerSimpleTest, givenAllocationWithReservedGpuVirtualAddressWhenMapCallFailsDuringCreateWddmAllocationThenReleasePreferredAddress) {
     MockWddmAllocation allocation;
     allocation.setAllocationType(GraphicsAllocation::AllocationType::KERNEL_ISA);
     uint64_t gpuAddress = 0x123;
-    allocation.preferredGpuAddress = gpuAddress;
+    uint64_t sizeForFree = 0x1234;
+    allocation.reservedGpuVirtualAddress = gpuAddress;
+    allocation.reservedSizeForGpuVirtualAddress = sizeForFree;
 
     wddm->callBaseMapGpuVa = false;
     wddm->mapGpuVaStatus = false;
 
     memoryManager->createWddmAllocation(&allocation, nullptr);
     EXPECT_EQ(1u, wddm->freeGpuVirtualAddressResult.called);
     EXPECT_EQ(gpuAddress, wddm->freeGpuVirtualAddressResult.uint64ParamPassed);
+    EXPECT_EQ(sizeForFree, wddm->freeGpuVirtualAddressResult.sizePassed);
 }
 
 TEST_F(WddmMemoryManagerSimpleTest, givenSvmCpuAllocationWhenSizeAndAlignmentProvidedThenAllocateMemoryReserveGpuVa) {