feature: support explicit memory locking

Added lockMemory in context to explicitly locking memory, Added a boolean flag in graphics_allocation to indicate the allocation is locked, and modified memory_operations_handler to add lock(). Related-To: NEO-8277 Signed-off-by: Young Jin Yoon <young.jin.yoon@intel.com>
intel · Mar 29, 2024 · d6a14d4 · d6a14d4
1 parent 15420aa
commit d6a14d4
Show file tree

Hide file tree

Showing 49 changed files with 615 additions and 97 deletions.
diff --git a/level_zero/core/source/context/CMakeLists.txt b/level_zero/core/source/context/CMakeLists.txt
@@ -7,8 +7,9 @@
 target_sources(${L0_STATIC_LIB_NAME}
                PRIVATE
                ${CMAKE_CURRENT_SOURCE_DIR}/CMakeLists.txt
+               ${CMAKE_CURRENT_SOURCE_DIR}/${BRANCH_DIR_SUFFIX}context_imp_helper.cpp
                ${CMAKE_CURRENT_SOURCE_DIR}/context_imp_${DRIVER_MODEL}/context_imp_${DRIVER_MODEL}.cpp
-               ${CMAKE_CURRENT_SOURCE_DIR}/context_imp_${DRIVER_MODEL}${BRANCH_DIR_SUFFIX}context_imp_helper.cpp
+               ${CMAKE_CURRENT_SOURCE_DIR}/context_imp_${DRIVER_MODEL}${BRANCH_DIR_SUFFIX}context_imp_${DRIVER_MODEL}_helper.cpp
                ${CMAKE_CURRENT_SOURCE_DIR}/context_imp.cpp
                ${CMAKE_CURRENT_SOURCE_DIR}/context_imp.h
                ${CMAKE_CURRENT_SOURCE_DIR}/context.h

diff --git a/level_zero/core/source/context/context.h b/level_zero/core/source/context/context.h
@@ -162,7 +162,7 @@ struct Context : _ze_context_handle_t {
     virtual ze_result_t getVirtualAddressSpaceIpcHandle(ze_device_handle_t hDevice,
                                                         ze_ipc_mem_handle_t *pIpcHandle) = 0;
     virtual ze_result_t putVirtualAddressSpaceIpcHandle(ze_ipc_mem_handle_t ipcHandle) = 0;
-
+    virtual ze_result_t lockMemory(ze_device_handle_t hDevice, void *ptr, size_t size) = 0;
     virtual bool isShareableMemory(const void *exportDesc, bool exportableMemory, NEO::Device *neoDevice) = 0;
     virtual void *getMemHandlePtr(ze_device_handle_t hDevice, uint64_t handle, NEO::AllocationType allocationType, ze_ipc_memory_flags_t flags) = 0;
 

diff --git a/level_zero/core/source/context/context_imp.cpp b/level_zero/core/source/context/context_imp.cpp
@@ -471,6 +471,9 @@ ze_result_t ContextImp::makeMemoryResident(ze_device_handle_t hDevice, void *ptr
             return ZE_RESULT_ERROR_INVALID_ARGUMENT;
         }
     }
+    if (allocation->isLockedMemory()) {
+        return ZE_RESULT_ERROR_INVALID_ARGUMENT;
+    }
 
     NEO::MemoryOperationsHandler *memoryOperationsIface = neoDevice->getRootDeviceEnvironment().memoryOperationsInterface.get();
     auto success = memoryOperationsIface->makeResident(neoDevice, ArrayRef<NEO::GraphicsAllocation *>(&allocation, 1));

diff --git a/level_zero/core/source/context/context_imp.h b/level_zero/core/source/context/context_imp.h
@@ -66,6 +66,7 @@ struct ContextImp : Context {
                                  void **ptr) override;
     ze_result_t getIpcHandleFromFd(uint64_t handle, ze_ipc_mem_handle_t *pIpcHandle) override;
     ze_result_t getFdFromIpcHandle(ze_ipc_mem_handle_t ipcHandle, uint64_t *pHandle) override;
+    ze_result_t lockMemory(ze_device_handle_t hDevice, void *ptr, size_t size) override;
 
     ze_result_t
     getIpcMemHandles(

diff --git a/...xt/context_imp_drm/context_imp_helper.cpp → ...ontext_imp_drm/context_imp_drm_helper.cpp b/...xt/context_imp_drm/context_imp_helper.cpp → ...ontext_imp_drm/context_imp_drm_helper.cpp
diff --git a/...xt_imp_drm_or_wddm/context_imp_helper.cpp → ...r_wddm/context_imp_drm_or_wddm_helper.cpp b/...xt_imp_drm_or_wddm/context_imp_helper.cpp → ...r_wddm/context_imp_drm_or_wddm_helper.cpp
diff --git a/level_zero/core/source/context/context_imp_helper.cpp b/level_zero/core/source/context/context_imp_helper.cpp
@@ -0,0 +1,18 @@
+/*
+ * Copyright (C) 2024 Intel Corporation
+ *
+ * SPDX-License-Identifier: MIT
+ *
+ */
+
+#include "level_zero/core/source/context/context_imp.h"
+#include "level_zero/core/source/device/device.h"
+#include "level_zero/core/source/driver/driver_handle_imp.h"
+
+namespace L0 {
+
+ze_result_t ContextImp::lockMemory(ze_device_handle_t device, void *ptr, size_t size) {
+    return ZE_RESULT_ERROR_UNSUPPORTED_FEATURE;
+}
+
+} // namespace L0
diff --git a/...t/context_imp_wddm/context_imp_helper.cpp → ...text_imp_wddm/context_imp_wddm_helper.cpp b/...t/context_imp_wddm/context_imp_helper.cpp → ...text_imp_wddm/context_imp_wddm_helper.cpp
@@ -18,4 +18,5 @@ ze_result_t ContextImp::getVirtualAddressSpaceIpcHandle(ze_device_handle_t hDevi
 ze_result_t ContextImp::putVirtualAddressSpaceIpcHandle(ze_ipc_mem_handle_t ipcHandle) {
     return ZE_RESULT_ERROR_UNSUPPORTED_FEATURE;
 }
+
 } // namespace L0
diff --git a/level_zero/core/test/unit_tests/sources/context/CMakeLists.txt b/level_zero/core/test/unit_tests/sources/context/CMakeLists.txt
@@ -8,6 +8,7 @@ target_sources(${TARGET_NAME} PRIVATE
                ${CMAKE_CURRENT_SOURCE_DIR}/CMakeLists.txt
                ${CMAKE_CURRENT_SOURCE_DIR}/test_context.cpp
                ${CMAKE_CURRENT_SOURCE_DIR}/test_context_${DRIVER_MODEL}.cpp
+               ${CMAKE_CURRENT_SOURCE_DIR}${BRANCH_DIR_SUFFIX}test_context_helper.cpp
 )
 
 add_subdirectories()
diff --git a/level_zero/core/test/unit_tests/sources/context/linux/CMakeLists.txt b/level_zero/core/test/unit_tests/sources/context/linux/CMakeLists.txt
@@ -7,7 +7,7 @@
 if(UNIX)
   target_sources(${TARGET_NAME} PRIVATE
                  ${CMAKE_CURRENT_SOURCE_DIR}/CMakeLists.txt
-                 ${CMAKE_CURRENT_SOURCE_DIR}${BRANCH_DIR_SUFFIX}test_context_helper.cpp
+                 ${CMAKE_CURRENT_SOURCE_DIR}${BRANCH_DIR_SUFFIX}test_context_helper_linux.cpp
   )
 endif()
 

diff --git a/...ces/context/linux/test_context_helper.cpp → ...ntext/linux/test_context_helper_linux.cpp b/...ces/context/linux/test_context_helper.cpp → ...ntext/linux/test_context_helper_linux.cpp
@@ -10,12 +10,14 @@
 #include "shared/test/common/mocks/mock_builtins.h"
 #include "shared/test/common/mocks/mock_device.h"
 #include "shared/test/common/mocks/mock_driver_model.h"
+#include "shared/test/common/mocks/mock_memory_operations_handler.h"
 #include "shared/test/common/test_macros/test.h"
 
 #include "level_zero/core/source/context/context_imp.h"
 #include "level_zero/core/source/driver/driver_handle_imp.h"
 #include "level_zero/core/source/driver/driver_imp.h"
 #include "level_zero/core/test/unit_tests/fixtures/device_fixture.h"
+#include "level_zero/core/test/unit_tests/fixtures/host_pointer_manager_fixture.h"
 #include "level_zero/core/test/unit_tests/mocks/mock_driver_handle.h"
 
 #include "gtest/gtest.h"
@@ -41,5 +43,6 @@ TEST_F(ContextGetVirtualAddressSpaceTests, givenDrmDriverModelWhenCallingGetVirt
     res = contextImp->destroy();
     EXPECT_EQ(ZE_RESULT_SUCCESS, res);
 }
+
 } // namespace ult
 } // namespace L0
