diff --git a/level_zero/core/source/memory/cpu_page_fault_memory_manager.cpp b/level_zero/core/source/memory/cpu_page_fault_memory_manager.cpp
index 862860d93e..5053cc6101 100644
--- a/level_zero/core/source/memory/cpu_page_fault_memory_manager.cpp
+++ b/level_zero/core/source/memory/cpu_page_fault_memory_manager.cpp
@@ -6,8 +6,6 @@
  */
 
 #include "shared/source/debug_settings/debug_settings_manager.h"
-#include "shared/source/execution_environment/root_device_environment.h"
-#include "shared/source/os_interface/os_interface.h"
 #include "shared/source/page_fault_manager/cpu_page_fault_manager.h"
 
 #include "level_zero/core/source/cmdlist/cmdlist.h"
@@ -42,14 +40,6 @@ void PageFaultManager::transferToGpu(void *ptr, void *device) {
 
     this->evictMemoryAfterImplCopy(allocData->cpuAllocation, deviceImp->getNEODevice());
 }
-void PageFaultManager::allowCPUMemoryEviction(void *ptr, PageFaultData &pageFaultData) {
-    L0::DeviceImp *deviceImp = static_cast<L0::DeviceImp *>(pageFaultData.cmdQ);
-
-    auto csr = deviceImp->getActiveDevice()->getInternalCopyEngine()->commandStreamReceiver;
-    auto osInterface = deviceImp->getNEODevice()->getRootDeviceEnvironment().osInterface.get();
-
-    allowCPUMemoryEvictionImpl(ptr, csr, osInterface);
-}
 } // namespace NEO
 
 namespace L0 {
diff --git a/opencl/source/memory_manager/cpu_page_fault_manager_memory_sync.cpp b/opencl/source/memory_manager/cpu_page_fault_manager_memory_sync.cpp
index c3abccd69c..803260ad8a 100644
--- a/opencl/source/memory_manager/cpu_page_fault_manager_memory_sync.cpp
+++ b/opencl/source/memory_manager/cpu_page_fault_manager_memory_sync.cpp
@@ -5,15 +5,11 @@
  *
  */
 
-#include "shared/source/device/device.h"
-#include "shared/source/execution_environment/root_device_environment.h"
 #include "shared/source/helpers/debug_helpers.h"
 #include "shared/source/memory_manager/unified_memory_manager.h"
-#include "shared/source/os_interface/os_interface.h"
 #include "shared/source/page_fault_manager/cpu_page_fault_manager.h"
 
 #include "opencl/source/command_queue/command_queue.h"
-#include "opencl/source/command_queue/csr_selection_args.h"
 
 namespace NEO {
 void PageFaultManager::transferToCpu(void *ptr, size_t size, void *cmdQ) {
@@ -30,19 +26,6 @@ void PageFaultManager::transferToGpu(void *ptr, void *cmdQ) {
     UNRECOVERABLE_IF(retVal);
 
     auto allocData = memoryData[ptr].unifiedMemoryManager->getSVMAlloc(ptr);
-    UNRECOVERABLE_IF(allocData == nullptr);
     this->evictMemoryAfterImplCopy(allocData->cpuAllocation, &commandQueue->getDevice());
 }
-void PageFaultManager::allowCPUMemoryEviction(void *ptr, PageFaultData &pageFaultData) {
-    auto commandQueue = static_cast<CommandQueue *>(pageFaultData.cmdQ);
-
-    auto allocData = memoryData[ptr].unifiedMemoryManager->getSVMAlloc(ptr);
-    UNRECOVERABLE_IF(allocData == nullptr);
-    CsrSelectionArgs csrSelectionArgs{CL_COMMAND_READ_BUFFER, &allocData->gpuAllocations, {}, commandQueue->getDevice().getRootDeviceIndex(), nullptr};
-    auto &csr = commandQueue->selectCsrForBuiltinOperation(csrSelectionArgs);
-    auto osInterface = commandQueue->getDevice().getRootDeviceEnvironment().osInterface.get();
-
-    allowCPUMemoryEvictionImpl(ptr, &csr, osInterface);
-}
-
 } // namespace NEO
diff --git a/shared/source/page_fault_manager/cpu_page_fault_manager.cpp b/shared/source/page_fault_manager/cpu_page_fault_manager.cpp
index c9390c1a25..262c6668c3 100644
--- a/shared/source/page_fault_manager/cpu_page_fault_manager.cpp
+++ b/shared/source/page_fault_manager/cpu_page_fault_manager.cpp
@@ -113,7 +113,6 @@ void PageFaultManager::transferAndUnprotectMemory(PageFaultManager *pageFaultHan
     pageFaultHandler->migrateStorageToCpuDomain(allocPtr, pageFaultData);
     pageFaultHandler->allowCPUMemoryAccess(allocPtr, pageFaultData.size);
     pageFaultHandler->setCpuAllocEvictable(true, allocPtr, pageFaultData.unifiedMemoryManager);
-    pageFaultHandler->allowCPUMemoryEviction(allocPtr, pageFaultData);
 }
 
 void PageFaultManager::unprotectAndTransferMemory(PageFaultManager *pageFaultHandler, void *allocPtr, PageFaultData &pageFaultData) {
diff --git a/shared/source/page_fault_manager/cpu_page_fault_manager.h b/shared/source/page_fault_manager/cpu_page_fault_manager.h
index 83ddeee1ef..9f18dc783a 100644
--- a/shared/source/page_fault_manager/cpu_page_fault_manager.h
+++ b/shared/source/page_fault_manager/cpu_page_fault_manager.h
@@ -15,11 +15,9 @@
 
 namespace NEO {
 struct MemoryProperties;
-class CommandStreamReceiver;
 class GraphicsAllocation;
 class Device;
 class SVMAllocsManager;
-class OSInterface;
 
 class PageFaultManager : public NonCopyableOrMovableClass {
   public:
@@ -55,13 +53,11 @@ class PageFaultManager : public NonCopyableOrMovableClass {
 
   protected:
     virtual void evictMemoryAfterImplCopy(GraphicsAllocation *allocation, Device *device) = 0;
-    virtual void allowCPUMemoryEvictionImpl(void *ptr, CommandStreamReceiver *csr, OSInterface *osInterface) = 0;
 
     MOCKABLE_VIRTUAL bool verifyPageFault(void *ptr);
     MOCKABLE_VIRTUAL void transferToGpu(void *ptr, void *cmdQ);
     MOCKABLE_VIRTUAL void setAubWritable(bool writable, void *ptr, SVMAllocsManager *unifiedMemoryManager);
     MOCKABLE_VIRTUAL void setCpuAllocEvictable(bool evictable, void *ptr, SVMAllocsManager *unifiedMemoryManager);
-    MOCKABLE_VIRTUAL void allowCPUMemoryEviction(void *ptr, PageFaultData &pageFaultData);
 
     static void transferAndUnprotectMemory(PageFaultManager *pageFaultHandler, void *alloc, PageFaultData &pageFaultData);
     static void unprotectAndTransferMemory(PageFaultManager *pageFaultHandler, void *alloc, PageFaultData &pageFaultData);
diff --git a/shared/source/page_fault_manager/linux/cpu_page_fault_manager_linux.cpp b/shared/source/page_fault_manager/linux/cpu_page_fault_manager_linux.cpp
index dfcb08bd66..274ea825f6 100644
--- a/shared/source/page_fault_manager/linux/cpu_page_fault_manager_linux.cpp
+++ b/shared/source/page_fault_manager/linux/cpu_page_fault_manager_linux.cpp
@@ -84,8 +84,6 @@ void PageFaultManagerLinux::evictMemoryAfterImplCopy(GraphicsAllocation *allocat
     if (evictMemoryAfterCopy) {
         device->getRootDeviceEnvironment().memoryOperationsInterface->evict(device, *allocation);
     }
-}
-
-void PageFaultManagerLinux::allowCPUMemoryEvictionImpl(void *ptr, CommandStreamReceiver *csr, OSInterface *osInterface) {}
+};
 
 } // namespace NEO
diff --git a/shared/source/page_fault_manager/linux/cpu_page_fault_manager_linux.h b/shared/source/page_fault_manager/linux/cpu_page_fault_manager_linux.h
index 6a6f3c4bbd..a64e39b10b 100644
--- a/shared/source/page_fault_manager/linux/cpu_page_fault_manager_linux.h
+++ b/shared/source/page_fault_manager/linux/cpu_page_fault_manager_linux.h
@@ -25,7 +25,6 @@ class PageFaultManagerLinux : public PageFaultManager {
     void protectCPUMemoryAccess(void *ptr, size_t size) override;
 
     void evictMemoryAfterImplCopy(GraphicsAllocation *allocation, Device *device) override;
-    void allowCPUMemoryEvictionImpl(void *ptr, CommandStreamReceiver *csr, OSInterface *osInterface) override;
 
     void callPreviousHandler(int signal, siginfo_t *info, void *context);
     bool previousHandlerRestored = false;
diff --git a/shared/source/page_fault_manager/windows/cpu_page_fault_manager_windows.cpp b/shared/source/page_fault_manager/windows/cpu_page_fault_manager_windows.cpp
index 007dde5938..6c375530be 100644
--- a/shared/source/page_fault_manager/windows/cpu_page_fault_manager_windows.cpp
+++ b/shared/source/page_fault_manager/windows/cpu_page_fault_manager_windows.cpp
@@ -7,12 +7,7 @@
 
 #include "shared/source/page_fault_manager/windows/cpu_page_fault_manager_windows.h"
 
-#include "shared/source/command_stream/command_stream_receiver.h"
-#include "shared/source/device/device.h"
 #include "shared/source/helpers/debug_helpers.h"
-#include "shared/source/memory_manager/unified_memory_manager.h"
-#include "shared/source/os_interface/os_interface.h"
-#include "shared/source/os_interface/windows/os_context_win.h"
 
 namespace NEO {
 std::unique_ptr<PageFaultManager> PageFaultManager::create() {
@@ -61,16 +56,4 @@ void PageFaultManagerWindows::protectCPUMemoryAccess(void *ptr, size_t size) {
 
 void PageFaultManagerWindows::evictMemoryAfterImplCopy(GraphicsAllocation *allocation, Device *device) {}
 
-void PageFaultManagerWindows::allowCPUMemoryEvictionImpl(void *ptr, CommandStreamReceiver *csr, OSInterface *osInterface) {
-    NEO::SvmAllocationData *allocData = memoryData[ptr].unifiedMemoryManager->getSVMAlloc(ptr);
-    UNRECOVERABLE_IF(allocData == nullptr);
-
-    if (osInterface) {
-        auto &residencyController = static_cast<OsContextWin *>(&csr->getOsContext())->getResidencyController();
-
-        auto lock = residencyController.acquireLock();
-        residencyController.addToTrimCandidateList(allocData->cpuAllocation);
-    }
-}
-
 } // namespace NEO
diff --git a/shared/source/page_fault_manager/windows/cpu_page_fault_manager_windows.h b/shared/source/page_fault_manager/windows/cpu_page_fault_manager_windows.h
index 7421e9e4fe..3fe0723f0e 100644
--- a/shared/source/page_fault_manager/windows/cpu_page_fault_manager_windows.h
+++ b/shared/source/page_fault_manager/windows/cpu_page_fault_manager_windows.h
@@ -26,7 +26,6 @@ class PageFaultManagerWindows : public PageFaultManager {
     void protectCPUMemoryAccess(void *ptr, size_t size) override;
 
     void evictMemoryAfterImplCopy(GraphicsAllocation *allocation, Device *device) override;
-    void allowCPUMemoryEvictionImpl(void *ptr, CommandStreamReceiver *csr, OSInterface *osInterface) override;
 
     static std::function<LONG(struct _EXCEPTION_POINTERS *exceptionInfo)> pageFaultHandler;
     PVOID previousHandler;
diff --git a/shared/test/common/mocks/mock_cpu_page_fault_manager.h b/shared/test/common/mocks/mock_cpu_page_fault_manager.h
index de58ffd744..ad618bb971 100644
--- a/shared/test/common/mocks/mock_cpu_page_fault_manager.h
+++ b/shared/test/common/mocks/mock_cpu_page_fault_manager.h
@@ -48,9 +48,6 @@ class MockPageFaultManager : public PageFaultManager {
         setCpuAllocEvictableCalled++;
         isCpuAllocEvictable = evictable;
     }
-    void allowCPUMemoryEviction(void *ptr, PageFaultData &pageFaultData) override {
-        allowCPUMemoryEvictionCalled++;
-    }
     void baseAubWritable(bool writable, void *ptr, SVMAllocsManager *unifiedMemoryManager) {
         PageFaultManager::setAubWritable(writable, ptr, unifiedMemoryManager);
     }
@@ -65,8 +62,6 @@ class MockPageFaultManager : public PageFaultManager {
     }
     void evictMemoryAfterImplCopy(GraphicsAllocation *allocation, Device *device) override {}
 
-    void allowCPUMemoryEvictionImpl(void *ptr, CommandStreamReceiver *csr, OSInterface *osInterface) override {}
-
     void *getHwHandlerAddress() {
         return reinterpret_cast<void *>(PageFaultManager::transferAndUnprotectMemory);
     }
@@ -85,7 +80,6 @@ class MockPageFaultManager : public PageFaultManager {
     int transferToGpuCalled = 0;
     int moveAllocationToGpuDomainCalled = 0;
     int setCpuAllocEvictableCalled = 0;
-    int allowCPUMemoryEvictionCalled = 0;
     void *transferToCpuAddress = nullptr;
     void *transferToGpuAddress = nullptr;
     void *allowedMemoryAccessAddress = nullptr;
diff --git a/shared/test/unit_test/page_fault_manager/cpu_page_fault_manager_tests.cpp b/shared/test/unit_test/page_fault_manager/cpu_page_fault_manager_tests.cpp
index c229b01df6..f88a460cee 100644
--- a/shared/test/unit_test/page_fault_manager/cpu_page_fault_manager_tests.cpp
+++ b/shared/test/unit_test/page_fault_manager/cpu_page_fault_manager_tests.cpp
@@ -649,14 +649,12 @@ TEST_F(PageFaultManagerTest, givenUnifiedMemoryAllocWhenMigratedBetweenCpuAndGpu
     EXPECT_EQ(pageFaultManager->transferToGpuCalled, 0);
     EXPECT_EQ(pageFaultManager->transferToCpuCalled, 0);
     EXPECT_EQ(pageFaultManager->setCpuAllocEvictableCalled, 0);
-    EXPECT_EQ(pageFaultManager->allowCPUMemoryEvictionCalled, 0);
     EXPECT_EQ(pageFaultManager->memoryData.size(), 1u);
     EXPECT_EQ(pageFaultManager->isCpuAllocEvictable, 1);
 
     pageFaultManager->moveAllocationToGpuDomain(ptr);
     EXPECT_EQ(pageFaultManager->moveAllocationToGpuDomainCalled, 1);
     EXPECT_EQ(pageFaultManager->setCpuAllocEvictableCalled, 1);
-    EXPECT_EQ(pageFaultManager->allowCPUMemoryEvictionCalled, 0);
     EXPECT_EQ(pageFaultManager->transferToGpuCalled, 1);
     EXPECT_EQ(pageFaultManager->protectMemoryCalled, 1);
     EXPECT_EQ(pageFaultManager->isCpuAllocEvictable, 0);
@@ -668,7 +666,6 @@ TEST_F(PageFaultManagerTest, givenUnifiedMemoryAllocWhenMigratedBetweenCpuAndGpu
     EXPECT_EQ(pageFaultManager->transferToCpuCalled, 1);
     EXPECT_EQ(pageFaultManager->allowMemoryAccessCalled, 1);
     EXPECT_EQ(pageFaultManager->setCpuAllocEvictableCalled, 2);
-    EXPECT_EQ(pageFaultManager->allowCPUMemoryEvictionCalled, 1);
     EXPECT_EQ(pageFaultManager->allowedMemoryAccessAddress, ptr);
     EXPECT_EQ(pageFaultManager->accessAllowedSize, 10u);
     EXPECT_EQ(pageFaultManager->isCpuAllocEvictable, 1);
diff --git a/shared/test/unit_test/ult_specific_config.cpp b/shared/test/unit_test/ult_specific_config.cpp
index 7f002e081b..279ddc86d0 100644
--- a/shared/test/unit_test/ult_specific_config.cpp
+++ b/shared/test/unit_test/ult_specific_config.cpp
@@ -25,8 +25,6 @@ void PageFaultManager::transferToCpu(void *ptr, size_t size, void *cmdQ) {
 }
 void PageFaultManager::transferToGpu(void *ptr, void *cmdQ) {
 }
-void PageFaultManager::allowCPUMemoryEviction(void *ptr, PageFaultData &pageFaultData) {
-}
 CompilerCacheConfig getDefaultCompilerCacheConfig() { return {}; }
 const char *getAdditionalBuiltinAsString(EBuiltInOps::Type builtin) { return nullptr; }