refactor virtualAlloc methods

adamstefanowski · Compute-Runtime-Automation · commit ffb33f5e865f · 2018-03-28T14:12:21.000+02:00
Change-Id: I06e93471b395818ad172048d545f1439066207d5
diff --git a/runtime/os_interface/windows/wddm.cpp b/runtime/os_interface/windows/wddm.cpp
@@ -43,11 +43,15 @@
 namespace OCLRT {
 extern Wddm::CreateDXGIFactoryFcn getCreateDxgiFactory();
 extern Wddm::GetSystemInfoFcn getGetSystemInfo();
+extern Wddm::VirtualAllocFcn getVirtualAlloc();
+extern Wddm::VirtualFreeFcn getVirtualFree();
 
 class WddmMemoryManager;
 
 Wddm::CreateDXGIFactoryFcn Wddm::createDxgiFactory = getCreateDxgiFactory();
 Wddm::GetSystemInfoFcn Wddm::getSystemInfo = getGetSystemInfo();
+Wddm::VirtualAllocFcn Wddm::virtualAllocFnc = getVirtualAlloc();
+Wddm::VirtualFreeFcn Wddm::virtualFreeFnc = getVirtualFree();
 
 Wddm::Wddm(Gdi *gdi) : initialized(false),
                        gdiAllocated(false),
@@ -900,7 +904,7 @@ void Wddm::registerTrimCallback(PFND3DKMT_TRIMNOTIFICATIONCALLBACK callback, Wdd
 
 void Wddm::releaseReservedAddress(void *reservedAddress) {
     if (reservedAddress) {
-        auto status = virtualFreeWrapper(reservedAddress, 0, MEM_RELEASE);
+        auto status = virtualFree(reservedAddress, 0, MEM_RELEASE);
         DEBUG_BREAK_IF(!status);
     }
 }
@@ -922,22 +926,22 @@ void Wddm::resetPageTableManager(GmmPageTableMngr *newPageTableManager) {
 }
 
 bool Wddm::reserveValidAddressRange(size_t size, void *&reservedMem) {
-    reservedMem = virtualAllocWrapper(nullptr, size, MEM_RESERVE, PAGE_READWRITE);
+    reservedMem = virtualAlloc(nullptr, size, MEM_RESERVE, PAGE_READWRITE);
     if (reservedMem == nullptr) {
         return false;
     } else if (minAddress > reinterpret_cast<uintptr_t>(reservedMem)) {
         StackVec<void *, 100> invalidAddrVector;
         invalidAddrVector.push_back(reservedMem);
         do {
-            reservedMem = virtualAllocWrapper(nullptr, size, MEM_RESERVE | MEM_TOP_DOWN, PAGE_READWRITE);
+            reservedMem = virtualAlloc(nullptr, size, MEM_RESERVE | MEM_TOP_DOWN, PAGE_READWRITE);
             if (minAddress > reinterpret_cast<uintptr_t>(reservedMem) && reservedMem != nullptr) {
                 invalidAddrVector.push_back(reservedMem);
             } else {
                 break;
             }
         } while (1);
         for (auto &it : invalidAddrVector) {
-            auto status = virtualFreeWrapper(it, 0, MEM_RELEASE);
+            auto status = virtualFree(it, 0, MEM_RELEASE);
             DEBUG_BREAK_IF(!status);
         }
         if (reservedMem == nullptr) {
@@ -947,4 +951,11 @@ bool Wddm::reserveValidAddressRange(size_t size, void *&reservedMem) {
     return true;
 }
 
+void *Wddm::virtualAlloc(void *inPtr, size_t size, unsigned long flags, unsigned long type) {
+    return virtualAllocFnc(inPtr, size, flags, type);
+}
+int Wddm::virtualFree(void *ptr, size_t size, unsigned long flags) {
+    return virtualFreeFnc(ptr, size, flags);
+}
+
 } // namespace OCLRT
diff --git a/runtime/os_interface/windows/wddm.h b/runtime/os_interface/windows/wddm.h
@@ -66,6 +66,8 @@ class Wddm {
   public:
     typedef HRESULT(WINAPI *CreateDXGIFactoryFcn)(REFIID riid, void **ppFactory);
     typedef void(WINAPI *GetSystemInfoFcn)(SYSTEM_INFO *pSystemInfo);
+    typedef BOOL(WINAPI *VirtualFreeFcn)(LPVOID ptr, SIZE_T size, DWORD flags);
+    typedef LPVOID(WINAPI *VirtualAllocFcn)(LPVOID inPtr, SIZE_T size, DWORD flags, DWORD type);
 
     virtual ~Wddm();
 
@@ -101,12 +103,9 @@ class Wddm {
     void registerTrimCallback(PFND3DKMT_TRIMNOTIFICATIONCALLBACK callback, WddmMemoryManager *memoryManager);
     MOCKABLE_VIRTUAL void releaseReservedAddress(void *reservedAddress);
     MOCKABLE_VIRTUAL bool reserveValidAddressRange(size_t size, void *&reservedMem);
-    MOCKABLE_VIRTUAL bool virtualFreeWrapper(void *ptr, size_t size, uint32_t flags) {
-        return VirtualFree(ptr, size, flags) != 0 ? true : false;
-    }
-    MOCKABLE_VIRTUAL void *virtualAllocWrapper(void *inPtr, size_t size, uint32_t flags, uint32_t type) {
-        return reinterpret_cast<void *>(VirtualAlloc(inPtr, size, flags, type));
-    }
+
+    MOCKABLE_VIRTUAL void *virtualAlloc(void *inPtr, size_t size, unsigned long flags, unsigned long type);
+    MOCKABLE_VIRTUAL int virtualFree(void *ptr, size_t size, unsigned long flags);
 
     template <typename GfxFamily>
     bool configureDeviceAddressSpace();
@@ -258,6 +257,8 @@ class Wddm {
 
     static CreateDXGIFactoryFcn createDxgiFactory;
     static GetSystemInfoFcn getSystemInfo;
+    static VirtualFreeFcn virtualFreeFnc;
+    static VirtualAllocFcn virtualAllocFnc;
 
     std::unique_ptr<GmmPageTableMngr> pageTableManager;
 
diff --git a/runtime/os_interface/windows/wddm_create.cpp b/runtime/os_interface/windows/wddm_create.cpp
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2017, Intel Corporation
+ * Copyright (c) 2017 - 2018, Intel Corporation
  *
  * Permission is hereby granted, free of charge, to any person obtaining a
  * copy of this software and associated documentation files (the "Software"),
@@ -22,7 +22,6 @@
 
 #include "runtime/os_interface/windows/wddm.h"
 #include <dxgi.h>
-
 namespace OCLRT {
 
 Wddm *Wddm::createWddm(Gdi *gdi) {
@@ -36,4 +35,13 @@ Wddm::CreateDXGIFactoryFcn getCreateDxgiFactory() {
 Wddm::GetSystemInfoFcn getGetSystemInfo() {
     return GetSystemInfo;
 }
+
+Wddm::VirtualFreeFcn getVirtualFree() {
+    return VirtualFree;
+}
+
+Wddm::VirtualAllocFcn getVirtualAlloc() {
+    return VirtualAlloc;
+}
+
 } // namespace OCLRT
diff --git a/unit_tests/os_interface/windows/device_command_stream_tests.cpp b/unit_tests/os_interface/windows/device_command_stream_tests.cpp
@@ -532,11 +532,13 @@ TEST_F(WddmCommandStreamTest, createAllocationAndMakeResident) {
 }
 
 TEST_F(WddmCommandStreamTest, givenHostPtrWhenPtrBelowRestrictionThenCreateAllocationAndMakeResident) {
-    void *hostPtr = reinterpret_cast<void *>(wddm->virtualAllocAddress - 0x3000);
+    void *hostPtr = reinterpret_cast<void *>(memManager->getAlignedMallocRestrictions()->minAddress - 0x1000);
     auto size = 0x2000u;
-    void *expectedReserve = reinterpret_cast<void *>(wddm->virtualAllocAddress);
+
     WddmAllocation *gfxAllocation = static_cast<WddmAllocation *>(csr->createAllocationAndHandleResidency(hostPtr, size));
 
+    void *expectedReserve = reinterpret_cast<void *>(wddm->virtualAllocAddress);
+
     ASSERT_NE(nullptr, gfxAllocation);
 
     EXPECT_EQ(1u, memManager->getResidencyAllocations().size());
diff --git a/unit_tests/os_interface/windows/wddm_create.cpp b/unit_tests/os_interface/windows/wddm_create.cpp
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2017, Intel Corporation
+ * Copyright (c) 2017 - 2018, Intel Corporation
  *
  * Permission is hereby granted, free of charge, to any person obtaining a
  * copy of this software and associated documentation files (the "Software"),
@@ -24,6 +24,16 @@
 #include "unit_tests/os_interface/windows/ult_dxgi_factory.h"
 
 namespace OCLRT {
+
+BOOL WINAPI ULTVirtualFree(LPVOID ptr, SIZE_T size, DWORD flags) {
+    free(ptr);
+    return 1;
+}
+
+LPVOID WINAPI ULTVirtualAlloc(LPVOID inPtr, SIZE_T size, DWORD flags, DWORD type) {
+    return malloc(size);
+}
+
 Wddm *Wddm::createWddm(Gdi *gdi) {
     if (gdi == nullptr)
         return new WddmMock();
@@ -37,4 +47,12 @@ Wddm::CreateDXGIFactoryFcn getCreateDxgiFactory() {
 Wddm::GetSystemInfoFcn getGetSystemInfo() {
     return ULTGetSystemInfo;
 }
+
+Wddm::VirtualFreeFcn getVirtualFree() {
+    return ULTVirtualFree;
+}
+
+Wddm::VirtualAllocFcn getVirtualAlloc() {
+    return ULTVirtualAlloc;
+}
 } // namespace OCLRT
diff --git a/unit_tests/os_interface/windows/wddm_fixture.h b/unit_tests/os_interface/windows/wddm_fixture.h
@@ -277,16 +277,14 @@ class WddmMock : public Wddm {
         return waitFromCpuResult.success = Wddm::waitFromCpu(lastFenceValue);
     }
 
-    bool virtualFreeWrapper(void *ptr, size_t size, uint32_t flags) {
-        return true;
+    void *virtualAlloc(void *inPtr, size_t size, unsigned long flags, unsigned long type) override {
+        void *address = Wddm::virtualAlloc(inPtr, size, flags, type);
+        virtualAllocAddress = (uintptr_t)address;
+        return address;
     }
-
-    void *virtualAllocWrapper(void *inPtr, size_t size, uint32_t flags, uint32_t type) {
-        void *tmp = reinterpret_cast<void *>(virtualAllocAddress);
-        size += MemoryConstants::pageSize;
-        size -= size % MemoryConstants::pageSize;
-        virtualAllocAddress += size;
-        return tmp;
+    int virtualFree(void *ptr, size_t size, unsigned long flags) override {
+        int success = Wddm::virtualFree(ptr, size, flags);
+        return success;
     }
 
     void releaseReservedAddress(void *reservedAddress) override {
@@ -361,15 +359,15 @@ class WddmMockReserveAddress : public WddmMock {
         returnNullIter = 0;
     }
 
-    void *virtualAllocWrapper(void *inPtr, size_t size, uint32_t flags, uint32_t type) {
+    void *virtualAlloc(void *inPtr, size_t size, unsigned long flags, unsigned long type) override {
         if (returnGood != 0) {
-            return WddmMock::virtualAllocWrapper(inPtr, size, flags, type);
+            return WddmMock::virtualAlloc(inPtr, size, flags, type);
         }
 
         if (returnInvalidCount != 0) {
             returnInvalidIter++;
             if (returnInvalidIter > returnInvalidCount) {
-                return WddmMock::virtualAllocWrapper(inPtr, size, flags, type);
+                return WddmMock::virtualAlloc(inPtr, size, flags, type);
             }
             if (returnNullCount != 0) {
                 returnNullIter++;
@@ -384,6 +382,15 @@ class WddmMockReserveAddress : public WddmMock {
         return nullptr;
     }
 
+    int virtualFree(void *ptr, size_t size, unsigned long flags) override {
+
+        if ((ptr == reinterpret_cast<void *>(0x1000)) || (ptr == reinterpret_cast<void *>(0x0))) {
+            return 1;
+        }
+
+        return WddmMock::virtualFree(ptr, size, flags);
+    }
+
     uint32_t returnGood;
     uint32_t returnInvalidCount;
     uint32_t returnInvalidIter;
diff --git a/unit_tests/os_interface/windows/wddm_memory_manager_tests.cpp b/unit_tests/os_interface/windows/wddm_memory_manager_tests.cpp
@@ -618,11 +618,13 @@ HWTEST_F(WddmMemoryManagerTest, givenDefaultWddmMemoryManagerWhenAskedForAligned
 HWTEST_F(WddmMemoryManagerTest, givenWddmMemoryManagerWhenCpuMemNotMeetRestrictionsThenReserveMemRangeForMap) {
     SetUpMm<FamilyType>();
     WddmMock *mockWddm = static_cast<WddmMock *>(wddm);
-    void *cpuPtr = reinterpret_cast<void *>(mockWddm->virtualAllocAddress - 0x3000);
+    void *cpuPtr = reinterpret_cast<void *>(memoryManager->getAlignedMallocRestrictions()->minAddress - 0x1000);
     size_t size = 0x1000;
-    void *expectReserve = reinterpret_cast<void *>(mockWddm->virtualAllocAddress);
 
     WddmAllocation *allocation = static_cast<WddmAllocation *>(memoryManager->allocateGraphicsMemory(size, cpuPtr));
+
+    void *expectReserve = reinterpret_cast<void *>(mockWddm->virtualAllocAddress);
+
     ASSERT_NE(nullptr, allocation);
     EXPECT_EQ(expectReserve, allocation->getReservedAddress());
     EXPECT_EQ(expectReserve, reinterpret_cast<void *>(allocation->gpuPtr));
diff --git a/unit_tests/os_interface/windows/wddm_tests.cpp b/unit_tests/os_interface/windows/wddm_tests.cpp
@@ -1001,8 +1001,9 @@ HWTEST_F(WddmReserveAddressTest, givenWddmWhenFirstIsSuccessfulThenReturnReserve
     EXPECT_TRUE(ret);
 
     wddmMock->returnGood = 1;
-    uintptr_t expectedReserve = wddmMock->virtualAllocAddress;
+
     ret = wddmMock->reserveValidAddressRange(size, reserve);
+    uintptr_t expectedReserve = wddmMock->virtualAllocAddress;
     EXPECT_TRUE(ret);
     EXPECT_EQ(expectedReserve, reinterpret_cast<uintptr_t>(reserve));
     wddmMock->releaseReservedAddress(reserve);
@@ -1032,9 +1033,9 @@ HWTEST_F(WddmReserveAddressTest, givenWddmWhenFirstIsInvalidSecondSuccessfulThen
     EXPECT_TRUE(ret);
 
     wddmMock->returnInvalidCount = 1;
-    uintptr_t expectedReserve = wddmMock->virtualAllocAddress;
 
     ret = wddmMock->reserveValidAddressRange(size, reserve);
+    uintptr_t expectedReserve = wddmMock->virtualAllocAddress;
     EXPECT_TRUE(ret);
     EXPECT_EQ(expectedReserve, reinterpret_cast<uintptr_t>(reserve));
     wddmMock->releaseReservedAddress(reserve);
@@ -1050,9 +1051,9 @@ HWTEST_F(WddmReserveAddressTest, givenWddmWhenSecondIsInvalidThirdSuccessfulThen
     EXPECT_TRUE(ret);
 
     wddmMock->returnInvalidCount = 2;
-    uintptr_t expectedReserve = wddmMock->virtualAllocAddress;
 
     ret = wddmMock->reserveValidAddressRange(size, reserve);
+    uintptr_t expectedReserve = wddmMock->virtualAllocAddress;
     EXPECT_TRUE(ret);
     EXPECT_EQ(expectedReserve, reinterpret_cast<uintptr_t>(reserve));
     wddmMock->releaseReservedAddress(reserve);