diff --git a/level_zero/core/test/unit_tests/sources/context/test_context.cpp b/level_zero/core/test/unit_tests/sources/context/test_context.cpp
@@ -580,6 +580,31 @@ TEST_F(ContextMakeMemoryResidentTests,
     context->freeMem(ptr);
 }
 
+TEST_F(ContextMakeMemoryResidentTests,
+       givenValidAllocationwithLockedWhenCallingMakeMemoryResidentThenInvalidArgumentIsReturned) {
+    const size_t size = 4096;
+    void *ptr = nullptr;
+    ze_host_mem_alloc_desc_t hostDesc = {};
+    ze_device_mem_alloc_desc_t deviceDesc = {};
+    ze_result_t res = context->allocSharedMem(device->toHandle(),
+                                              &deviceDesc,
+                                              &hostDesc,
+                                              size,
+                                              0,
+                                              &ptr);
+    EXPECT_EQ(ZE_RESULT_SUCCESS, res);
+
+    DriverHandleImp *driverHandleImp = static_cast<DriverHandleImp *>(hostDriverHandle.get());
+    auto allocation = driverHandleImp->getDriverSystemMemoryAllocation(ptr, size, neoDevice->getRootDeviceIndex(), nullptr);
+    allocation->setLockedMemory(true);
+
+    mockMemoryInterface->makeResidentResult = NEO::MemoryOperationsStatus::success;
+    res = context->makeMemoryResident(device, ptr, size);
+    EXPECT_EQ(ZE_RESULT_ERROR_INVALID_ARGUMENT, res);
+
+    context->freeMem(ptr);
+}
+
 TEST_F(ContextMakeMemoryResidentTests,
        whenMakingASharedMemoryResidentThenIsAddedToVectorOfResidentAllocations) {
     const size_t size = 4096;

diff --git a/level_zero/core/test/unit_tests/sources/context/test_context_helper.cpp b/level_zero/core/test/unit_tests/sources/context/test_context_helper.cpp
@@ -0,0 +1,48 @@
+/*
+ * Copyright (C) 2023-2024 Intel Corporation
+ *
+ * SPDX-License-Identifier: MIT
+ *
+ */
+
+#include "shared/source/execution_environment/root_device_environment.h"
+#include "shared/source/os_interface/os_interface.h"
+#include "shared/test/common/mocks/mock_builtins.h"
+#include "shared/test/common/mocks/mock_device.h"
+#include "shared/test/common/mocks/mock_driver_model.h"
+#include "shared/test/common/mocks/mock_memory_operations_handler.h"
+#include "shared/test/common/test_macros/test.h"
+
+#include "level_zero/core/source/context/context_imp.h"
+#include "level_zero/core/source/driver/driver_handle_imp.h"
+#include "level_zero/core/source/driver/driver_imp.h"
+#include "level_zero/core/test/unit_tests/fixtures/device_fixture.h"
+#include "level_zero/core/test/unit_tests/fixtures/host_pointer_manager_fixture.h"
+#include "level_zero/core/test/unit_tests/mocks/mock_driver_handle.h"
+
+#include "gtest/gtest.h"
+namespace L0 {
+namespace ult {
+
+using ContextLockMemoryTests = Test<HostPointerManagerFixure>;
+
+TEST_F(ContextLockMemoryTests, givenValidPointerWhenCallingLockMemoryThenUnsupportedErrorIsReturned) {
+    const size_t size = 4096;
+    void *ptr = nullptr;
+    ze_device_mem_alloc_desc_t deviceDesc = {};
+    ze_result_t res = context->allocDeviceMem(device->toHandle(),
+                                              &deviceDesc,
+                                              size,
+                                              0,
+                                              &ptr);
+    EXPECT_EQ(ZE_RESULT_SUCCESS, res);
+
+    mockMemoryInterface->lockResult = NEO::MemoryOperationsStatus::success;
+    res = context->lockMemory(device, ptr, size);
+    EXPECT_EQ(ZE_RESULT_ERROR_UNSUPPORTED_FEATURE, res);
+
+    context->freeMem(ptr);
+}
+
+} // namespace ult
+} // namespace L0
diff --git a/level_zero/core/test/unit_tests/sources/context/windows/CMakeLists.txt b/level_zero/core/test/unit_tests/sources/context/windows/CMakeLists.txt
@@ -7,6 +7,6 @@
 if(WIN32)
   target_sources(${TARGET_NAME} PRIVATE
                  ${CMAKE_CURRENT_SOURCE_DIR}/CMakeLists.txt
-                 ${CMAKE_CURRENT_SOURCE_DIR}${BRANCH_DIR_SUFFIX}test_context_helper.cpp
+                 ${CMAKE_CURRENT_SOURCE_DIR}${BRANCH_DIR_SUFFIX}test_context_helper_windows.cpp
   )
 endif()
diff --git a/...s/context/windows/test_context_helper.cpp → ...t/windows/test_context_helper_windows.cpp b/...s/context/windows/test_context_helper.cpp → ...t/windows/test_context_helper_windows.cpp
@@ -10,12 +10,14 @@
 #include "shared/test/common/mocks/mock_builtins.h"
 #include "shared/test/common/mocks/mock_device.h"
 #include "shared/test/common/mocks/mock_driver_model.h"
+#include "shared/test/common/mocks/mock_memory_operations_handler.h"
 #include "shared/test/common/test_macros/test.h"
 
 #include "level_zero/core/source/context/context_imp.h"
 #include "level_zero/core/source/driver/driver_handle_imp.h"
 #include "level_zero/core/source/driver/driver_imp.h"
 #include "level_zero/core/test/unit_tests/fixtures/device_fixture.h"
+#include "level_zero/core/test/unit_tests/fixtures/host_pointer_manager_fixture.h"
 #include "level_zero/core/test/unit_tests/mocks/mock_driver_handle.h"
 
 #include "gtest/gtest.h"

diff --git a/shared/source/debug_settings/debug_variables_base.inl b/shared/source/debug_settings/debug_variables_base.inl
@@ -612,6 +612,7 @@ DECLARE_DEBUG_VARIABLE(int32_t, EnableSetPair, -1, "Use SET_PAIR to pair two buf
 DECLARE_DEBUG_VARIABLE(int32_t, ForcePreferredAllocationMethod, -1, "Sets preferred allocation method for Wddm paths; values = -1: driver default, 0: UseUmdSystemPtr, 1: AllocateByKmd")
 DECLARE_DEBUG_VARIABLE(int32_t, EventTimestampRefreshIntervalInMilliSec, -1, "-1: use driver default, This value sets the refresh interval for getting synchronized GPU and CPU timestamp")
 DECLARE_DEBUG_VARIABLE(int64_t, ReadOnlyAllocationsTypeMask, 0, "0: default,  >0: (bitmask) for given Graphics Allocation Type, set as read only resource.")
+
 /* Binary Cache */
 DECLARE_DEBUG_VARIABLE(bool, BinaryCacheTrace, false, "enable cl_cache to produce .trace files with information about hash computation")
 

diff --git a/shared/source/memory_manager/graphics_allocation.h b/shared/source/memory_manager/graphics_allocation.h
@@ -124,6 +124,8 @@ class GraphicsAllocation : public IDNode<GraphicsAllocation> {
     bool peekEvictable() const { return allocationInfo.flags.evictable; }
     bool isFlushL3Required() const { return allocationInfo.flags.flushL3Required; }
     void setFlushL3Required(bool flushL3Required) { allocationInfo.flags.flushL3Required = flushL3Required; }
+    bool isLockedMemory() const { return allocationInfo.flags.lockedMemory; }
+    void setLockedMemory(bool locked) { allocationInfo.flags.lockedMemory = locked; }
 
     bool isUncacheable() const { return allocationInfo.flags.uncacheable; }
     void setUncacheable(bool uncacheable) { allocationInfo.flags.uncacheable = uncacheable; }
@@ -349,7 +351,8 @@ class GraphicsAllocation : public IDNode<GraphicsAllocation> {
                 uint32_t flushL3Required : 1;
                 uint32_t uncacheable : 1;
                 uint32_t is32BitAllocation : 1;
-                uint32_t reserved : 27;
+                uint32_t lockedMemory : 1;
+                uint32_t reserved : 26;
             } flags;
             uint32_t allFlags = 0u;
         };
@@ -359,6 +362,7 @@ class GraphicsAllocation : public IDNode<GraphicsAllocation> {
             flags.evictable = true;
             flags.flushL3Required = true;
             flags.is32BitAllocation = false;
+            flags.lockedMemory = false;
         }
     };
 

diff --git a/shared/source/memory_manager/memory_operations_handler.h b/shared/source/memory_manager/memory_operations_handler.h
@@ -20,6 +20,7 @@ class MemoryOperationsHandler {
     virtual ~MemoryOperationsHandler() = default;
 
     virtual MemoryOperationsStatus makeResident(Device *device, ArrayRef<GraphicsAllocation *> gfxAllocations) = 0;
+    virtual MemoryOperationsStatus lock(Device *device, ArrayRef<GraphicsAllocation *> gfxAllocations) = 0;
     virtual MemoryOperationsStatus evict(Device *device, GraphicsAllocation &gfxAllocation) = 0;
     virtual MemoryOperationsStatus isResident(Device *device, GraphicsAllocation &gfxAllocation) = 0;
 

diff --git a/shared/source/os_interface/aub_memory_operations_handler.cpp b/shared/source/os_interface/aub_memory_operations_handler.cpp
@@ -69,6 +69,10 @@ MemoryOperationsStatus AubMemoryOperationsHandler::makeResident(Device *device,
     return MemoryOperationsStatus::success;
 }
 
+MemoryOperationsStatus AubMemoryOperationsHandler::lock(Device *device, ArrayRef<GraphicsAllocation *> gfxAllocations) {
+    return makeResident(device, gfxAllocations);
+}
+
 MemoryOperationsStatus AubMemoryOperationsHandler::evict(Device *device, GraphicsAllocation &gfxAllocation) {
     auto lock = acquireLock(resourcesLock);
     auto itor = std::find(residentAllocations.begin(), residentAllocations.end(), &gfxAllocation);

diff --git a/shared/source/os_interface/aub_memory_operations_handler.h b/shared/source/os_interface/aub_memory_operations_handler.h
@@ -23,6 +23,7 @@ class AubMemoryOperationsHandler : public MemoryOperationsHandler {
     ~AubMemoryOperationsHandler() override = default;
 
     MemoryOperationsStatus makeResident(Device *device, ArrayRef<GraphicsAllocation *> gfxAllocations) override;
+    MemoryOperationsStatus lock(Device *device, ArrayRef<GraphicsAllocation *> gfxAllocations) override;
     MemoryOperationsStatus evict(Device *device, GraphicsAllocation &gfxAllocation) override;
     MemoryOperationsStatus isResident(Device *device, GraphicsAllocation &gfxAllocation) override;
 

diff --git a/shared/source/os_interface/linux/drm_buffer_object.h b/shared/source/os_interface/linux/drm_buffer_object.h
@@ -217,6 +217,9 @@ class BufferObject {
     std::vector<uint64_t> &getColourAddresses() {
         return this->bindAddresses;
     }
+    void requireExplicitLockedMemory(bool locked) { requiresLocked = locked; }
+    bool isExplicitLockedMemoryRequired() { return requiresLocked; }
+
     uint64_t peekPatIndex() const { return patIndex; }
     void setPatIndex(uint64_t newPatIndex) { this->patIndex = newPatIndex; }
     BOType peekBOType() const { return boType; }
@@ -266,6 +269,7 @@ class BufferObject {
     bool allowCapture = false;
     bool requiresImmediateBinding = false;
     bool requiresExplicitResidency = false;
+    bool requiresLocked = false;
     bool chunked = false;
     bool isReused = false;
     bool readOnlyGpuResource = false;

diff --git a/shared/source/os_interface/linux/drm_memory_operations_handler_bind.cpp b/shared/source/os_interface/linux/drm_memory_operations_handler_bind.cpp
@@ -39,6 +39,13 @@ MemoryOperationsStatus DrmMemoryOperationsHandlerBind::makeResident(Device *devi
     return result;
 }
 
+MemoryOperationsStatus DrmMemoryOperationsHandlerBind::lock(Device *device, ArrayRef<GraphicsAllocation *> gfxAllocations) {
+    for (auto gfxAllocation = gfxAllocations.begin(); gfxAllocation != gfxAllocations.end(); gfxAllocation++) {
+        (*gfxAllocation)->setLockedMemory(true);
+    }
+    return makeResident(device, gfxAllocations);
+}
+
 MemoryOperationsStatus DrmMemoryOperationsHandlerBind::makeResidentWithinOsContext(OsContext *osContext, ArrayRef<GraphicsAllocation *> gfxAllocations, bool evictable) {
     auto deviceBitfield = osContext->getDeviceBitfield();
 
@@ -59,12 +66,12 @@ MemoryOperationsStatus DrmMemoryOperationsHandlerBind::makeResidentWithinOsConte
             }
 
             if (!bo->getBindInfo()[bo->getOsContextId(osContext)][drmIterator]) {
+                bo->requireExplicitLockedMemory(drmAllocation->isLockedMemory());
                 int result = drmAllocation->makeBOsResident(osContext, drmIterator, nullptr, true);
                 if (result) {
                     return MemoryOperationsStatus::outOfMemory;
                 }
             }
-
             if (!evictable) {
                 drmAllocation->updateResidencyTaskCount(GraphicsAllocation::objectAlwaysResident, osContext->getContextId());
             }
@@ -77,6 +84,7 @@ MemoryOperationsStatus DrmMemoryOperationsHandlerBind::makeResidentWithinOsConte
 MemoryOperationsStatus DrmMemoryOperationsHandlerBind::evict(Device *device, GraphicsAllocation &gfxAllocation) {
     auto &engines = device->getAllEngines();
     auto retVal = MemoryOperationsStatus::success;
+    gfxAllocation.setLockedMemory(false);
     for (const auto &engine : engines) {
         retVal = this->evictWithinOsContext(engine.osContext, gfxAllocation);
         if (retVal != MemoryOperationsStatus::success) {
@@ -185,7 +193,10 @@ MemoryOperationsStatus DrmMemoryOperationsHandlerBind::evictUnusedAllocationsImp
                         evict = false;
                         break;
                     }
-
+                    if (allocation->isLockedMemory()) {
+                        evict = false;
+                        break;
+                    }
                     if (waitForCompletion) {
                         const auto waitStatus = engine.commandStreamReceiver->waitForCompletionWithTimeout(WaitParams{false, false, 0}, engine.commandStreamReceiver->peekLatestFlushedTaskCount());
                         if (waitStatus == WaitStatus::gpuHang) {

diff --git a/shared/source/os_interface/linux/drm_memory_operations_handler_bind.h b/shared/source/os_interface/linux/drm_memory_operations_handler_bind.h
@@ -18,6 +18,7 @@ class DrmMemoryOperationsHandlerBind : public DrmMemoryOperationsHandler {
 
     MemoryOperationsStatus makeResidentWithinOsContext(OsContext *osContext, ArrayRef<GraphicsAllocation *> gfxAllocations, bool evictable) override;
     MemoryOperationsStatus makeResident(Device *device, ArrayRef<GraphicsAllocation *> gfxAllocations) override;
+    MemoryOperationsStatus lock(Device *device, ArrayRef<GraphicsAllocation *> gfxAllocations) override;
     MemoryOperationsStatus evict(Device *device, GraphicsAllocation &gfxAllocation) override;
     MemoryOperationsStatus evictWithinOsContext(OsContext *osContext, GraphicsAllocation &gfxAllocation) override;
     MemoryOperationsStatus isResident(Device *device, GraphicsAllocation &gfxAllocation) override;

diff --git a/shared/source/os_interface/linux/drm_memory_operations_handler_default.cpp b/shared/source/os_interface/linux/drm_memory_operations_handler_default.cpp
@@ -8,6 +8,8 @@
 #include "shared/source/os_interface/linux/drm_memory_operations_handler_default.h"
 
 #include "shared/source/debug_settings/debug_settings_manager.h"
+#include "shared/source/os_interface/linux/drm_allocation.h"
+#include "shared/source/os_interface/linux/drm_buffer_object.h"
 
 #include <algorithm>
 
@@ -29,6 +31,18 @@ MemoryOperationsStatus DrmMemoryOperationsHandlerDefault::makeResident(Device *d
     return this->makeResidentWithinOsContext(osContext, gfxAllocations, false);
 }
 
+MemoryOperationsStatus DrmMemoryOperationsHandlerDefault::lock(Device *device, ArrayRef<GraphicsAllocation *> gfxAllocations) {
+    OsContext *osContext = nullptr;
+    for (auto gfxAllocation = gfxAllocations.begin(); gfxAllocation != gfxAllocations.end(); gfxAllocation++) {
+        auto drmAllocation = static_cast<DrmAllocation *>(*gfxAllocation);
+        drmAllocation->setLockedMemory(true);
+        for (auto bo : drmAllocation->getBOs()) {
+            bo->requireExplicitLockedMemory(true);
+        }
+    }
+    return this->makeResidentWithinOsContext(osContext, gfxAllocations, false);
+}
+
 MemoryOperationsStatus DrmMemoryOperationsHandlerDefault::evictWithinOsContext(OsContext *osContext, GraphicsAllocation &gfxAllocation) {
     std::lock_guard<std::mutex> lock(mutex);
     this->residency.erase(&gfxAllocation);
@@ -37,6 +51,16 @@ MemoryOperationsStatus DrmMemoryOperationsHandlerDefault::evictWithinOsContext(O
 
 MemoryOperationsStatus DrmMemoryOperationsHandlerDefault::evict(Device *device, GraphicsAllocation &gfxAllocation) {
     OsContext *osContext = nullptr;
+    auto drmAllocation = static_cast<DrmAllocation *>(&gfxAllocation);
+    drmAllocation->setLockedMemory(false);
+    if (drmAllocation->storageInfo.isChunked || drmAllocation->storageInfo.getNumBanks() == 1) {
+        auto bo = drmAllocation->getBO();
+        bo->requireExplicitLockedMemory(false);
+    } else {
+        for (auto bo : drmAllocation->getBOs()) {
+            bo->requireExplicitLockedMemory(false);
+        }
+    }
     return this->evictWithinOsContext(osContext, gfxAllocation);
 }
 

diff --git a/shared/source/os_interface/linux/drm_memory_operations_handler_default.h b/shared/source/os_interface/linux/drm_memory_operations_handler_default.h
@@ -21,6 +21,7 @@ class DrmMemoryOperationsHandlerDefault : public DrmMemoryOperationsHandler {
 
     MemoryOperationsStatus makeResidentWithinOsContext(OsContext *osContext, ArrayRef<GraphicsAllocation *> gfxAllocations, bool evictable) override;
     MemoryOperationsStatus makeResident(Device *device, ArrayRef<GraphicsAllocation *> gfxAllocations) override;
+    MemoryOperationsStatus lock(Device *device, ArrayRef<GraphicsAllocation *> gfxAllocations) override;
     MemoryOperationsStatus isResident(Device *device, GraphicsAllocation &gfxAllocation) override;
     MemoryOperationsStatus evictWithinOsContext(OsContext *osContext, GraphicsAllocation &gfxAllocation) override;
     MemoryOperationsStatus evict(Device *device, GraphicsAllocation &gfxAllocation) override;