From 6c5d9a6ed7402175a13e579efc9e6309920e2c82 Mon Sep 17 00:00:00 2001 From: Compute-Runtime-Validation Date: Thu, 12 Dec 2024 11:11:42 +0100 Subject: [PATCH] Revert "feature: extend TBX page fault manager from CPU implementation" This reverts commit 51c0e80299f848f223b3d79af5f7775fd00b6c9b. Signed-off-by: Compute-Runtime-Validation --- level_zero/core/source/device/device_imp.h | 2 +- .../memory/cpu_page_fault_memory_manager.cpp | 12 +- .../sources/cmdlist/test_cmdlist_1.cpp | 26 ++-- .../cpu_page_fault_manager_memory_sync.cpp | 6 +- ...u_page_fault_manager_memory_sync_tests.cpp | 2 +- .../tbx_command_stream_receiver_hw.h | 8 +- .../tbx_command_stream_receiver_hw.inl | 65 ++-------- .../debug_settings/debug_settings_manager.h | 6 - shared/source/helpers/debug_helpers.cpp | 1 - .../source/memory_manager/memory_manager.cpp | 8 +- shared/source/memory_manager/memory_manager.h | 6 +- .../source/page_fault_manager/CMakeLists.txt | 2 - .../cpu_page_fault_manager.cpp | 49 +++----- .../cpu_page_fault_manager.h | 52 +++----- .../page_fault_manager/linux/CMakeLists.txt | 2 - .../linux/cpu_page_fault_manager_linux.cpp | 11 +- .../linux/cpu_page_fault_manager_linux.h | 5 +- .../linux/tbx_page_fault_manager_linux.cpp | 14 --- .../linux/tbx_page_fault_manager_linux.h | 17 --- .../tbx_page_fault_manager.cpp | 57 --------- .../tbx_page_fault_manager.h | 33 ------ .../page_fault_manager/windows/CMakeLists.txt | 2 - .../cpu_page_fault_manager_windows.cpp | 16 +-- .../windows/cpu_page_fault_manager_windows.h | 5 +- .../tbx_page_fault_manager_windows.cpp | 14 --- .../windows/tbx_page_fault_manager_windows.h | 20 ---- .../fixtures/tbx_command_stream_fixture.cpp | 3 - .../fixtures/tbx_command_stream_fixture.h | 3 - .../common/mocks/mock_allocation_properties.h | 1 - .../mocks/mock_cpu_page_fault_manager.h | 37 +++--- shared/test/common/mocks/mock_tbx_csr.h | 5 - .../tbx_command_stream_tests.cpp | 111 ------------------ .../debug_settings_manager_tests.cpp | 18 --- .../cpu_page_fault_manager_tests.cpp | 86 ++++---------- .../cpu_page_fault_manager_windows_tests.cpp | 2 +- shared/test/unit_test/ult_specific_config.cpp | 6 +- 36 files changed, 129 insertions(+), 584 deletions(-) delete mode 100644 shared/source/page_fault_manager/linux/tbx_page_fault_manager_linux.cpp delete mode 100644 shared/source/page_fault_manager/linux/tbx_page_fault_manager_linux.h delete mode 100644 shared/source/page_fault_manager/tbx_page_fault_manager.cpp delete mode 100644 shared/source/page_fault_manager/tbx_page_fault_manager.h delete mode 100644 shared/source/page_fault_manager/windows/tbx_page_fault_manager_windows.cpp delete mode 100644 shared/source/page_fault_manager/windows/tbx_page_fault_manager_windows.h diff --git a/level_zero/core/source/device/device_imp.h b/level_zero/core/source/device/device_imp.h index 09b68b16b0..d982478363 100644 --- a/level_zero/core/source/device/device_imp.h +++ b/level_zero/core/source/device/device_imp.h @@ -196,6 +196,6 @@ struct DeviceImp : public Device, NEO::NonCopyableOrMovableClass { std::unique_ptr debugSession; }; -void transferAndUnprotectMemoryWithHints(NEO::CpuPageFaultManager *pageFaultHandler, void *allocPtr, NEO::CpuPageFaultManager::PageFaultData &pageFaultData); +void transferAndUnprotectMemoryWithHints(NEO::PageFaultManager *pageFaultHandler, void *allocPtr, NEO::PageFaultManager::PageFaultData &pageFaultData); } // namespace L0 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 443e67fd72..674e19d8d6 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 @@ -16,7 +16,7 @@ #include "level_zero/core/source/driver/driver_handle_imp.h" namespace NEO { -void CpuPageFaultManager::transferToCpu(void *ptr, size_t size, void *device) { +void PageFaultManager::transferToCpu(void *ptr, size_t size, void *device) { L0::DeviceImp *deviceImp = static_cast(device); deviceImp->getNEODevice()->stopDirectSubmissionForCopyEngine(); @@ -29,7 +29,7 @@ void CpuPageFaultManager::transferToCpu(void *ptr, size_t size, void *device) { allocData->size, true); UNRECOVERABLE_IF(ret); } -void CpuPageFaultManager::transferToGpu(void *ptr, void *device) { +void PageFaultManager::transferToGpu(void *ptr, void *device) { L0::DeviceImp *deviceImp = static_cast(device); deviceImp->getNEODevice()->stopDirectSubmissionForCopyEngine(); @@ -44,7 +44,7 @@ void CpuPageFaultManager::transferToGpu(void *ptr, void *device) { this->evictMemoryAfterImplCopy(allocData->cpuAllocation, deviceImp->getNEODevice()); } -void CpuPageFaultManager::allowCPUMemoryEviction(bool evict, void *ptr, PageFaultData &pageFaultData) { +void PageFaultManager::allowCPUMemoryEviction(bool evict, void *ptr, PageFaultData &pageFaultData) { L0::DeviceImp *deviceImp = static_cast(pageFaultData.cmdQ); CommandStreamReceiver *csr = nullptr; @@ -61,9 +61,9 @@ void CpuPageFaultManager::allowCPUMemoryEviction(bool evict, void *ptr, PageFaul } // namespace NEO namespace L0 { -void transferAndUnprotectMemoryWithHints(NEO::CpuPageFaultManager *pageFaultHandler, void *allocPtr, NEO::CpuPageFaultManager::PageFaultData &pageFaultData) { +void transferAndUnprotectMemoryWithHints(NEO::PageFaultManager *pageFaultHandler, void *allocPtr, NEO::PageFaultManager::PageFaultData &pageFaultData) { bool migration = true; - if (pageFaultData.domain == NEO::CpuPageFaultManager::AllocationDomain::gpu) { + if (pageFaultData.domain == NEO::PageFaultManager::AllocationDomain::gpu) { L0::DeviceImp *deviceImp = static_cast(pageFaultData.cmdQ); NEO::SvmAllocationData *allocData = deviceImp->getDriverHandle()->getSvmAllocsManager()->getSVMAlloc(allocPtr); @@ -87,7 +87,7 @@ void transferAndUnprotectMemoryWithHints(NEO::CpuPageFaultManager *pageFaultHand } } if (migration) { - pageFaultData.domain = NEO::CpuPageFaultManager::AllocationDomain::cpu; + pageFaultData.domain = NEO::PageFaultManager::AllocationDomain::cpu; } pageFaultHandler->allowCPUMemoryAccess(allocPtr, pageFaultData.size); } diff --git a/level_zero/core/test/unit_tests/sources/cmdlist/test_cmdlist_1.cpp b/level_zero/core/test/unit_tests/sources/cmdlist/test_cmdlist_1.cpp index f630b0bb1c..8d3ebf3a56 100644 --- a/level_zero/core/test/unit_tests/sources/cmdlist/test_cmdlist_1.cpp +++ b/level_zero/core/test/unit_tests/sources/cmdlist/test_cmdlist_1.cpp @@ -545,9 +545,9 @@ TEST_F(CommandListMemAdvisePageFault, givenValidPtrAndPageFaultHandlerAndGpuDoma EXPECT_EQ(handlerWithHints, reinterpret_cast(mockPageFaultManager->gpuDomainHandler)); - NEO::CpuPageFaultManager::PageFaultData pageData; + NEO::PageFaultManager::PageFaultData pageData; pageData.cmdQ = deviceImp; - pageData.domain = NEO::CpuPageFaultManager::AllocationDomain::gpu; + pageData.domain = NEO::PageFaultManager::AllocationDomain::gpu; mockPageFaultManager->gpuDomainHandler(mockPageFaultManager, ptr, pageData); flags = deviceImp->memAdviseSharedAllocations[allocData]; EXPECT_EQ(1, flags.cpuMigrationBlocked); @@ -586,9 +586,9 @@ TEST_F(CommandListMemAdvisePageFault, givenValidPtrAndPageFaultHandlerAndGpuDoma EXPECT_EQ(handlerWithHints, reinterpret_cast(mockPageFaultManager->gpuDomainHandler)); - NEO::CpuPageFaultManager::PageFaultData pageData; + NEO::PageFaultManager::PageFaultData pageData; pageData.cmdQ = deviceImp; - pageData.domain = NEO::CpuPageFaultManager::AllocationDomain::gpu; + pageData.domain = NEO::PageFaultManager::AllocationDomain::gpu; pageData.unifiedMemoryManager = device->getDriverHandle()->getSvmAllocsManager(); EXPECT_EQ(0u, device->getDriverHandle()->getSvmAllocsManager()->nonGpuDomainAllocs.size()); mockPageFaultManager->gpuDomainHandler(mockPageFaultManager, ptr, pageData); @@ -661,9 +661,9 @@ TEST_F(CommandListMemAdvisePageFault, givenValidPtrAndPageFaultHandlerAndGpuDoma testing::internal::CaptureStdout(); // start capturing - NEO::CpuPageFaultManager::PageFaultData pageData; + NEO::PageFaultManager::PageFaultData pageData; pageData.cmdQ = deviceImp; - pageData.domain = NEO::CpuPageFaultManager::AllocationDomain::gpu; + pageData.domain = NEO::PageFaultManager::AllocationDomain::gpu; pageData.unifiedMemoryManager = device->getDriverHandle()->getSvmAllocsManager(); mockPageFaultManager->gpuDomainHandler(mockPageFaultManager, ptr, pageData); flags = deviceImp->memAdviseSharedAllocations[allocData]; @@ -715,9 +715,9 @@ TEST_F(CommandListMemAdvisePageFault, givenValidPtrAndPageFaultHandlerAndGpuDoma EXPECT_EQ(handlerWithHints, reinterpret_cast(mockPageFaultManager->gpuDomainHandler)); - NEO::CpuPageFaultManager::PageFaultData pageData; + NEO::PageFaultManager::PageFaultData pageData; pageData.cmdQ = deviceImp; - pageData.domain = NEO::CpuPageFaultManager::AllocationDomain::gpu; + pageData.domain = NEO::PageFaultManager::AllocationDomain::gpu; pageData.unifiedMemoryManager = device->getDriverHandle()->getSvmAllocsManager(); mockPageFaultManager->gpuDomainHandler(mockPageFaultManager, ptr, pageData); flags = deviceImp->memAdviseSharedAllocations[allocData]; @@ -762,9 +762,9 @@ TEST_F(CommandListMemAdvisePageFault, givenValidPtrAndPageFaultHandlerAndGpuDoma EXPECT_EQ(handlerWithHints, reinterpret_cast(mockPageFaultManager->gpuDomainHandler)); - NEO::CpuPageFaultManager::PageFaultData pageData; + NEO::PageFaultManager::PageFaultData pageData; pageData.cmdQ = deviceImp; - pageData.domain = NEO::CpuPageFaultManager::AllocationDomain::cpu; + pageData.domain = NEO::PageFaultManager::AllocationDomain::cpu; pageData.unifiedMemoryManager = device->getDriverHandle()->getSvmAllocsManager(); mockPageFaultManager->gpuDomainHandler(mockPageFaultManager, ptr, pageData); flags = deviceImp->memAdviseSharedAllocations[allocData]; @@ -809,9 +809,9 @@ TEST_F(CommandListMemAdvisePageFault, givenInvalidPtrAndPageFaultHandlerAndGpuDo EXPECT_EQ(handlerWithHints, reinterpret_cast(mockPageFaultManager->gpuDomainHandler)); - NEO::CpuPageFaultManager::PageFaultData pageData; + NEO::PageFaultManager::PageFaultData pageData; pageData.cmdQ = deviceImp; - pageData.domain = NEO::CpuPageFaultManager::AllocationDomain::gpu; + pageData.domain = NEO::PageFaultManager::AllocationDomain::gpu; pageData.unifiedMemoryManager = device->getDriverHandle()->getSvmAllocsManager(); void *alloc = reinterpret_cast(0x1); mockPageFaultManager->gpuDomainHandler(mockPageFaultManager, alloc, pageData); @@ -838,7 +838,7 @@ TEST_F(CommandListMemAdvisePageFault, givenUnifiedMemoryAllocWhenAllowCPUMemoryE L0::DeviceImp *deviceImp = static_cast((L0::Device::fromHandle(device))); - NEO::CpuPageFaultManager::PageFaultData pageData; + NEO::PageFaultManager::PageFaultData pageData; pageData.cmdQ = deviceImp; mockPageFaultManager->baseAllowCPUMemoryEviction(true, ptr, pageData); 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 94467e4ae7..e6a18b611f 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 @@ -16,14 +16,14 @@ #include "opencl/source/command_queue/csr_selection_args.h" namespace NEO { -void CpuPageFaultManager::transferToCpu(void *ptr, size_t size, void *cmdQ) { +void PageFaultManager::transferToCpu(void *ptr, size_t size, void *cmdQ) { auto commandQueue = static_cast(cmdQ); commandQueue->getDevice().stopDirectSubmissionForCopyEngine(); auto retVal = commandQueue->enqueueSVMMap(true, CL_MAP_WRITE, ptr, size, 0, nullptr, nullptr, false); UNRECOVERABLE_IF(retVal); } -void CpuPageFaultManager::transferToGpu(void *ptr, void *cmdQ) { +void PageFaultManager::transferToGpu(void *ptr, void *cmdQ) { auto commandQueue = static_cast(cmdQ); commandQueue->getDevice().stopDirectSubmissionForCopyEngine(); @@ -37,7 +37,7 @@ void CpuPageFaultManager::transferToGpu(void *ptr, void *cmdQ) { UNRECOVERABLE_IF(allocData == nullptr); this->evictMemoryAfterImplCopy(allocData->cpuAllocation, &commandQueue->getDevice()); } -void CpuPageFaultManager::allowCPUMemoryEviction(bool evict, void *ptr, PageFaultData &pageFaultData) { +void PageFaultManager::allowCPUMemoryEviction(bool evict, void *ptr, PageFaultData &pageFaultData) { auto commandQueue = static_cast(pageFaultData.cmdQ); auto allocData = memoryData[ptr].unifiedMemoryManager->getSVMAlloc(ptr); diff --git a/opencl/test/unit_test/memory_manager/cpu_page_fault_manager_memory_sync_tests.cpp b/opencl/test/unit_test/memory_manager/cpu_page_fault_manager_memory_sync_tests.cpp index 098e31b113..c00181be48 100644 --- a/opencl/test/unit_test/memory_manager/cpu_page_fault_manager_memory_sync_tests.cpp +++ b/opencl/test/unit_test/memory_manager/cpu_page_fault_manager_memory_sync_tests.cpp @@ -121,7 +121,7 @@ TEST_F(PageFaultManagerTest, givenUnifiedMemoryAllocWhenAllowCPUMemoryEvictionIs cmdQ->device = device.get(); pageFaultManager->insertAllocation(alloc, 256, svmAllocsManager.get(), cmdQ.get(), {}); - NEO::CpuPageFaultManager::PageFaultData pageData; + NEO::PageFaultManager::PageFaultData pageData; pageData.cmdQ = cmdQ.get(); pageFaultManager->baseAllowCPUMemoryEviction(true, alloc, pageData); diff --git a/shared/source/command_stream/tbx_command_stream_receiver_hw.h b/shared/source/command_stream/tbx_command_stream_receiver_hw.h index 8dd0cd60b7..02f3b3eb43 100644 --- a/shared/source/command_stream/tbx_command_stream_receiver_hw.h +++ b/shared/source/command_stream/tbx_command_stream_receiver_hw.h @@ -18,7 +18,6 @@ namespace NEO { class AubSubCaptureManager; class TbxStream; -class CpuPageFaultManager; template class TbxCommandStreamReceiverHw : public CommandStreamReceiverSimulatedHw { @@ -37,9 +36,6 @@ class TbxCommandStreamReceiverHw : public CommandStreamReceiverSimulatedHw::initAdditionalMMIO; using CommandStreamReceiverSimulatedCommonHw::aubManager; @@ -85,12 +81,10 @@ class TbxCommandStreamReceiverHw : public CommandStreamReceiverSimulatedHw subCaptureManager; uint32_t aubDeviceId; diff --git a/shared/source/command_stream/tbx_command_stream_receiver_hw.inl b/shared/source/command_stream/tbx_command_stream_receiver_hw.inl index 2a9a765f33..8998b9fe2d 100644 --- a/shared/source/command_stream/tbx_command_stream_receiver_hw.inl +++ b/shared/source/command_stream/tbx_command_stream_receiver_hw.inl @@ -26,22 +26,14 @@ #include "shared/source/helpers/gfx_core_helper.h" #include "shared/source/helpers/hw_info.h" #include "shared/source/helpers/ptr_math.h" -#include "shared/source/memory_manager/allocation_type.h" #include "shared/source/memory_manager/graphics_allocation.h" -#include "shared/source/memory_manager/memory_manager.h" #include "shared/source/os_interface/aub_memory_operations_handler.h" #include "shared/source/os_interface/product_helper.h" -#include "shared/source/page_fault_manager/tbx_page_fault_manager.h" #include namespace NEO { -template -CpuPageFaultManager *TbxCommandStreamReceiverHw::getTbxPageFaultManager() { - return this->getMemoryManager()->getPageFaultManager(); -} - template TbxCommandStreamReceiverHw::TbxCommandStreamReceiverHw(ExecutionEnvironment &executionEnvironment, uint32_t rootDeviceIndex, @@ -82,26 +74,6 @@ TbxCommandStreamReceiverHw::~TbxCommandStreamReceiverHw() { this->freeEngineInfo(gttRemap); } -template -void TbxCommandStreamReceiverHw::allowCPUMemoryAccessIfHostBuffer(AllocationType allocType, void *cpuAddress, size_t size) { - if (allocType == AllocationType::bufferHostMemory) { - auto faultManager = getTbxPageFaultManager(); - if (faultManager != nullptr) { - faultManager->allowCPUMemoryAccess(cpuAddress, size); - } - } -} - -template -void TbxCommandStreamReceiverHw::protectCPUMemoryAccessIfHostBuffer(AllocationType allocType, void *cpuAddress, size_t size) { - if (allocType == AllocationType::bufferHostMemory) { - auto faultManager = getTbxPageFaultManager(); - if (faultManager != nullptr) { - faultManager->protectCPUMemoryAccess(cpuAddress, size); - } - } -} - template void TbxCommandStreamReceiverHw::initializeEngine() { isEngineInitialized = true; @@ -459,32 +431,21 @@ void TbxCommandStreamReceiverHw::writeMemory(uint64_t gpuAddress, voi template bool TbxCommandStreamReceiverHw::writeMemory(GraphicsAllocation &gfxAllocation, bool isChunkCopy, uint64_t gpuVaChunkOffset, size_t chunkSize) { - uint64_t gpuAddress; - void *cpuAddress; - size_t size; - - if (!this->getParametersForMemory(gfxAllocation, gpuAddress, cpuAddress, size)) { - return false; - } - - auto allocType = gfxAllocation.getAllocationType(); - if (allocType == AllocationType::bufferHostMemory) { - auto faultManager = getTbxPageFaultManager(); - if (faultManager != nullptr) { - faultManager->insertAllocation(this, &gfxAllocation, cpuAddress, size); - } - } - if (!this->isTbxWritable(gfxAllocation)) { return false; } - this->allowCPUMemoryAccessIfHostBuffer(allocType, cpuAddress, size); - if (!isEngineInitialized) { initializeEngine(); } + uint64_t gpuAddress; + void *cpuAddress; + size_t size; + if (!this->getParametersForMemory(gfxAllocation, gpuAddress, cpuAddress, size)) { + return false; + } + if (aubManager) { this->writeMemoryWithAubManager(gfxAllocation, isChunkCopy, gpuVaChunkOffset, chunkSize); } else { @@ -499,7 +460,6 @@ bool TbxCommandStreamReceiverHw::writeMemory(GraphicsAllocation &gfxA if (AubHelper::isOneTimeAubWritableAllocationType(gfxAllocation.getAllocationType())) { this->setTbxWritable(false, gfxAllocation); } - this->protectCPUMemoryAccessIfHostBuffer(allocType, cpuAddress, size); return true; } @@ -573,7 +533,6 @@ void TbxCommandStreamReceiverHw::processEviction() { template SubmissionStatus TbxCommandStreamReceiverHw::processResidency(ResidencyContainer &allocationsForResidency, uint32_t handleId) { - for (auto &gfxAllocation : allocationsForResidency) { if (dumpTbxNonWritable) { this->setTbxWritable(true, *gfxAllocation); @@ -595,16 +554,12 @@ SubmissionStatus TbxCommandStreamReceiverHw::processResidency(Residen template void TbxCommandStreamReceiverHw::downloadAllocationTbx(GraphicsAllocation &gfxAllocation) { - uint64_t gpuAddress = 0; void *cpuAddress = nullptr; size_t size = 0; this->getParametersForMemory(gfxAllocation, gpuAddress, cpuAddress, size); - auto allocType = gfxAllocation.getAllocationType(); - this->allowCPUMemoryAccessIfHostBuffer(allocType, cpuAddress, size); - if (hardwareContextController) { hardwareContextController->readMemory(gpuAddress, cpuAddress, size, this->getMemoryBank(&gfxAllocation), gfxAllocation.getUsedPageSize()); @@ -716,12 +671,6 @@ void TbxCommandStreamReceiverHw::dumpAllocation(GraphicsAllocation &g template void TbxCommandStreamReceiverHw::removeDownloadAllocation(GraphicsAllocation *alloc) { auto lockCSR = this->obtainUniqueOwnership(); - this->allocationsForDownload.erase(alloc); - - auto faultManager = getTbxPageFaultManager(); - if (faultManager != nullptr) { - faultManager->removeAllocation(alloc); - } } } // namespace NEO diff --git a/shared/source/debug_settings/debug_settings_manager.h b/shared/source/debug_settings/debug_settings_manager.h index 90d6f8fc8c..13d4b39ae4 100644 --- a/shared/source/debug_settings/debug_settings_manager.h +++ b/shared/source/debug_settings/debug_settings_manager.h @@ -6,7 +6,6 @@ */ #pragma once -#include "shared/source/helpers/options.h" #include "shared/source/helpers/string.h" #include "shared/source/utilities/io_functions.h" @@ -162,11 +161,6 @@ class DebugSettingsManager { } } - inline bool isTbxMode() { - auto setCsr = flags.SetCommandStreamReceiver.get(); - return (setCsr == static_cast(CommandStreamReceiverType::tbx)) || (setCsr == static_cast(CommandStreamReceiverType::tbxWithAub)); - } - protected: std::unique_ptr readerImpl; bool isLoopAtDriverInitEnabled() const { diff --git a/shared/source/helpers/debug_helpers.cpp b/shared/source/helpers/debug_helpers.cpp index 76178bce11..8d924e6f31 100644 --- a/shared/source/helpers/debug_helpers.cpp +++ b/shared/source/helpers/debug_helpers.cpp @@ -9,7 +9,6 @@ #include "shared/source/debug_settings/debug_settings_manager.h" #include "shared/source/helpers/abort.h" -#include "shared/source/helpers/options.h" #include #include diff --git a/shared/source/memory_manager/memory_manager.cpp b/shared/source/memory_manager/memory_manager.cpp index c762036743..2b66c0c8cc 100644 --- a/shared/source/memory_manager/memory_manager.cpp +++ b/shared/source/memory_manager/memory_manager.cpp @@ -83,11 +83,9 @@ MemoryManager::MemoryManager(ExecutionEnvironment &executionEnvironment) : execu localMemAllocsSize[rootDeviceIndex].store(0u); } - if (anyLocalMemorySupported || debugManager.isTbxMode()) { - pageFaultManager = CpuPageFaultManager::create(); - if (anyLocalMemorySupported) { - prefetchManager = PrefetchManager::create(); - } + if (anyLocalMemorySupported) { + pageFaultManager = PageFaultManager::create(); + prefetchManager = PrefetchManager::create(); } if (debugManager.flags.EnableMultiStorageResources.get() != -1) { diff --git a/shared/source/memory_manager/memory_manager.h b/shared/source/memory_manager/memory_manager.h index 3c94d4f5b1..ac7bdb0a05 100644 --- a/shared/source/memory_manager/memory_manager.h +++ b/shared/source/memory_manager/memory_manager.h @@ -29,7 +29,7 @@ namespace NEO { using SubDeviceIdsVec = StackVec; class MultiGraphicsAllocation; -class CpuPageFaultManager; +class PageFaultManager; class GfxPartition; struct ImageInfo; struct AllocationData; @@ -192,7 +192,7 @@ class MemoryManager { return deferredDeleter.get(); } - MOCKABLE_VIRTUAL CpuPageFaultManager *getPageFaultManager() const { + PageFaultManager *getPageFaultManager() const { return pageFaultManager.get(); } @@ -410,7 +410,7 @@ class MemoryManager { std::vector> internalLocalMemoryUsageBankSelector; std::vector> externalLocalMemoryUsageBankSelector; void *reservedMemory = nullptr; - std::unique_ptr pageFaultManager; + std::unique_ptr pageFaultManager; std::unique_ptr prefetchManager; OSMemory::ReservedCpuAddressRange reservedCpuAddressRange; std::vector> heapAssigners; diff --git a/shared/source/page_fault_manager/CMakeLists.txt b/shared/source/page_fault_manager/CMakeLists.txt index 3e592b73b3..f935d0f979 100644 --- a/shared/source/page_fault_manager/CMakeLists.txt +++ b/shared/source/page_fault_manager/CMakeLists.txt @@ -8,8 +8,6 @@ set(NEO_CORE_PAGE_FAULT_MANAGER ${CMAKE_CURRENT_SOURCE_DIR}/CMakeLists.txt ${CMAKE_CURRENT_SOURCE_DIR}/cpu_page_fault_manager.cpp ${CMAKE_CURRENT_SOURCE_DIR}/cpu_page_fault_manager.h - ${CMAKE_CURRENT_SOURCE_DIR}/tbx_page_fault_manager.cpp - ${CMAKE_CURRENT_SOURCE_DIR}/tbx_page_fault_manager.h ) set_property(GLOBAL PROPERTY NEO_CORE_PAGE_FAULT_MANAGER ${NEO_CORE_PAGE_FAULT_MANAGER}) 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 44c6e21b81..1945950e44 100644 --- a/shared/source/page_fault_manager/cpu_page_fault_manager.cpp +++ b/shared/source/page_fault_manager/cpu_page_fault_manager.cpp @@ -16,26 +16,19 @@ #include namespace NEO { - -void CpuPageFaultManager::insertAllocation(void *ptr, size_t size, SVMAllocsManager *unifiedMemoryManager, void *cmdQ, const MemoryProperties &memoryProperties) { +void PageFaultManager::insertAllocation(void *ptr, size_t size, SVMAllocsManager *unifiedMemoryManager, void *cmdQ, const MemoryProperties &memoryProperties) { auto initialPlacement = MemoryPropertiesHelper::getUSMInitialPlacement(memoryProperties); const auto domain = (initialPlacement == GraphicsAllocation::UsmInitialPlacement::CPU) ? AllocationDomain::cpu : AllocationDomain::none; std::unique_lock lock{mtx}; - PageFaultData faultData{}; - faultData.faultType = FaultMode::cpu; - faultData.size = size; - faultData.unifiedMemoryManager = unifiedMemoryManager; - faultData.cmdQ = cmdQ; - faultData.domain = domain; - this->memoryData.insert(std::make_pair(ptr, faultData)); + this->memoryData.insert(std::make_pair(ptr, PageFaultData{size, unifiedMemoryManager, cmdQ, domain})); if (initialPlacement != GraphicsAllocation::UsmInitialPlacement::CPU) { this->protectCPUMemoryAccess(ptr, size); } unifiedMemoryManager->nonGpuDomainAllocs.push_back(ptr); } -void CpuPageFaultManager::removeAllocation(void *ptr) { +void PageFaultManager::removeAllocation(void *ptr) { std::unique_lock lock{mtx}; auto alloc = memoryData.find(ptr); if (alloc != memoryData.end()) { @@ -52,7 +45,7 @@ void CpuPageFaultManager::removeAllocation(void *ptr) { } } -void CpuPageFaultManager::moveAllocationToGpuDomain(void *ptr) { +void PageFaultManager::moveAllocationToGpuDomain(void *ptr) { std::unique_lock lock{mtx}; auto alloc = memoryData.find(ptr); if (alloc != memoryData.end()) { @@ -68,7 +61,7 @@ void CpuPageFaultManager::moveAllocationToGpuDomain(void *ptr) { } } -void CpuPageFaultManager::moveAllocationsWithinUMAllocsManagerToGpuDomain(SVMAllocsManager *unifiedMemoryManager) { +void PageFaultManager::moveAllocationsWithinUMAllocsManagerToGpuDomain(SVMAllocsManager *unifiedMemoryManager) { std::unique_lock lock{mtx}; for (auto allocPtr : unifiedMemoryManager->nonGpuDomainAllocs) { auto &pageFaultData = this->memoryData[allocPtr]; @@ -77,7 +70,7 @@ void CpuPageFaultManager::moveAllocationsWithinUMAllocsManagerToGpuDomain(SVMAll unifiedMemoryManager->nonGpuDomainAllocs.clear(); } -inline void CpuPageFaultManager::migrateStorageToGpuDomain(void *ptr, PageFaultData &pageFaultData) { +inline void PageFaultManager::migrateStorageToGpuDomain(void *ptr, PageFaultData &pageFaultData) { if (pageFaultData.domain == AllocationDomain::cpu) { this->setCpuAllocEvictable(false, ptr, pageFaultData.unifiedMemoryManager); this->allowCPUMemoryEviction(false, ptr, pageFaultData); @@ -103,19 +96,15 @@ inline void CpuPageFaultManager::migrateStorageToGpuDomain(void *ptr, PageFaultD pageFaultData.domain = AllocationDomain::gpu; } -void CpuPageFaultManager::handlePageFault(void *ptr, PageFaultData &faultData) { - this->setAubWritable(true, ptr, faultData.unifiedMemoryManager); - gpuDomainHandler(this, ptr, faultData); -} - -bool CpuPageFaultManager::verifyAndHandlePageFault(void *ptr, bool handleFault) { +bool PageFaultManager::verifyAndHandlePageFault(void *ptr, bool handlePageFault) { std::unique_lock lock{mtx}; - for (auto &alloc : memoryData) { + for (auto &alloc : this->memoryData) { auto allocPtr = alloc.first; auto &pageFaultData = alloc.second; if (ptr >= allocPtr && ptr < ptrOffset(allocPtr, pageFaultData.size)) { - if (handleFault) { - handlePageFault(allocPtr, pageFaultData); + if (handlePageFault) { + this->setAubWritable(true, allocPtr, pageFaultData.unifiedMemoryManager); + gpuDomainHandler(this, allocPtr, pageFaultData); } return true; } @@ -123,23 +112,23 @@ bool CpuPageFaultManager::verifyAndHandlePageFault(void *ptr, bool handleFault) return false; } -void CpuPageFaultManager::setGpuDomainHandler(gpuDomainHandlerFunc gpuHandlerFuncPtr) { +void PageFaultManager::setGpuDomainHandler(gpuDomainHandlerFunc gpuHandlerFuncPtr) { this->gpuDomainHandler = gpuHandlerFuncPtr; } -void CpuPageFaultManager::transferAndUnprotectMemory(CpuPageFaultManager *pageFaultHandler, void *allocPtr, PageFaultData &pageFaultData) { +void PageFaultManager::transferAndUnprotectMemory(PageFaultManager *pageFaultHandler, void *allocPtr, PageFaultData &pageFaultData) { pageFaultHandler->migrateStorageToCpuDomain(allocPtr, pageFaultData); pageFaultHandler->allowCPUMemoryAccess(allocPtr, pageFaultData.size); pageFaultHandler->setCpuAllocEvictable(true, allocPtr, pageFaultData.unifiedMemoryManager); pageFaultHandler->allowCPUMemoryEviction(true, allocPtr, pageFaultData); } -void CpuPageFaultManager::unprotectAndTransferMemory(CpuPageFaultManager *pageFaultHandler, void *allocPtr, PageFaultData &pageFaultData) { +void PageFaultManager::unprotectAndTransferMemory(PageFaultManager *pageFaultHandler, void *allocPtr, PageFaultData &pageFaultData) { pageFaultHandler->allowCPUMemoryAccess(allocPtr, pageFaultData.size); pageFaultHandler->migrateStorageToCpuDomain(allocPtr, pageFaultData); } -inline void CpuPageFaultManager::migrateStorageToCpuDomain(void *ptr, PageFaultData &pageFaultData) { +inline void PageFaultManager::migrateStorageToCpuDomain(void *ptr, PageFaultData &pageFaultData) { if (pageFaultData.domain == AllocationDomain::gpu) { std::chrono::steady_clock::time_point start; std::chrono::steady_clock::time_point end; @@ -155,19 +144,19 @@ inline void CpuPageFaultManager::migrateStorageToCpuDomain(void *ptr, PageFaultD pageFaultData.domain = AllocationDomain::cpu; } -void CpuPageFaultManager::selectGpuDomainHandler() { +void PageFaultManager::selectGpuDomainHandler() { if (debugManager.flags.SetCommandStreamReceiver.get() > static_cast(CommandStreamReceiverType::hardware) || debugManager.flags.NEO_CAL_ENABLED.get()) { - this->gpuDomainHandler = &CpuPageFaultManager::unprotectAndTransferMemory; + this->gpuDomainHandler = &PageFaultManager::unprotectAndTransferMemory; } } -void CpuPageFaultManager::setAubWritable(bool writable, void *ptr, SVMAllocsManager *unifiedMemoryManager) { +void PageFaultManager::setAubWritable(bool writable, void *ptr, SVMAllocsManager *unifiedMemoryManager) { UNRECOVERABLE_IF(ptr == nullptr); auto gpuAlloc = unifiedMemoryManager->getSVMAlloc(ptr)->gpuAllocations.getDefaultGraphicsAllocation(); gpuAlloc->setAubWritable(writable, GraphicsAllocation::allBanks); } -void CpuPageFaultManager::setCpuAllocEvictable(bool evictable, void *ptr, SVMAllocsManager *unifiedMemoryManager) { +void PageFaultManager::setCpuAllocEvictable(bool evictable, void *ptr, SVMAllocsManager *unifiedMemoryManager) { UNRECOVERABLE_IF(ptr == nullptr); auto cpuAlloc = unifiedMemoryManager->getSVMAlloc(ptr)->cpuAllocation; cpuAlloc->setEvictable(evictable); 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 7fba7f7cad..3b3a34f14b 100644 --- a/shared/source/page_fault_manager/cpu_page_fault_manager.h +++ b/shared/source/page_fault_manager/cpu_page_fault_manager.h @@ -21,26 +21,16 @@ class Device; class SVMAllocsManager; class OSInterface; -class CpuPageFaultManager : public NonCopyableClass { +class PageFaultManager : public NonCopyableOrMovableClass { public: - static std::unique_ptr create(); + static std::unique_ptr create(); - virtual ~CpuPageFaultManager() = default; - - virtual void allowCPUMemoryAccess(void *ptr, size_t size) = 0; - virtual void protectCPUMemoryAccess(void *ptr, size_t size) = 0; + virtual ~PageFaultManager() = default; MOCKABLE_VIRTUAL void moveAllocationToGpuDomain(void *ptr); MOCKABLE_VIRTUAL void moveAllocationsWithinUMAllocsManagerToGpuDomain(SVMAllocsManager *unifiedMemoryManager); void insertAllocation(void *ptr, size_t size, SVMAllocsManager *unifiedMemoryManager, void *cmdQ, const MemoryProperties &memoryProperties); void removeAllocation(void *ptr); - virtual void insertAllocation(CommandStreamReceiver *csr, GraphicsAllocation *alloc, void *ptr, size_t size) {} - virtual void removeAllocation(GraphicsAllocation *alloc) {} - - enum class FaultMode { - cpu, - tbx - }; enum class AllocationDomain { none, @@ -49,49 +39,39 @@ class CpuPageFaultManager : public NonCopyableClass { }; struct PageFaultData { - FaultMode faultType = FaultMode::cpu; - size_t size = 0; - - // cpu fault data - SVMAllocsManager *unifiedMemoryManager = nullptr; - void *cmdQ = nullptr; - AllocationDomain domain = AllocationDomain::none; - - // tbx fault data - GraphicsAllocation *gfxAllocation = nullptr; - CommandStreamReceiver *csr = nullptr; + size_t size; + SVMAllocsManager *unifiedMemoryManager; + void *cmdQ; + AllocationDomain domain; }; - typedef void (*gpuDomainHandlerFunc)(CpuPageFaultManager *pageFaultHandler, void *alloc, PageFaultData &pageFaultData); + typedef void (*gpuDomainHandlerFunc)(PageFaultManager *pageFaultHandler, void *alloc, PageFaultData &pageFaultData); void setGpuDomainHandler(gpuDomainHandlerFunc gpuHandlerFuncPtr); + virtual void allowCPUMemoryAccess(void *ptr, size_t size) = 0; + virtual void protectCPUMemoryAccess(void *ptr, size_t size) = 0; MOCKABLE_VIRTUAL void transferToCpu(void *ptr, size_t size, void *cmdQ); protected: + virtual bool checkFaultHandlerFromPageFaultManager() = 0; + virtual void registerFaultHandler() = 0; virtual void evictMemoryAfterImplCopy(GraphicsAllocation *allocation, Device *device) = 0; virtual void allowCPUMemoryEvictionImpl(bool evict, void *ptr, CommandStreamReceiver &csr, OSInterface *osInterface) = 0; - virtual bool checkFaultHandlerFromPageFaultManager() = 0; - virtual void registerFaultHandler() = 0; - - virtual bool verifyAndHandlePageFault(void *ptr, bool handlePageFault); - - virtual void handlePageFault(void *ptr, PageFaultData &faultData); - + MOCKABLE_VIRTUAL bool verifyAndHandlePageFault(void *ptr, bool handlePageFault); 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(bool evict, void *ptr, PageFaultData &pageFaultData); - static void transferAndUnprotectMemory(CpuPageFaultManager *pageFaultHandler, void *alloc, PageFaultData &pageFaultData); - static void unprotectAndTransferMemory(CpuPageFaultManager *pageFaultHandler, void *alloc, PageFaultData &pageFaultData); + static void transferAndUnprotectMemory(PageFaultManager *pageFaultHandler, void *alloc, PageFaultData &pageFaultData); + static void unprotectAndTransferMemory(PageFaultManager *pageFaultHandler, void *alloc, PageFaultData &pageFaultData); void selectGpuDomainHandler(); inline void migrateStorageToGpuDomain(void *ptr, PageFaultData &pageFaultData); inline void migrateStorageToCpuDomain(void *ptr, PageFaultData &pageFaultData); - using gpuDomainHandlerType = decltype(&transferAndUnprotectMemory); - gpuDomainHandlerType gpuDomainHandler = &transferAndUnprotectMemory; + decltype(&transferAndUnprotectMemory) gpuDomainHandler = &transferAndUnprotectMemory; std::unordered_map memoryData; SpinLock mtx; diff --git a/shared/source/page_fault_manager/linux/CMakeLists.txt b/shared/source/page_fault_manager/linux/CMakeLists.txt index b02f47e574..2e4ecc7566 100644 --- a/shared/source/page_fault_manager/linux/CMakeLists.txt +++ b/shared/source/page_fault_manager/linux/CMakeLists.txt @@ -8,8 +8,6 @@ set(NEO_CORE_PAGE_FAULT_MANAGER_LINUX ${CMAKE_CURRENT_SOURCE_DIR}/CMakeLists.txt ${CMAKE_CURRENT_SOURCE_DIR}/cpu_page_fault_manager_linux.cpp ${CMAKE_CURRENT_SOURCE_DIR}/cpu_page_fault_manager_linux.h - ${CMAKE_CURRENT_SOURCE_DIR}/tbx_page_fault_manager_linux.cpp - ${CMAKE_CURRENT_SOURCE_DIR}/tbx_page_fault_manager_linux.h ) set_property(GLOBAL PROPERTY NEO_CORE_PAGE_FAULT_MANAGER_LINUX ${NEO_CORE_PAGE_FAULT_MANAGER_LINUX}) 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 c7f626286c..12f64c3686 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 @@ -10,20 +10,15 @@ #include "shared/source/debug_settings/debug_settings_manager.h" #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/memory_operations_handler.h" -#include "shared/source/page_fault_manager/linux/tbx_page_fault_manager_linux.h" #include #include namespace NEO { -std::unique_ptr CpuPageFaultManager::create() { - auto pageFaultManager = [&]() -> std::unique_ptr { - if (debugManager.isTbxMode()) { - return TbxPageFaultManager::create(); - } - return std::make_unique(); - }(); +std::unique_ptr PageFaultManager::create() { + auto pageFaultManager = std::make_unique(); pageFaultManager->selectGpuDomainHandler(); return pageFaultManager; 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 a714bd02de..adfbd2fcf0 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 @@ -14,7 +14,7 @@ #include namespace NEO { -class PageFaultManagerLinux : public virtual CpuPageFaultManager { +class PageFaultManagerLinux : public PageFaultManager { public: PageFaultManagerLinux(); ~PageFaultManagerLinux() override; @@ -41,7 +41,4 @@ class PageFaultManagerLinux : public virtual CpuPageFaultManager { bool evictMemoryAfterCopy = false; int handlerIndex = 0; }; - -class CpuPageFaultManagerLinux final : public PageFaultManagerLinux {}; - } // namespace NEO diff --git a/shared/source/page_fault_manager/linux/tbx_page_fault_manager_linux.cpp b/shared/source/page_fault_manager/linux/tbx_page_fault_manager_linux.cpp deleted file mode 100644 index e6bb24885a..0000000000 --- a/shared/source/page_fault_manager/linux/tbx_page_fault_manager_linux.cpp +++ /dev/null @@ -1,14 +0,0 @@ -/* - * Copyright (C) 2019-2024 Intel Corporation - * - * SPDX-License-Identifier: MIT - * - */ - -#include "shared/source/page_fault_manager/linux/tbx_page_fault_manager_linux.h" - -namespace NEO { -std::unique_ptr TbxPageFaultManager::create() { - return std::make_unique(); -} -} // namespace NEO diff --git a/shared/source/page_fault_manager/linux/tbx_page_fault_manager_linux.h b/shared/source/page_fault_manager/linux/tbx_page_fault_manager_linux.h deleted file mode 100644 index 6d02e4ece9..0000000000 --- a/shared/source/page_fault_manager/linux/tbx_page_fault_manager_linux.h +++ /dev/null @@ -1,17 +0,0 @@ -/* - * Copyright (C) 2024 Intel Corporation - * - * SPDX-License-Identifier: MIT - * - */ - -#pragma once - -#include "shared/source/page_fault_manager/linux/cpu_page_fault_manager_linux.h" -#include "shared/source/page_fault_manager/tbx_page_fault_manager.h" - -namespace NEO { - -class TbxPageFaultManagerLinux final : public TbxPageFaultManager, public PageFaultManagerLinux {}; - -} // namespace NEO diff --git a/shared/source/page_fault_manager/tbx_page_fault_manager.cpp b/shared/source/page_fault_manager/tbx_page_fault_manager.cpp deleted file mode 100644 index c976604374..0000000000 --- a/shared/source/page_fault_manager/tbx_page_fault_manager.cpp +++ /dev/null @@ -1,57 +0,0 @@ -/* - * Copyright (C) 2024 Intel Corporation - * - * SPDX-License-Identifier: MIT - * - */ - -#include "shared/source/page_fault_manager/tbx_page_fault_manager.h" - -#include "shared/source/command_stream/command_stream_receiver.h" -#include "shared/source/memory_manager/graphics_allocation.h" -#include "shared/source/page_fault_manager/cpu_page_fault_manager.h" - -namespace NEO { - -void TbxPageFaultManager::handlePageFault(void *ptr, PageFaultData &faultData) { - if (faultData.faultType == FaultMode::cpu) { - CpuPageFaultManager::handlePageFault(ptr, faultData); - return; - } - unprotectAndTransferMemoryTbx(this, ptr, faultData); -} - -void TbxPageFaultManager::unprotectAndTransferMemoryTbx(TbxPageFaultManager *pageFaultHandler, void *allocPtr, PageFaultData &pageFaultData) { - pageFaultHandler->allowCPUMemoryAccess(allocPtr, pageFaultData.size); - pageFaultData.csr->downloadAllocation(*pageFaultData.gfxAllocation); - pageFaultData.gfxAllocation->setTbxWritable(true, GraphicsAllocation::allBanks); -} - -void TbxPageFaultManager::removeAllocation(GraphicsAllocation *alloc) { - std::unique_lock lock{mtx}; - for (auto &data : memoryData) { - auto allocPtr = data.first; - auto faultData = data.second; - if (faultData.gfxAllocation == alloc) { - memoryData.erase(allocPtr); - this->allowCPUMemoryAccess(allocPtr, faultData.size); - return; - } - } -} - -void TbxPageFaultManager::insertAllocation(CommandStreamReceiver *csr, GraphicsAllocation *alloc, void *ptr, size_t size) { - std::unique_lock lock{mtx}; - - if (memoryData.find(ptr) == memoryData.end()) { - PageFaultData pageFaultData{}; - pageFaultData.faultType = FaultMode::tbx; - pageFaultData.size = size; - pageFaultData.gfxAllocation = alloc; - pageFaultData.csr = csr; - memoryData[ptr] = pageFaultData; - } - this->protectCPUMemoryAccess(ptr, size); -} - -} // namespace NEO diff --git a/shared/source/page_fault_manager/tbx_page_fault_manager.h b/shared/source/page_fault_manager/tbx_page_fault_manager.h deleted file mode 100644 index c6b46eda91..0000000000 --- a/shared/source/page_fault_manager/tbx_page_fault_manager.h +++ /dev/null @@ -1,33 +0,0 @@ -/* - * Copyright (C) 2024 Intel Corporation - * - * SPDX-License-Identifier: MIT - * - */ - -#pragma once - -#include "shared/source/page_fault_manager/cpu_page_fault_manager.h" - -namespace NEO { -class CommandStreamReceiver; -class GraphicsAllocation; - -class TbxPageFaultManager : public virtual CpuPageFaultManager { - public: - static std::unique_ptr create(); - - using CpuPageFaultManager::insertAllocation; - using CpuPageFaultManager::removeAllocation; - void insertAllocation(CommandStreamReceiver *csr, GraphicsAllocation *alloc, void *ptr, size_t size) override; - void removeAllocation(GraphicsAllocation *alloc) override; - - using CpuPageFaultManager::checkFaultHandlerFromPageFaultManager; - using CpuPageFaultManager::verifyAndHandlePageFault; - - protected: - void handlePageFault(void *ptr, PageFaultData &faultData) override; - static void unprotectAndTransferMemoryTbx(TbxPageFaultManager *pageFaultHandler, void *alloc, PageFaultData &pageFaultData); -}; - -} // namespace NEO diff --git a/shared/source/page_fault_manager/windows/CMakeLists.txt b/shared/source/page_fault_manager/windows/CMakeLists.txt index 370bc5035b..20754ea8b6 100644 --- a/shared/source/page_fault_manager/windows/CMakeLists.txt +++ b/shared/source/page_fault_manager/windows/CMakeLists.txt @@ -8,8 +8,6 @@ set(NEO_CORE_PAGE_FAULT_MANAGER_WINDOWS ${CMAKE_CURRENT_SOURCE_DIR}/CMakeLists.txt ${CMAKE_CURRENT_SOURCE_DIR}/cpu_page_fault_manager_windows.cpp ${CMAKE_CURRENT_SOURCE_DIR}/cpu_page_fault_manager_windows.h - ${CMAKE_CURRENT_SOURCE_DIR}/tbx_page_fault_manager_windows.cpp - ${CMAKE_CURRENT_SOURCE_DIR}/tbx_page_fault_manager_windows.h ) if(WIN32) 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 bf828f59d2..56911d0dec 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 @@ -8,27 +8,21 @@ #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/debug_settings/debug_settings_manager.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" -#include "shared/source/page_fault_manager/windows/tbx_page_fault_manager_windows.h" namespace NEO { -std::unique_ptr CpuPageFaultManager::create() { - auto pageFaultManager = [&]() -> std::unique_ptr { - if (debugManager.isTbxMode()) { - return TbxPageFaultManager::create(); - } - return std::make_unique(); - }(); +std::unique_ptr PageFaultManager::create() { + auto pageFaultManager = std::make_unique(); pageFaultManager->selectGpuDomainHandler(); return pageFaultManager; } -std::function PageFaultManagerWindows::pageFaultHandler = nullptr; +std::function PageFaultManagerWindows::pageFaultHandler; PageFaultManagerWindows::PageFaultManagerWindows() { PageFaultManagerWindows::registerFaultHandler(); @@ -76,7 +70,7 @@ void PageFaultManagerWindows::protectCPUMemoryAccess(void *ptr, size_t size) { void PageFaultManagerWindows::evictMemoryAfterImplCopy(GraphicsAllocation *allocation, Device *device) {} void PageFaultManagerWindows::allowCPUMemoryEvictionImpl(bool evict, void *ptr, CommandStreamReceiver &csr, OSInterface *osInterface) { - NEO::SvmAllocationData *allocData = this->memoryData[ptr].unifiedMemoryManager->getSVMAlloc(ptr); + NEO::SvmAllocationData *allocData = memoryData[ptr].unifiedMemoryManager->getSVMAlloc(ptr); UNRECOVERABLE_IF(allocData == nullptr); if (osInterface) { 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 a0b293cd00..5c183397bb 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 @@ -13,8 +13,7 @@ #include namespace NEO { - -class PageFaultManagerWindows : public virtual CpuPageFaultManager { +class PageFaultManagerWindows : public PageFaultManager { public: PageFaultManagerWindows(); ~PageFaultManagerWindows() override; @@ -35,6 +34,4 @@ class PageFaultManagerWindows : public virtual CpuPageFaultManager { PVOID previousHandler; }; -class CpuPageFaultManagerWindows final : public PageFaultManagerWindows {}; - } // namespace NEO diff --git a/shared/source/page_fault_manager/windows/tbx_page_fault_manager_windows.cpp b/shared/source/page_fault_manager/windows/tbx_page_fault_manager_windows.cpp deleted file mode 100644 index 1c35fa9ef6..0000000000 --- a/shared/source/page_fault_manager/windows/tbx_page_fault_manager_windows.cpp +++ /dev/null @@ -1,14 +0,0 @@ -/* - * Copyright (C) 2019-2024 Intel Corporation - * - * SPDX-License-Identifier: MIT - * - */ - -#include "shared/source/page_fault_manager/windows/tbx_page_fault_manager_windows.h" - -namespace NEO { -std::unique_ptr TbxPageFaultManager::create() { - return std::make_unique(); -} -} // namespace NEO diff --git a/shared/source/page_fault_manager/windows/tbx_page_fault_manager_windows.h b/shared/source/page_fault_manager/windows/tbx_page_fault_manager_windows.h deleted file mode 100644 index 0f82546de8..0000000000 --- a/shared/source/page_fault_manager/windows/tbx_page_fault_manager_windows.h +++ /dev/null @@ -1,20 +0,0 @@ -/* - * Copyright (C) 2024 Intel Corporation - * - * SPDX-License-Identifier: MIT - * - */ - -#pragma once - -#include "shared/source/page_fault_manager/tbx_page_fault_manager.h" -#include "shared/source/page_fault_manager/windows/cpu_page_fault_manager_windows.h" - -// Known false positive for valid virtual inheritance -#pragma warning(disable : 4250) - -namespace NEO { - -class TbxPageFaultManagerWindows final : public TbxPageFaultManager, public PageFaultManagerWindows {}; - -} // namespace NEO diff --git a/shared/test/common/fixtures/tbx_command_stream_fixture.cpp b/shared/test/common/fixtures/tbx_command_stream_fixture.cpp index 3fbc5199eb..7a024595a4 100644 --- a/shared/test/common/fixtures/tbx_command_stream_fixture.cpp +++ b/shared/test/common/fixtures/tbx_command_stream_fixture.cpp @@ -10,7 +10,6 @@ #include "shared/source/command_stream/command_stream_receiver.h" #include "shared/source/command_stream/tbx_command_stream_receiver_hw.h" #include "shared/source/memory_manager/os_agnostic_memory_manager.h" -#include "shared/test/common/helpers/debug_manager_state_restore.h" #include "shared/test/common/mocks/mock_device.h" #include "gtest/gtest.h" @@ -19,8 +18,6 @@ namespace NEO { void TbxCommandStreamFixture::setUp(MockDevice *pDevice) { // Create our TBX command stream receiver based on HW type - DebugManagerStateRestore dbgRestore; - debugManager.flags.SetCommandStreamReceiver.set(static_cast(CommandStreamReceiverType::tbx)); pCommandStreamReceiver = TbxCommandStreamReceiver::create("", false, *pDevice->executionEnvironment, pDevice->getRootDeviceIndex(), pDevice->getDeviceBitfield()); ASSERT_NE(nullptr, pCommandStreamReceiver); memoryManager = new OsAgnosticMemoryManager(*pDevice->executionEnvironment); diff --git a/shared/test/common/fixtures/tbx_command_stream_fixture.h b/shared/test/common/fixtures/tbx_command_stream_fixture.h index 632e12eb0a..147f39306a 100644 --- a/shared/test/common/fixtures/tbx_command_stream_fixture.h +++ b/shared/test/common/fixtures/tbx_command_stream_fixture.h @@ -7,9 +7,6 @@ #pragma once -#include "shared/source/memory_manager/os_agnostic_memory_manager.h" -#include "shared/source/page_fault_manager/cpu_page_fault_manager.h" - namespace NEO { class CommandStreamReceiver; diff --git a/shared/test/common/mocks/mock_allocation_properties.h b/shared/test/common/mocks/mock_allocation_properties.h index bdd833e640..3437559bc5 100644 --- a/shared/test/common/mocks/mock_allocation_properties.h +++ b/shared/test/common/mocks/mock_allocation_properties.h @@ -19,6 +19,5 @@ struct MockAllocationProperties : public AllocationProperties { MockAllocationProperties(uint32_t rootDeviceIndex, bool allocateMemory, size_t size, DeviceBitfield deviceBitfield) : AllocationProperties(rootDeviceIndex, allocateMemory, size, AllocationType::internalHostMemory, false, deviceBitfield) {} MockAllocationProperties(uint32_t rootDeviceIndex, bool allocateMemory, size_t size, AllocationType allocationType) : AllocationProperties(rootDeviceIndex, allocateMemory, size, allocationType, false, mockDeviceBitfield) {} MockAllocationProperties(uint32_t rootDeviceIndex, bool allocateMemory, size_t size, AllocationType allocationType, DeviceBitfield deviceBitfield) : AllocationProperties(rootDeviceIndex, allocateMemory, size, allocationType, false, deviceBitfield) {} - MockAllocationProperties(uint32_t rootDeviceIndex, AllocationType allocType, size_t size) : AllocationProperties(rootDeviceIndex, true, size, allocType, false, mockDeviceBitfield) {} }; } // namespace NEO 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 3cb66763f6..0f9c9f5bbe 100644 --- a/shared/test/common/mocks/mock_cpu_page_fault_manager.h +++ b/shared/test/common/mocks/mock_cpu_page_fault_manager.h @@ -14,17 +14,16 @@ using namespace NEO; -template -class MockPageFaultManagerImpl : public BaseFaultManager { +class MockPageFaultManager : public PageFaultManager { public: - using BaseFaultManager::BaseFaultManager; - using BaseFaultManager::gpuDomainHandler; - using BaseFaultManager::memoryData; - using PageFaultData = typename BaseFaultManager::PageFaultData; - using BaseFaultManager::selectGpuDomainHandler; - using BaseFaultManager::transferAndUnprotectMemory; - using BaseFaultManager::unprotectAndTransferMemory; - using BaseFaultManager::verifyAndHandlePageFault; + using PageFaultManager::gpuDomainHandler; + using PageFaultManager::memoryData; + using PageFaultManager::PageFaultData; + using PageFaultManager::PageFaultManager; + using PageFaultManager::selectGpuDomainHandler; + using PageFaultManager::transferAndUnprotectMemory; + using PageFaultManager::unprotectAndTransferMemory; + using PageFaultManager::verifyAndHandlePageFault; bool checkFaultHandlerFromPageFaultManager() override { checkFaultHandlerCalled++; @@ -63,19 +62,19 @@ class MockPageFaultManagerImpl : public BaseFaultManager { allowCPUMemoryEvictionCalled++; } void baseAubWritable(bool writable, void *ptr, SVMAllocsManager *unifiedMemoryManager) { - BaseFaultManager::setAubWritable(writable, ptr, unifiedMemoryManager); + PageFaultManager::setAubWritable(writable, ptr, unifiedMemoryManager); } void baseCpuTransfer(void *ptr, size_t size, void *cmdQ) { - BaseFaultManager::transferToCpu(ptr, size, cmdQ); + PageFaultManager::transferToCpu(ptr, size, cmdQ); } void baseGpuTransfer(void *ptr, void *cmdQ) { - BaseFaultManager::transferToGpu(ptr, cmdQ); + PageFaultManager::transferToGpu(ptr, cmdQ); } void baseCpuAllocEvictable(bool evictable, void *ptr, SVMAllocsManager *unifiedMemoryManager) { - BaseFaultManager::setCpuAllocEvictable(evictable, ptr, unifiedMemoryManager); + PageFaultManager::setCpuAllocEvictable(evictable, ptr, unifiedMemoryManager); } void baseAllowCPUMemoryEviction(bool evict, void *ptr, PageFaultData &pageFaultData) { - BaseFaultManager::allowCPUMemoryEviction(evict, ptr, pageFaultData); + PageFaultManager::allowCPUMemoryEviction(evict, ptr, pageFaultData); } void evictMemoryAfterImplCopy(GraphicsAllocation *allocation, Device *device) override {} @@ -86,15 +85,15 @@ class MockPageFaultManagerImpl : public BaseFaultManager { } void *getHwHandlerAddress() { - return reinterpret_cast(BaseFaultManager::transferAndUnprotectMemory); + return reinterpret_cast(PageFaultManager::transferAndUnprotectMemory); } void *getAubAndTbxHandlerAddress() { - return reinterpret_cast(BaseFaultManager::unprotectAndTransferMemory); + return reinterpret_cast(PageFaultManager::unprotectAndTransferMemory); } void moveAllocationToGpuDomain(void *ptr) override { moveAllocationToGpuDomainCalled++; - BaseFaultManager::moveAllocationToGpuDomain(ptr); + PageFaultManager::moveAllocationToGpuDomain(ptr); } int checkFaultHandlerCalled = 0; @@ -121,8 +120,6 @@ class MockPageFaultManagerImpl : public BaseFaultManager { EngineUsage engineUsage = EngineUsage::engineUsageCount; }; -class MockPageFaultManager : public MockPageFaultManagerImpl {}; - template class MockPageFaultManagerHandlerInvoke : public T { public: diff --git a/shared/test/common/mocks/mock_tbx_csr.h b/shared/test/common/mocks/mock_tbx_csr.h index f9abae2ce7..a3c55ab8ff 100644 --- a/shared/test/common/mocks/mock_tbx_csr.h +++ b/shared/test/common/mocks/mock_tbx_csr.h @@ -10,8 +10,6 @@ #include "shared/source/command_stream/submission_status.h" #include "shared/source/command_stream/tbx_command_stream_receiver_hw.h" #include "shared/source/execution_environment/execution_environment.h" -#include "shared/source/page_fault_manager/cpu_page_fault_manager.h" -#include "shared/source/page_fault_manager/tbx_page_fault_manager.h" namespace NEO { @@ -20,8 +18,6 @@ class MockTbxCsr : public TbxCommandStreamReceiverHw { public: using TbxCommandStreamReceiverHw::writeMemory; using TbxCommandStreamReceiverHw::allocationsForDownload; - using TbxCommandStreamReceiverHw::getParametersForMemory; - using TbxCommandStreamReceiverHw::getTbxPageFaultManager; MockTbxCsr(ExecutionEnvironment &executionEnvironment, const DeviceBitfield deviceBitfield) : TbxCommandStreamReceiverHw(executionEnvironment, 0, deviceBitfield) { this->downloadAllocationImpl = [this](GraphicsAllocation &gfxAllocation) { @@ -68,7 +64,6 @@ class MockTbxCsr : public TbxCommandStreamReceiverHw { TbxCommandStreamReceiverHw::dumpAllocation(gfxAllocation); dumpAllocationCalled = true; } - bool initializeEngineCalled = false; bool writeMemoryWithAubManagerCalled = false; bool writeMemoryCalled = false; diff --git a/shared/test/unit_test/command_stream/tbx_command_stream_tests.cpp b/shared/test/unit_test/command_stream/tbx_command_stream_tests.cpp index 064af09993..bae63c7b7b 100644 --- a/shared/test/unit_test/command_stream/tbx_command_stream_tests.cpp +++ b/shared/test/unit_test/command_stream/tbx_command_stream_tests.cpp @@ -13,11 +13,9 @@ #include "shared/source/helpers/engine_node_helper.h" #include "shared/source/helpers/gfx_core_helper.h" #include "shared/source/helpers/hardware_context_controller.h" -#include "shared/source/helpers/options.h" #include "shared/source/helpers/ptr_math.h" #include "shared/source/memory_manager/memory_banks.h" #include "shared/source/memory_manager/os_agnostic_memory_manager.h" -#include "shared/source/page_fault_manager/cpu_page_fault_manager.h" #include "shared/test/common/fixtures/device_fixture.h" #include "shared/test/common/fixtures/mock_aub_center_fixture.h" #include "shared/test/common/fixtures/tbx_command_stream_fixture.h" @@ -38,7 +36,6 @@ #include "shared/test/common/test_macros/hw_test.h" #include -#include using namespace NEO; @@ -1284,111 +1281,3 @@ HWTEST_F(TbxCommandStreamTests, givenTimestampBufferAllocationWhenTbxWriteMemory memoryManager->freeGraphicsMemory(timestampAllocation); } - -template -struct TbxPageFaultTestFixture { - - class MockTbxCsrForPageFaultTests : public MockTbxCsr { - public: - using MockTbxCsr::MockTbxCsr; - - CpuPageFaultManager *getTbxPageFaultManager() override { - return this->tbxFaultManager.get(); - } - - std::unique_ptr tbxFaultManager = TbxPageFaultManager::create(); - }; - - static void runTest1(MockDevice *pDevice) { - DebugManagerStateRestore dbgRestore; - debugManager.flags.SetCommandStreamReceiver.set(static_cast(csrType)); - std::unique_ptr tbxCsr(new MockTbxCsrForPageFaultTests(*pDevice->executionEnvironment, pDevice->getDeviceBitfield())); - tbxCsr->setupContext(*pDevice->getDefaultEngine().osContext); - - EXPECT_TRUE(tbxCsr->tbxFaultManager->checkFaultHandlerFromPageFaultManager()); - - auto memoryManager = pDevice->getMemoryManager(); - - NEO::GraphicsAllocation *gfxAlloc1 = memoryManager->allocateGraphicsMemoryWithProperties( - {pDevice->getRootDeviceIndex(), - MemoryConstants::pageSize, - AllocationType::bufferHostMemory, - pDevice->getDeviceBitfield()}); - - uint64_t gpuAddress; - void *cpuAddress; - size_t size; - - EXPECT_TRUE(tbxCsr->getParametersForMemory(*gfxAlloc1, gpuAddress, cpuAddress, size)); - - tbxCsr->writeMemory(*gfxAlloc1); - EXPECT_FALSE(tbxCsr->isTbxWritable(*gfxAlloc1)); - - // accessing outside address range does not affect inserted host allocs - auto ptrBelow = (void *)0x0; - EXPECT_FALSE(tbxCsr->tbxFaultManager->verifyAndHandlePageFault(ptrBelow, true)); - auto ptrAbove = ptrOffset(cpuAddress, size + 1); - EXPECT_FALSE(tbxCsr->tbxFaultManager->verifyAndHandlePageFault(ptrAbove, true)); - EXPECT_FALSE(tbxCsr->isTbxWritable(*gfxAlloc1)); - - *reinterpret_cast(cpuAddress) = 1; - EXPECT_TRUE(tbxCsr->isTbxWritable(*gfxAlloc1)); - - tbxCsr->writeMemory(*gfxAlloc1); - EXPECT_FALSE(tbxCsr->isTbxWritable(*gfxAlloc1)); - - // accessing address with offset that is still in alloc range should - // also make writable and download - reinterpret_cast(cpuAddress)[1] = 1; - EXPECT_TRUE(tbxCsr->isTbxWritable(*gfxAlloc1)); - - // for coverage - tbxCsr->tbxFaultManager->removeAllocation(static_cast(nullptr)); - tbxCsr->tbxFaultManager->removeAllocation(gfxAlloc1); - - memoryManager->freeGraphicsMemory(gfxAlloc1); - } - - static void runtTest2(MockDevice *pDevice) { - DebugManagerStateRestore dbgRestore; - debugManager.flags.SetCommandStreamReceiver.set(static_cast(csrType)); - std::unique_ptr tbxCsr(new MockTbxCsrForPageFaultTests(*pDevice->executionEnvironment, pDevice->getDeviceBitfield())); - tbxCsr->setupContext(*pDevice->getDefaultEngine().osContext); - - EXPECT_TRUE(tbxCsr->tbxFaultManager->checkFaultHandlerFromPageFaultManager()); - - auto memoryManager = pDevice->getMemoryManager(); - - NEO::GraphicsAllocation *gfxAlloc1 = memoryManager->allocateGraphicsMemoryWithProperties( - {pDevice->getRootDeviceIndex(), - MemoryConstants::pageSize, - AllocationType::bufferHostMemory, - pDevice->getDeviceBitfield()}); - - uint64_t gpuAddress; - void *cpuAddress; - size_t size; - - EXPECT_TRUE(tbxCsr->getParametersForMemory(*gfxAlloc1, gpuAddress, cpuAddress, size)); - - tbxCsr->writeMemory(*gfxAlloc1); - tbxCsr->downloadAllocationTbx(*gfxAlloc1); - EXPECT_TRUE(!tbxCsr->isTbxWritable(*gfxAlloc1)); - - static_cast(cpuAddress)[0] = 1.0f; - - memoryManager->freeGraphicsMemory(gfxAlloc1); - } -}; - -HWTEST_F(TbxCommandStreamTests, givenTbxModeWhenHostAccessesHostAllocThenAllocShouldBeDownloadedAndWritable) { - TbxPageFaultTestFixture::runTest1(pDevice); -} - -HWTEST_F(TbxCommandStreamTests, givenTbxWithAubModeWhenHostAccessesHostAllocThenAllocShouldBeDownloadedAndWritable) { - TbxPageFaultTestFixture::runTest1(pDevice); -} - -HWTEST_F(TbxCommandStreamTests, givenTbxWithModeWhenHostBufferNotWritableAndProtectedThenDownloadShouldNotCrash) { - TbxPageFaultTestFixture::runtTest2(pDevice); -} diff --git a/shared/test/unit_test/debug_settings/debug_settings_manager_tests.cpp b/shared/test/unit_test/debug_settings/debug_settings_manager_tests.cpp index f464dd630d..836a3e128b 100644 --- a/shared/test/unit_test/debug_settings/debug_settings_manager_tests.cpp +++ b/shared/test/unit_test/debug_settings/debug_settings_manager_tests.cpp @@ -452,21 +452,3 @@ TEST(DurationLogTest, givenDurationGetTimeStringThenTimeStringIsCorrect) { EXPECT_TRUE(std::isdigit(c) || c == '[' || c == ']' || c == '.' || c == ' '); } } - -TEST(DebugSettingsManager, GivenTbxOrTbxWithAubCsrTypeWhenCallingIsTbxModeThenReturnTrue) { - DebugManagerStateRestore restorer; - NEO::debugManager.flags.SetCommandStreamReceiver.set(2); - EXPECT_TRUE(NEO::debugManager.isTbxMode()); - - NEO::debugManager.flags.SetCommandStreamReceiver.set(4); - EXPECT_TRUE(NEO::debugManager.isTbxMode()); -} - -TEST(DebugSettingsManager, GivenHardwareOrHardwareWithAubCsrTypeWhenCallingIsTbxModeThenReturnFalse) { - DebugManagerStateRestore restorer; - NEO::debugManager.flags.SetCommandStreamReceiver.set(1); - EXPECT_FALSE(NEO::debugManager.isTbxMode()); - - NEO::debugManager.flags.SetCommandStreamReceiver.set(3); - EXPECT_FALSE(NEO::debugManager.isTbxMode()); -} 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 8f45ff49cb..ecac0a4258 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 @@ -5,8 +5,6 @@ * */ -#include "shared/source/helpers/options.h" -#include "shared/source/page_fault_manager/tbx_page_fault_manager.h" #include "shared/test/common/fixtures/cpu_page_fault_manager_tests_fixture.h" #include "shared/test/common/helpers/debug_manager_state_restore.h" #include "shared/test/common/mocks/mock_graphics_allocation.h" @@ -23,7 +21,7 @@ TEST_F(PageFaultManagerTest, givenUnifiedMemoryAllocsWhenInsertingAllocsThenAllo EXPECT_EQ(pageFaultManager->memoryData.size(), 1u); EXPECT_EQ(pageFaultManager->memoryData[alloc1].size, 10u); EXPECT_EQ(pageFaultManager->memoryData[alloc1].cmdQ, cmdQ); - EXPECT_EQ(pageFaultManager->memoryData[alloc1].domain, CpuPageFaultManager::AllocationDomain::cpu); + EXPECT_EQ(pageFaultManager->memoryData[alloc1].domain, PageFaultManager::AllocationDomain::cpu); EXPECT_EQ(pageFaultManager->memoryData[alloc1].unifiedMemoryManager, unifiedMemoryManager.get()); EXPECT_EQ(pageFaultManager->allowMemoryAccessCalled, 0); EXPECT_EQ(pageFaultManager->protectMemoryCalled, 0); @@ -35,11 +33,11 @@ TEST_F(PageFaultManagerTest, givenUnifiedMemoryAllocsWhenInsertingAllocsThenAllo EXPECT_EQ(pageFaultManager->memoryData.size(), 2u); EXPECT_EQ(pageFaultManager->memoryData[alloc1].size, 10u); EXPECT_EQ(pageFaultManager->memoryData[alloc1].cmdQ, cmdQ); - EXPECT_EQ(pageFaultManager->memoryData[alloc1].domain, CpuPageFaultManager::AllocationDomain::cpu); + EXPECT_EQ(pageFaultManager->memoryData[alloc1].domain, PageFaultManager::AllocationDomain::cpu); EXPECT_EQ(pageFaultManager->memoryData[alloc1].unifiedMemoryManager, unifiedMemoryManager.get()); EXPECT_EQ(pageFaultManager->memoryData[alloc2].size, 20u); EXPECT_EQ(pageFaultManager->memoryData[alloc2].cmdQ, cmdQ); - EXPECT_EQ(pageFaultManager->memoryData[alloc2].domain, CpuPageFaultManager::AllocationDomain::cpu); + EXPECT_EQ(pageFaultManager->memoryData[alloc2].domain, PageFaultManager::AllocationDomain::cpu); EXPECT_EQ(pageFaultManager->memoryData[alloc2].unifiedMemoryManager, unifiedMemoryManager.get()); EXPECT_EQ(pageFaultManager->allowMemoryAccessCalled, 0); EXPECT_EQ(pageFaultManager->protectMemoryCalled, 0); @@ -64,7 +62,7 @@ TEST_F(PageFaultManagerTest, givenUnifiedMemoryAllocWhenRemovingProtectedAllocTh EXPECT_EQ(pageFaultManager->memoryData[alloc1].size, 10u); EXPECT_EQ(pageFaultManager->memoryData[alloc1].unifiedMemoryManager, unifiedMemoryManager.get()); - pageFaultManager->memoryData[alloc1].domain = CpuPageFaultManager::AllocationDomain::gpu; + pageFaultManager->memoryData[alloc1].domain = PageFaultManager::AllocationDomain::gpu; pageFaultManager->removeAllocation(alloc1); EXPECT_EQ(pageFaultManager->allowMemoryAccessCalled, 1); @@ -93,7 +91,7 @@ TEST_F(PageFaultManagerTest, givenUnifiedMemoryAllocWhenRemovingAllocsThenNonGpu EXPECT_EQ(unifiedMemoryManager->nonGpuDomainAllocs.size(), 1u); EXPECT_EQ(unifiedMemoryManager->nonGpuDomainAllocs[0], alloc2); - pageFaultManager->memoryData.at(alloc2).domain = CpuPageFaultManager::AllocationDomain::gpu; + pageFaultManager->memoryData.at(alloc2).domain = PageFaultManager::AllocationDomain::gpu; pageFaultManager->removeAllocation(alloc2); EXPECT_EQ(pageFaultManager->allowMemoryAccessCalled, 1); EXPECT_EQ(pageFaultManager->allowedMemoryAccessAddress, alloc2); @@ -111,7 +109,7 @@ TEST_F(PageFaultManagerTest, givenUnifiedMemoryAllocWhenAllocNotPresentInNonGpuD pageFaultManager->moveAllocationToGpuDomain(alloc1); EXPECT_EQ(unifiedMemoryManager->nonGpuDomainAllocs.size(), 0u); - pageFaultManager->memoryData.at(alloc1).domain = CpuPageFaultManager::AllocationDomain::cpu; + pageFaultManager->memoryData.at(alloc1).domain = PageFaultManager::AllocationDomain::cpu; pageFaultManager->removeAllocation(alloc1); EXPECT_EQ(unifiedMemoryManager->nonGpuDomainAllocs.size(), 0u); } @@ -129,7 +127,7 @@ TEST_F(PageFaultManagerTest, givenNonGpuAllocsContainerWhenMovingToGpuDomainMult pageFaultManager->moveAllocationToGpuDomain(alloc1); EXPECT_EQ(unifiedMemoryManager->nonGpuDomainAllocs.size(), 1u); EXPECT_EQ(unifiedMemoryManager->nonGpuDomainAllocs[0], alloc2); - pageFaultManager->memoryData.at(alloc1).domain = CpuPageFaultManager::AllocationDomain::none; + pageFaultManager->memoryData.at(alloc1).domain = PageFaultManager::AllocationDomain::none; pageFaultManager->moveAllocationToGpuDomain(alloc1); EXPECT_EQ(unifiedMemoryManager->nonGpuDomainAllocs.size(), 1u); EXPECT_EQ(unifiedMemoryManager->nonGpuDomainAllocs[0], alloc2); @@ -148,7 +146,7 @@ TEST_F(PageFaultManagerTest, givenUnifiedMemoryAllocsWhenMovingToGpuDomainAllocs pageFaultManager->insertAllocation(alloc3, 30, unifiedMemoryManager.get(), cmdQ, {}); EXPECT_EQ(pageFaultManager->transferToCpuCalled, 0); EXPECT_EQ(pageFaultManager->memoryData.size(), 3u); - pageFaultManager->memoryData.at(alloc3).domain = CpuPageFaultManager::AllocationDomain::gpu; + pageFaultManager->memoryData.at(alloc3).domain = PageFaultManager::AllocationDomain::gpu; pageFaultManager->moveAllocationsWithinUMAllocsManagerToGpuDomain(unifiedMemoryManager.get()); @@ -168,9 +166,9 @@ TEST_F(PageFaultManagerTest, givenUnifiedMemoryAllocWhenMovingAllocsOfGivenUMMan pageFaultManager->insertAllocation(alloc1, 10u, unifiedMemoryManager.get(), nullptr, {}); pageFaultManager->insertAllocation(alloc2, 20u, unifiedMemoryManager.get(), nullptr, {}); - pageFaultManager->memoryData.at(alloc2).domain = CpuPageFaultManager::AllocationDomain::gpu; + pageFaultManager->memoryData.at(alloc2).domain = PageFaultManager::AllocationDomain::gpu; pageFaultManager->moveAllocationsWithinUMAllocsManagerToGpuDomain(unifiedMemoryManager.get()); - EXPECT_EQ(pageFaultManager->memoryData.at(alloc1).domain, CpuPageFaultManager::AllocationDomain::gpu); + EXPECT_EQ(pageFaultManager->memoryData.at(alloc1).domain, PageFaultManager::AllocationDomain::gpu); EXPECT_EQ(unifiedMemoryManager->nonGpuDomainAllocs.size(), 0u); } @@ -189,7 +187,7 @@ TEST_F(PageFaultManagerTest, givenUnifiedMemoryAllocsWhenMovingToGpuDomainWithPr pageFaultManager->insertAllocation(alloc3, 30, unifiedMemoryManager.get(), cmdQ, {}); EXPECT_EQ(pageFaultManager->transferToCpuCalled, 0); EXPECT_EQ(pageFaultManager->memoryData.size(), 3u); - pageFaultManager->memoryData.at(alloc3).domain = CpuPageFaultManager::AllocationDomain::gpu; + pageFaultManager->memoryData.at(alloc3).domain = PageFaultManager::AllocationDomain::gpu; testing::internal::CaptureStdout(); // start capturing @@ -221,8 +219,8 @@ TEST_F(PageFaultManagerTest, givenUnifiedMemoryAllocsWhenMovingToGpuDomainAllocs EXPECT_EQ(unifiedMemoryManager->nonGpuDomainAllocs.size(), 2u); EXPECT_EQ(unifiedMemoryManager->nonGpuDomainAllocs[0], alloc1); EXPECT_EQ(unifiedMemoryManager->nonGpuDomainAllocs[1], alloc2); - pageFaultManager->memoryData.at(alloc1).domain = CpuPageFaultManager::AllocationDomain::cpu; - pageFaultManager->memoryData.at(alloc2).domain = CpuPageFaultManager::AllocationDomain::none; + pageFaultManager->memoryData.at(alloc1).domain = PageFaultManager::AllocationDomain::cpu; + pageFaultManager->memoryData.at(alloc2).domain = PageFaultManager::AllocationDomain::none; pageFaultManager->moveAllocationsWithinUMAllocsManagerToGpuDomain(unifiedMemoryManager.get()); @@ -368,13 +366,13 @@ TEST_F(PageFaultManagerTest, givenUnifiedMemoryAllocWhenMovingToGpuDomainThenUpd EXPECT_EQ(unifiedMemoryManager->nonGpuDomainAllocs.size(), 2u); pageFaultManager->moveAllocationToGpuDomain(alloc1); - EXPECT_EQ(pageFaultManager->memoryData.at(alloc1).domain, CpuPageFaultManager::AllocationDomain::gpu); + EXPECT_EQ(pageFaultManager->memoryData.at(alloc1).domain, PageFaultManager::AllocationDomain::gpu); const auto &allocsVec = unifiedMemoryManager->nonGpuDomainAllocs; EXPECT_EQ(std::find(allocsVec.cbegin(), allocsVec.cend(), alloc1), allocsVec.cend()); EXPECT_EQ(allocsVec.size(), 1u); EXPECT_EQ(allocsVec[0], alloc2); - pageFaultManager->memoryData.at(alloc2).domain = CpuPageFaultManager::AllocationDomain::gpu; + pageFaultManager->memoryData.at(alloc2).domain = PageFaultManager::AllocationDomain::gpu; pageFaultManager->moveAllocationToGpuDomain(alloc2); EXPECT_NE(std::find(allocsVec.cbegin(), allocsVec.cend(), alloc2), allocsVec.cend()); EXPECT_EQ(unifiedMemoryManager->nonGpuDomainAllocs.size(), 1u); @@ -415,7 +413,7 @@ TEST_F(PageFaultManagerTest, givenUnifiedMemoryAllocInGpuDomainWhenMovingToGpuDo pageFaultManager->insertAllocation(alloc, 10, unifiedMemoryManager.get(), cmdQ, {}); EXPECT_EQ(pageFaultManager->transferToCpuCalled, 0); EXPECT_EQ(pageFaultManager->memoryData.size(), 1u); - pageFaultManager->memoryData.at(alloc).domain = CpuPageFaultManager::AllocationDomain::gpu; + pageFaultManager->memoryData.at(alloc).domain = PageFaultManager::AllocationDomain::gpu; pageFaultManager->moveAllocationToGpuDomain(alloc); EXPECT_EQ(pageFaultManager->allowMemoryAccessCalled, 0); @@ -541,15 +539,15 @@ TEST_F(PageFaultManagerTest, givenAllocsFromCpuDomainWhenVerifyingPageFaultThenD pageFaultManager->moveAllocationsWithinUMAllocsManagerToGpuDomain(unifiedMemoryManager.get()); EXPECT_EQ(unifiedMemoryManager->nonGpuDomainAllocs.size(), 0u); - pageFaultManager->memoryData.at(alloc2).domain = CpuPageFaultManager::AllocationDomain::none; + pageFaultManager->memoryData.at(alloc2).domain = PageFaultManager::AllocationDomain::none; pageFaultManager->verifyAndHandlePageFault(alloc2, true); - EXPECT_EQ(pageFaultManager->memoryData.at(alloc2).domain, CpuPageFaultManager::AllocationDomain::cpu); + EXPECT_EQ(pageFaultManager->memoryData.at(alloc2).domain, PageFaultManager::AllocationDomain::cpu); EXPECT_EQ(unifiedMemoryManager->nonGpuDomainAllocs.size(), 0u); pageFaultManager->gpuDomainHandler = &MockPageFaultManager::unprotectAndTransferMemory; - pageFaultManager->memoryData.at(alloc1).domain = CpuPageFaultManager::AllocationDomain::none; + pageFaultManager->memoryData.at(alloc1).domain = PageFaultManager::AllocationDomain::none; pageFaultManager->verifyAndHandlePageFault(alloc1, true); - EXPECT_EQ(pageFaultManager->memoryData.at(alloc1).domain, CpuPageFaultManager::AllocationDomain::cpu); + EXPECT_EQ(pageFaultManager->memoryData.at(alloc1).domain, PageFaultManager::AllocationDomain::cpu); EXPECT_EQ(unifiedMemoryManager->nonGpuDomainAllocs.size(), 0u); } @@ -904,7 +902,7 @@ struct PageFaultManagerTestWithDebugFlag : public ::testing::TestWithParam(0x1), @@ -955,58 +953,24 @@ TEST_F(PageFaultManagerTest, givenNoUsmInitialPlacementFlagsWHenInsertingUsmAllo memoryProperties.allocFlags.usmInitialPlacementCpu = 0; memoryProperties.allocFlags.usmInitialPlacementGpu = 0; pageFaultManager->insertAllocation(allocs[0], 10, unifiedMemoryManager.get(), cmdQ, memoryProperties); - EXPECT_EQ(CpuPageFaultManager::AllocationDomain::cpu, pageFaultManager->memoryData.at(allocs[0]).domain); + EXPECT_EQ(PageFaultManager::AllocationDomain::cpu, pageFaultManager->memoryData.at(allocs[0]).domain); EXPECT_EQ(allocs[0], unifiedMemoryManager->nonGpuDomainAllocs[0]); memoryProperties.allocFlags.usmInitialPlacementCpu = 0; memoryProperties.allocFlags.usmInitialPlacementGpu = 1; pageFaultManager->insertAllocation(allocs[1], 10, unifiedMemoryManager.get(), cmdQ, memoryProperties); - EXPECT_EQ(CpuPageFaultManager::AllocationDomain::none, pageFaultManager->memoryData.at(allocs[1]).domain); + EXPECT_EQ(PageFaultManager::AllocationDomain::none, pageFaultManager->memoryData.at(allocs[1]).domain); EXPECT_EQ(allocs[1], unifiedMemoryManager->nonGpuDomainAllocs[1]); memoryProperties.allocFlags.usmInitialPlacementCpu = 1; memoryProperties.allocFlags.usmInitialPlacementGpu = 0; pageFaultManager->insertAllocation(allocs[2], 10, unifiedMemoryManager.get(), cmdQ, memoryProperties); - EXPECT_EQ(CpuPageFaultManager::AllocationDomain::cpu, pageFaultManager->memoryData.at(allocs[2]).domain); + EXPECT_EQ(PageFaultManager::AllocationDomain::cpu, pageFaultManager->memoryData.at(allocs[2]).domain); EXPECT_EQ(allocs[2], unifiedMemoryManager->nonGpuDomainAllocs[2]); memoryProperties.allocFlags.usmInitialPlacementCpu = 1; memoryProperties.allocFlags.usmInitialPlacementGpu = 1; pageFaultManager->insertAllocation(allocs[3], 10, unifiedMemoryManager.get(), cmdQ, memoryProperties); - EXPECT_EQ(CpuPageFaultManager::AllocationDomain::cpu, pageFaultManager->memoryData.at(allocs[3]).domain); + EXPECT_EQ(PageFaultManager::AllocationDomain::cpu, pageFaultManager->memoryData.at(allocs[3]).domain); EXPECT_EQ(allocs[3], unifiedMemoryManager->nonGpuDomainAllocs[3]); } - -TEST_F(PageFaultManagerTest, givenTbxModeWhenAllocateSharedMemoryThenTbxFaultManagerShouldBehaveLikeCpuFaultManager) { - auto memoryManager2 = std::make_unique(executionEnvironment); - auto unifiedMemoryManager2 = std::make_unique(memoryManager2.get(), false); - auto pageFaultManager2 = std::make_unique>(); - void *cmdQ = reinterpret_cast(0xFFFF); - - RootDeviceIndicesContainer rootDeviceIndices = {mockRootDeviceIndex}; - std::map deviceBitfields{{mockRootDeviceIndex, mockDeviceBitfield}}; - - auto properties = SVMAllocsManager::UnifiedMemoryProperties(InternalMemoryType::sharedUnifiedMemory, 1, rootDeviceIndices, deviceBitfields); - void *ptr = unifiedMemoryManager2->createSharedUnifiedMemoryAllocation(10, properties, cmdQ); - - pageFaultManager2->insertAllocation(ptr, 10, unifiedMemoryManager2.get(), cmdQ, {}); - - EXPECT_TRUE(pageFaultManager2->verifyAndHandlePageFault(ptr, true)); - - unifiedMemoryManager2->freeSVMAlloc(ptr); -} - -TEST_F(PageFaultManagerTest, givenHardwareModeWhenCallTbxInsertOrRemoveApiThenNothing) { - auto pageFaultManager2 = std::make_unique>(); - - auto ptr = reinterpret_cast(0XFFFF); - auto gfxAlloc = reinterpret_cast(0xFFFF); - auto csr = reinterpret_cast(0xFFFF); - pageFaultManager2->insertAllocation(csr, gfxAlloc, ptr, 0); - EXPECT_EQ(pageFaultManager2->memoryData.find(ptr), pageFaultManager2->memoryData.end()); - - pageFaultManager2->memoryData[ptr] = {}; - pageFaultManager2->removeAllocation(gfxAlloc); - EXPECT_FALSE(pageFaultManager2->memoryData.find(ptr) == pageFaultManager2->memoryData.end()); - pageFaultManager2->memoryData.erase(ptr); -} diff --git a/shared/test/unit_test/page_fault_manager/windows/cpu_page_fault_manager_windows_tests.cpp b/shared/test/unit_test/page_fault_manager/windows/cpu_page_fault_manager_windows_tests.cpp index 23cc7805ec..49e1052204 100644 --- a/shared/test/unit_test/page_fault_manager/windows/cpu_page_fault_manager_windows_tests.cpp +++ b/shared/test/unit_test/page_fault_manager/windows/cpu_page_fault_manager_windows_tests.cpp @@ -156,4 +156,4 @@ TEST_F(PageFaultManagerTest, EXPECT_EQ(0u, csr->getEvictionAllocations().size()); unifiedMemoryManager->freeSVMAlloc(ptr); -} +} \ No newline at end of file diff --git a/shared/test/unit_test/ult_specific_config.cpp b/shared/test/unit_test/ult_specific_config.cpp index bd1f17b108..b6d93c1ca1 100644 --- a/shared/test/unit_test/ult_specific_config.cpp +++ b/shared/test/unit_test/ult_specific_config.cpp @@ -29,11 +29,11 @@ const char *neoMockSettingsFileName = "neo_mock.config"; bool CompressionSelector::preferCompressedAllocation(const AllocationProperties &properties) { return false; } -void CpuPageFaultManager::transferToCpu(void *ptr, size_t size, void *cmdQ) { +void PageFaultManager::transferToCpu(void *ptr, size_t size, void *cmdQ) { } -void CpuPageFaultManager::transferToGpu(void *ptr, void *cmdQ) { +void PageFaultManager::transferToGpu(void *ptr, void *cmdQ) { } -void CpuPageFaultManager::allowCPUMemoryEviction(bool evict, void *ptr, PageFaultData &pageFaultData) { +void PageFaultManager::allowCPUMemoryEviction(bool evict, void *ptr, PageFaultData &pageFaultData) { } void RootDeviceEnvironment::initApiGfxCoreHelper() {