performance: Make memory resident before cpu access

Signed-off-by: Bellekallu Rajkiran <[email protected]>

Author: bellekal

shared/source/os_interface/linux/drm_memory_manager.cpp

@@ -2665,15 +2665,24 @@ DrmAllocation *DrmMemoryManager::createAllocWithAlignment(const AllocationData &
             return nullptr;
         }
 
-        [[maybe_unused]] auto retPtr = ioctlHelper->mmapFunction(*this, cpuPointer, alignedSize, PROT_READ | PROT_WRITE, MAP_SHARED | MAP_FIXED, drm.getFileDescriptor(), static_cast<off_t>(offset));
-        DEBUG_BREAK_IF(retPtr != cpuPointer);
-
         obtainGpuAddress(allocationData, bo.get(), gpuAddress);
         emitPinningRequest(bo.get(), allocationData);
 
         auto gmmHelper = getGmmHelper(allocationData.rootDeviceIndex);
         auto canonizedGpuAddress = gmmHelper->canonize(bo->peekAddress());
-        auto allocation = std::make_unique<DrmAllocation>(allocationData.rootDeviceIndex, 1u /*num gmms*/, allocationData.type, bo.get(), cpuPointer, canonizedGpuAddress, alignedSize, memoryPool);
+        auto allocation = std::make_unique<DrmAllocation>(allocationData.rootDeviceIndex, 1u /*num gmms*/, allocationData.type, bo.get(), nullptr, canonizedGpuAddress, alignedSize, memoryPool);
+
+        if (ioctlHelper->makeResidentBeforeLockNeeded()) {
+            auto memoryOperationsInterface = static_cast<DrmMemoryOperationsHandler *>(executionEnvironment.rootDeviceEnvironments[allocationData.rootDeviceIndex]->memoryOperationsInterface.get());
+            GraphicsAllocation *allocationPtr = allocation.get();
+            [[maybe_unused]] auto ret = memoryOperationsInterface->makeResidentWithinOsContext(getDefaultOsContext(allocationData.rootDeviceIndex), ArrayRef<NEO::GraphicsAllocation *>(&allocationPtr, 1), false, false, true) == MemoryOperationsStatus::success;
+            DEBUG_BREAK_IF(!ret);
+        }
+
+        [[maybe_unused]] auto retPtr = ioctlHelper->mmapFunction(*this, cpuPointer, alignedSize, PROT_READ | PROT_WRITE, MAP_SHARED | MAP_FIXED, drm.getFileDescriptor(), static_cast<off_t>(offset));
+        DEBUG_BREAK_IF(retPtr != cpuPointer);
+
+        allocation->setCpuPtrAndGpuAddress(cpuPointer, canonizedGpuAddress);
         allocation->setMmapPtr(cpuPointer);
         allocation->setMmapSize(alignedSize);
         if (pointerDiff != 0) {

shared/test/unit_test/os_interface/linux/drm_memory_manager_localmem_prelim_tests.cpp

@@ -13,6 +13,7 @@
 #include "shared/source/memory_manager/memory_banks.h"
 #include "shared/source/memory_manager/unified_memory_manager.h"
 #include "shared/source/os_interface/linux/allocator_helper.h"
+#include "shared/source/os_interface/linux/drm_memory_operations_handler_bind.h"
 #include "shared/source/utilities/heap_allocator.h"
 #include "shared/test/common/helpers/batch_buffer_helper.h"
 #include "shared/test/common/helpers/stream_capture.h"
@@ -3735,3 +3736,57 @@ TEST_F(DrmMemoryManagerLocalMemoryPrelimTest, givenCreateMultiHostDebugSurfaceAl
 
     memoryManager->freeGraphicsMemory(allocation);
 }
+
+TEST_F(DrmMemoryManagerLocalMemoryPrelimTest, givenDrmMemoryManagerAndResidentNeededbeforeLockWhenCreateAllocWithAlignmentIsCalledThenverifyAllocationIsResident) {
+    auto mockIoctlHelper = new MockIoctlHelper(*mock);
+    mockIoctlHelper->makeResidentBeforeLockNeededResult = true;
+
+    auto &drm = static_cast<DrmMockCustom &>(memoryManager->getDrm(rootDeviceIndex));
+    drm.ioctlHelper.reset(mockIoctlHelper);
+
+    auto memoryClassSystem = mockIoctlHelper->getDrmParamValue(DrmParam::memoryClassSystem);
+    auto memoryClassDevice = mockIoctlHelper->getDrmParamValue(DrmParam::memoryClassDevice);
+
+    std::vector<MemoryRegion> regionInfo(2);
+    regionInfo[0].region = {static_cast<uint16_t>(memoryClassSystem), 0};
+    regionInfo[1].region = {static_cast<uint16_t>(memoryClassDevice), DrmMockHelper::getEngineOrMemoryInstanceValue(0, 0)};
+
+    mock->memoryInfo.reset(new MockedMemoryInfo(regionInfo, *mock));
+    mock->engineInfoQueried = false;
+    mock->queryEngineInfo();
+
+    memoryManager->mmapFunction = [](void *addr, size_t len, int prot,
+                                     int flags, int fd, off_t offset) throw() {
+        if (addr == 0) {
+            return reinterpret_cast<void *>(0x10000000);
+        } else {
+            return addr;
+        }
+    };
+
+    memoryManager->munmapFunction = [](void *addr, size_t len) throw() {
+        return 0;
+    };
+
+    executionEnvironment->rootDeviceEnvironments[rootDeviceIndex]->memoryOperationsInterface.reset(new DrmMemoryOperationsHandlerBind(*executionEnvironment->rootDeviceEnvironments[rootDeviceIndex].get(), 0));
+
+    AllocationData allocationData;
+    allocationData.size = MemoryConstants::pageSize64k;
+    allocationData.rootDeviceIndex = 0u;
+    allocationData.type = AllocationType::buffer;
+
+    auto allocation = memoryManager->createAllocWithAlignment(allocationData,
+                                                              MemoryConstants::pageSize,
+                                                              MemoryConstants::pageSize64k,
+                                                              MemoryConstants::pageSize64k,
+                                                              0u);
+    ASSERT_NE(nullptr, allocation);
+
+    auto osContext = device->getDefaultEngine().osContext;
+    EXPECT_TRUE(allocation->isAlwaysResident(osContext->getContextId()));
+
+    memoryManager->freeGraphicsMemory(allocation);
+
+    memoryManager->mmapFunction = SysCalls::mmap;
+    memoryManager->munmapFunction = SysCalls::munmap;
+}