From 4f96b6132ff66e009a82a03b10dcfbb877d3f8bb Mon Sep 17 00:00:00 2001 From: Compute-Runtime-Validation Date: Sat, 28 Sep 2024 07:25:46 +0200 Subject: [PATCH] Revert "feature: capture multiple cpu pagefault handler" This reverts commit 4b3a6e9cfec4439db22ca1e38ba3494beddf49a5. Signed-off-by: Compute-Runtime-Validation --- .../debug_settings/debug_variables_base.inl | 2 +- .../cpu_page_fault_manager.cpp | 8 +- .../cpu_page_fault_manager.h | 2 +- .../linux/cpu_page_fault_manager_linux.cpp | 30 +-- .../linux/cpu_page_fault_manager_linux.h | 4 +- .../cpu_page_fault_manager_windows.cpp | 2 +- .../mocks/mock_cpu_page_fault_manager.h | 9 +- shared/test/common/test_files/igdrcl.config | 2 +- .../cpu_page_fault_manager_tests.cpp | 101 ++-------- .../cpu_page_fault_manager_linux_tests.cpp | 190 +----------------- .../cpu_page_fault_manager_windows_tests.cpp | 2 +- 11 files changed, 35 insertions(+), 317 deletions(-) diff --git a/shared/source/debug_settings/debug_variables_base.inl b/shared/source/debug_settings/debug_variables_base.inl index 68dfa9f8fc..ce3cd48b24 100644 --- a/shared/source/debug_settings/debug_variables_base.inl +++ b/shared/source/debug_settings/debug_variables_base.inl @@ -442,7 +442,7 @@ DECLARE_DEBUG_VARIABLE(int32_t, WaitForPagingFenceInController, -1, "Instead of /*FEATURE FLAGS*/ DECLARE_DEBUG_VARIABLE(bool, USMEvictAfterMigration, false, "Evict USM allocation after implicit migration to GPU") -DECLARE_DEBUG_VARIABLE(bool, RegisterPageFaultHandlerOnMigration, false, "Register handler on migration to GPU when current is not from pagefault manager") +DECLARE_DEBUG_VARIABLE(bool, RegisterPageFaultHandlerOnMigration, true, "Register handler on migration to GPU when current is not from pagefault manager") DECLARE_DEBUG_VARIABLE(bool, EnableNV12, true, "Enables NV12 extension") DECLARE_DEBUG_VARIABLE(bool, EnablePackedYuv, true, "Enables cl_packed_yuv extension") DECLARE_DEBUG_VARIABLE(bool, EnableDeferredDeleter, true, "Enables async deleter") 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 f45cc962ca..62229b098b 100644 --- a/shared/source/page_fault_manager/cpu_page_fault_manager.cpp +++ b/shared/source/page_fault_manager/cpu_page_fault_manager.cpp @@ -95,16 +95,14 @@ inline void PageFaultManager::migrateStorageToGpuDomain(void *ptr, PageFaultData pageFaultData.domain = AllocationDomain::gpu; } -bool PageFaultManager::verifyAndHandlePageFault(void *ptr, bool handlePageFault) { +bool PageFaultManager::verifyPageFault(void *ptr) { std::unique_lock lock{mtx}; for (auto &alloc : this->memoryData) { auto allocPtr = alloc.first; auto &pageFaultData = alloc.second; if (ptr >= allocPtr && ptr < ptrOffset(allocPtr, pageFaultData.size)) { - if (handlePageFault) { - this->setAubWritable(true, allocPtr, pageFaultData.unifiedMemoryManager); - gpuDomainHandler(this, allocPtr, pageFaultData); - } + this->setAubWritable(true, allocPtr, pageFaultData.unifiedMemoryManager); + gpuDomainHandler(this, allocPtr, pageFaultData); return true; } } 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 241441fb96..1c478efb95 100644 --- a/shared/source/page_fault_manager/cpu_page_fault_manager.h +++ b/shared/source/page_fault_manager/cpu_page_fault_manager.h @@ -59,7 +59,7 @@ class PageFaultManager : public NonCopyableOrMovableClass { virtual void evictMemoryAfterImplCopy(GraphicsAllocation *allocation, Device *device) = 0; virtual void allowCPUMemoryEvictionImpl(void *ptr, CommandStreamReceiver &csr, OSInterface *osInterface) = 0; - MOCKABLE_VIRTUAL bool verifyAndHandlePageFault(void *ptr, bool handlePageFault); + 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); 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 734c4720d6..1724ed5b57 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 @@ -13,7 +13,6 @@ #include "shared/source/helpers/debug_helpers.h" #include "shared/source/memory_manager/memory_operations_handler.h" -#include #include namespace NEO { @@ -36,9 +35,8 @@ PageFaultManagerLinux::PageFaultManagerLinux() { PageFaultManagerLinux::~PageFaultManagerLinux() { if (!previousHandlerRestored) { - auto retVal = sigaction(SIGSEGV, &previousPageFaultHandlers[0], nullptr); + auto retVal = sigaction(SIGSEGV, &previousPageFaultHandler, nullptr); UNRECOVERABLE_IF(retVal != 0); - previousPageFaultHandlers.clear(); } } @@ -49,21 +47,8 @@ bool PageFaultManagerLinux::checkFaultHandlerFromPageFaultManager() { } void PageFaultManagerLinux::registerFaultHandler() { - struct sigaction previousPageFaultHandler = {}; - auto retVal = sigaction(SIGSEGV, nullptr, &previousPageFaultHandler); - UNRECOVERABLE_IF(retVal != 0); - - auto compareHandler = [&ph = previousPageFaultHandler](const struct sigaction &h) -> bool { - return (h.sa_flags & SA_SIGINFO) ? (h.sa_sigaction == ph.sa_sigaction) : (h.sa_handler == ph.sa_handler); - }; - if (std::find_if(previousPageFaultHandlers.begin(), - previousPageFaultHandlers.end(), - compareHandler) == previousPageFaultHandlers.end()) { - previousPageFaultHandlers.push_back(previousPageFaultHandler); - } - pageFaultHandler = [&](int signal, siginfo_t *info, void *context) { - if (!this->verifyAndHandlePageFault(info->si_addr, this->handlerIndex == 0)) { + if (!this->verifyPageFault(info->si_addr)) { callPreviousHandler(signal, info, context); } }; @@ -72,7 +57,7 @@ void PageFaultManagerLinux::registerFaultHandler() { pageFaultManagerHandler.sa_flags = SA_SIGINFO; pageFaultManagerHandler.sa_sigaction = pageFaultHandlerWrapper; - retVal = sigaction(SIGSEGV, &pageFaultManagerHandler, &previousPageFaultHandler); + auto retVal = sigaction(SIGSEGV, &pageFaultManagerHandler, &previousPageFaultHandler); UNRECOVERABLE_IF(retVal != 0); } @@ -91,9 +76,6 @@ void PageFaultManagerLinux::protectCPUMemoryAccess(void *ptr, size_t size) { } void PageFaultManagerLinux::callPreviousHandler(int signal, siginfo_t *info, void *context) { - handlerIndex++; - UNRECOVERABLE_IF(handlerIndex < 0 && handlerIndex >= static_cast(previousPageFaultHandlers.size())); - auto previousPageFaultHandler = previousPageFaultHandlers[previousPageFaultHandlers.size() - handlerIndex]; if (previousPageFaultHandler.sa_flags & SA_SIGINFO) { previousPageFaultHandler.sa_sigaction(signal, info, context); } else { @@ -101,12 +83,12 @@ void PageFaultManagerLinux::callPreviousHandler(int signal, siginfo_t *info, voi auto retVal = sigaction(SIGSEGV, &previousPageFaultHandler, nullptr); UNRECOVERABLE_IF(retVal != 0); previousHandlerRestored = true; - previousPageFaultHandlers.clear(); - } else if (previousPageFaultHandler.sa_handler != SIG_IGN) { + } else if (previousPageFaultHandler.sa_handler == SIG_IGN) { + return; + } else { previousPageFaultHandler.sa_handler(signal); } } - handlerIndex--; } void PageFaultManagerLinux::evictMemoryAfterImplCopy(GraphicsAllocation *allocation, Device *device) { 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 414641bcc4..e540444427 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 @@ -11,7 +11,6 @@ #include #include -#include namespace NEO { class PageFaultManagerLinux : public PageFaultManager { @@ -36,9 +35,8 @@ class PageFaultManagerLinux : public PageFaultManager { static std::function pageFaultHandler; - std::vector previousPageFaultHandlers; + struct sigaction previousPageFaultHandler = {}; bool evictMemoryAfterCopy = false; - int handlerIndex = 0; }; } // namespace NEO 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 4536c35ed1..f735131c36 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 @@ -39,7 +39,7 @@ bool PageFaultManagerWindows::checkFaultHandlerFromPageFaultManager() { void PageFaultManagerWindows::registerFaultHandler() { pageFaultHandler = [this](struct _EXCEPTION_POINTERS *exceptionInfo) { if (static_cast(exceptionInfo->ExceptionRecord->ExceptionCode) == EXCEPTION_ACCESS_VIOLATION) { - if (this->verifyAndHandlePageFault(reinterpret_cast(exceptionInfo->ExceptionRecord->ExceptionInformation[1]), true)) { + if (this->verifyPageFault(reinterpret_cast(exceptionInfo->ExceptionRecord->ExceptionInformation[1]))) { // this is our fault that we serviced, continue app execution return EXCEPTION_CONTINUE_EXECUTION; } 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 223dcfff7b..214d220982 100644 --- a/shared/test/common/mocks/mock_cpu_page_fault_manager.h +++ b/shared/test/common/mocks/mock_cpu_page_fault_manager.h @@ -23,11 +23,11 @@ class MockPageFaultManager : public PageFaultManager { using PageFaultManager::selectGpuDomainHandler; using PageFaultManager::transferAndUnprotectMemory; using PageFaultManager::unprotectAndTransferMemory; - using PageFaultManager::verifyAndHandlePageFault; + using PageFaultManager::verifyPageFault; bool checkFaultHandlerFromPageFaultManager() override { checkFaultHandlerCalled++; - return isFaultHandlerFromPageFaultManager; + return (registerFaultHandlerCalled != 0); } void registerFaultHandler() override { registerFaultHandlerCalled++; @@ -115,7 +115,6 @@ class MockPageFaultManager : public PageFaultManager { size_t protectedSize = 0; bool isAubWritable = true; bool isCpuAllocEvictable = true; - bool isFaultHandlerFromPageFaultManager = false; aub_stream::EngineType engineType = aub_stream::EngineType::NUM_ENGINES; EngineUsage engineUsage = EngineUsage::engineUsageCount; }; @@ -131,8 +130,8 @@ class MockPageFaultManagerHandlerInvoke : public T { using T::registerFaultHandler; using T::T; - bool verifyAndHandlePageFault(void *ptr, bool handlePageFault) override { - handlerInvoked = handlePageFault; + bool verifyPageFault(void *ptr) override { + handlerInvoked = true; if (allowCPUMemoryAccessOnPageFault) { this->allowCPUMemoryAccess(ptr, size); } diff --git a/shared/test/common/test_files/igdrcl.config b/shared/test/common/test_files/igdrcl.config index 5d71e143db..437676f716 100644 --- a/shared/test/common/test_files/igdrcl.config +++ b/shared/test/common/test_files/igdrcl.config @@ -27,7 +27,7 @@ SetCommandStreamReceiver = -1 TbxPort = 4321 TbxFrontdoorMode = 0 FlattenBatchBufferForAUBDump = 0 -RegisterPageFaultHandlerOnMigration = 0 +RegisterPageFaultHandlerOnMigration = 1 AddPatchInfoCommentsForAUBDump = 0 UseAubStream = 1 AUBDumpAllocsOnEnqueueReadOnly = 0 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 cb60996548..2ebd232f76 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 @@ -253,8 +253,6 @@ TEST_F(PageFaultManagerTest, givenUnifiedMemoryAllocWhenMoveToGpuDomainThenTrans } TEST_F(PageFaultManagerTest, givenUnifiedMemoryAllocWhenMoveToGpuDomainTwiceThenCheckFaultHandlerFromPageFaultManagerReturnsTrue) { - DebugManagerStateRestore restorer; - debugManager.flags.RegisterPageFaultHandlerOnMigration.set(true); void *cmdQ = reinterpret_cast(0xFFFF); void *alloc1 = reinterpret_cast(0x1); void *alloc2 = reinterpret_cast(0x2); @@ -264,7 +262,7 @@ TEST_F(PageFaultManagerTest, givenUnifiedMemoryAllocWhenMoveToGpuDomainTwiceThen EXPECT_EQ(pageFaultManager->memoryData.size(), 2u); EXPECT_EQ(pageFaultManager->transferToCpuCalled, 0); - pageFaultManager->isFaultHandlerFromPageFaultManager = false; + EXPECT_FALSE(pageFaultManager->checkFaultHandlerFromPageFaultManager()); pageFaultManager->moveAllocationToGpuDomain(alloc1); EXPECT_EQ(pageFaultManager->allowMemoryAccessCalled, 0); @@ -276,9 +274,7 @@ TEST_F(PageFaultManagerTest, givenUnifiedMemoryAllocWhenMoveToGpuDomainTwiceThen EXPECT_EQ(pageFaultManager->protectedSize, 10u); EXPECT_EQ(pageFaultManager->transferToGpuAddress, alloc1); - EXPECT_FALSE(pageFaultManager->checkFaultHandlerFromPageFaultManager()); - - pageFaultManager->isFaultHandlerFromPageFaultManager = true; + EXPECT_TRUE(pageFaultManager->checkFaultHandlerFromPageFaultManager()); pageFaultManager->moveAllocationToGpuDomain(alloc2); EXPECT_EQ(pageFaultManager->allowMemoryAccessCalled, 0); @@ -293,44 +289,6 @@ TEST_F(PageFaultManagerTest, givenUnifiedMemoryAllocWhenMoveToGpuDomainTwiceThen EXPECT_TRUE(pageFaultManager->checkFaultHandlerFromPageFaultManager()); } -TEST_F(PageFaultManagerTest, givenUnifiedMemoryAllocWhenMoveToGpuDomainTwiceThenRegisterFaultHandlerIsCalledTwice) { - DebugManagerStateRestore restorer; - debugManager.flags.RegisterPageFaultHandlerOnMigration.set(true); - - void *cmdQ = reinterpret_cast(0xFFFF); - void *alloc1 = reinterpret_cast(0x1); - void *alloc2 = reinterpret_cast(0x2); - - pageFaultManager->insertAllocation(alloc1, 10u, unifiedMemoryManager.get(), cmdQ, {}); - pageFaultManager->insertAllocation(alloc2, 20u, unifiedMemoryManager.get(), cmdQ, {}); - EXPECT_EQ(pageFaultManager->memoryData.size(), 2u); - EXPECT_EQ(pageFaultManager->transferToCpuCalled, 0); - - pageFaultManager->isFaultHandlerFromPageFaultManager = false; - - pageFaultManager->moveAllocationToGpuDomain(alloc1); - EXPECT_EQ(pageFaultManager->allowMemoryAccessCalled, 0); - EXPECT_EQ(pageFaultManager->protectMemoryCalled, 1); - EXPECT_EQ(pageFaultManager->transferToCpuCalled, 0); - EXPECT_EQ(pageFaultManager->transferToGpuCalled, 1); - EXPECT_EQ(pageFaultManager->registerFaultHandlerCalled, 1); - EXPECT_EQ(pageFaultManager->protectedMemoryAccessAddress, alloc1); - EXPECT_EQ(pageFaultManager->protectedSize, 10u); - EXPECT_EQ(pageFaultManager->transferToGpuAddress, alloc1); - EXPECT_FALSE(pageFaultManager->checkFaultHandlerFromPageFaultManager()); - - pageFaultManager->moveAllocationToGpuDomain(alloc2); - EXPECT_EQ(pageFaultManager->allowMemoryAccessCalled, 0); - EXPECT_EQ(pageFaultManager->protectMemoryCalled, 2); - EXPECT_EQ(pageFaultManager->transferToCpuCalled, 0); - EXPECT_EQ(pageFaultManager->transferToGpuCalled, 2); - EXPECT_EQ(pageFaultManager->registerFaultHandlerCalled, 2); - EXPECT_EQ(pageFaultManager->protectedMemoryAccessAddress, alloc2); - EXPECT_EQ(pageFaultManager->protectedSize, 20u); - EXPECT_EQ(pageFaultManager->transferToGpuAddress, alloc2); - EXPECT_FALSE(pageFaultManager->checkFaultHandlerFromPageFaultManager()); -} - TEST_F(PageFaultManagerTest, givenRegisterPageFaultHandlerOnMigrationDisabledWhenMoveToGpuDomainThenDoNotRegisterHandler) { DebugManagerStateRestore restorer; debugManager.flags.RegisterPageFaultHandlerOnMigration.set(false); @@ -446,7 +404,7 @@ TEST_F(PageFaultManagerTest, givenHandlerRegisteredAndUntrackedPageFaultAddressW pageFaultManager->insertAllocation(alloc2, 20, unifiedMemoryManager.get(), nullptr, {}); EXPECT_EQ(pageFaultManager->memoryData.size(), 2u); - auto retVal = pageFaultManager->verifyAndHandlePageFault(alloc3, true); + auto retVal = pageFaultManager->verifyPageFault(alloc3); EXPECT_FALSE(retVal); } @@ -459,7 +417,7 @@ TEST_F(PageFaultManagerTest, givenTrackedPageFaultAddressWhenVerifyingThenProper EXPECT_EQ(pageFaultManager->transferToCpuCalled, 0); EXPECT_EQ(pageFaultManager->memoryData.size(), 2u); - pageFaultManager->verifyAndHandlePageFault(alloc1, true); + pageFaultManager->verifyPageFault(alloc1); EXPECT_EQ(pageFaultManager->allowMemoryAccessCalled, 1); EXPECT_EQ(pageFaultManager->protectMemoryCalled, 0); EXPECT_EQ(pageFaultManager->transferToCpuCalled, 0); @@ -480,7 +438,7 @@ TEST_F(PageFaultManagerTest, givenInitialPlacementCpuWhenVerifyingPagefaultThenF EXPECT_EQ(unifiedMemoryManager->nonGpuDomainAllocs.size(), 1u); EXPECT_EQ(unifiedMemoryManager->nonGpuDomainAllocs[0], alloc); - pageFaultManager->verifyAndHandlePageFault(alloc, true); + pageFaultManager->verifyPageFault(alloc); EXPECT_EQ(pageFaultManager->allowMemoryAccessCalled, 1); EXPECT_EQ(pageFaultManager->protectMemoryCalled, 0); EXPECT_EQ(pageFaultManager->transferToCpuCalled, 0); @@ -506,13 +464,13 @@ TEST_F(PageFaultManagerTest, givenAllocsMovedToGpuDomainWhenVerifyingPageFaultTh pageFaultManager->moveAllocationsWithinUMAllocsManagerToGpuDomain(unifiedMemoryManager.get()); EXPECT_EQ(unifiedMemoryManager->nonGpuDomainAllocs.size(), 0u); - pageFaultManager->verifyAndHandlePageFault(alloc2, true); + pageFaultManager->verifyPageFault(alloc2); EXPECT_EQ(unifiedMemoryManager->nonGpuDomainAllocs.size(), 1u); EXPECT_EQ(unifiedMemoryManager->nonGpuDomainAllocs[0], alloc2); pageFaultManager->gpuDomainHandler = &MockPageFaultManager::unprotectAndTransferMemory; - pageFaultManager->verifyAndHandlePageFault(alloc1, true); + pageFaultManager->verifyPageFault(alloc1); EXPECT_EQ(unifiedMemoryManager->nonGpuDomainAllocs.size(), 2u); EXPECT_EQ(unifiedMemoryManager->nonGpuDomainAllocs[1], alloc1); } @@ -531,13 +489,13 @@ TEST_F(PageFaultManagerTest, givenAllocsFromCpuDomainWhenVerifyingPageFaultThenD EXPECT_EQ(unifiedMemoryManager->nonGpuDomainAllocs.size(), 0u); pageFaultManager->memoryData.at(alloc2).domain = PageFaultManager::AllocationDomain::none; - pageFaultManager->verifyAndHandlePageFault(alloc2, true); + pageFaultManager->verifyPageFault(alloc2); 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 = PageFaultManager::AllocationDomain::none; - pageFaultManager->verifyAndHandlePageFault(alloc1, true); + pageFaultManager->verifyPageFault(alloc1); EXPECT_EQ(pageFaultManager->memoryData.at(alloc1).domain, PageFaultManager::AllocationDomain::cpu); EXPECT_EQ(unifiedMemoryManager->nonGpuDomainAllocs.size(), 0u); } @@ -556,7 +514,7 @@ TEST_F(PageFaultManagerTest, givenTbxWhenVerifyingPagefaultThenVerifyPagefaultUn EXPECT_EQ(pageFaultManager->protectMemoryCalled, 1); EXPECT_EQ(pageFaultManager->transferToGpuCalled, 0); - pageFaultManager->verifyAndHandlePageFault(alloc, true); + pageFaultManager->verifyPageFault(alloc); EXPECT_EQ(pageFaultManager->allowMemoryAccessCalled, 1); EXPECT_EQ(pageFaultManager->transferToCpuCalled, 1); EXPECT_EQ(pageFaultManager->allowedMemoryAccessAddress, alloc); @@ -583,7 +541,7 @@ TEST_F(PageFaultManagerTest, whenVerifyingPagefaultWithPrintUsmSharedMigrationDe EXPECT_EQ(pageFaultManager->protectedMemoryAccessAddress, alloc); EXPECT_EQ(pageFaultManager->protectedSize, 10u); - pageFaultManager->verifyAndHandlePageFault(alloc, true); + pageFaultManager->verifyPageFault(alloc); std::string output = testing::internal::GetCapturedStdout(); // stop capturing @@ -622,7 +580,7 @@ TEST_F(PageFaultManagerTest, givenTbxWhenVerifyingPagefaultWithPrintUsmSharedMig EXPECT_EQ(pageFaultManager->protectedMemoryAccessAddress, alloc); EXPECT_EQ(pageFaultManager->protectedSize, 10u); - pageFaultManager->verifyAndHandlePageFault(alloc, true); + pageFaultManager->verifyPageFault(alloc); std::string output = testing::internal::GetCapturedStdout(); // stop capturing @@ -656,7 +614,7 @@ TEST_F(PageFaultManagerTest, givenTbxAndInitialPlacementGpuWhenVerifyingPagefaul EXPECT_EQ(pageFaultManager->protectedSize, 10u); EXPECT_EQ(pageFaultManager->memoryData.size(), 1u); - pageFaultManager->verifyAndHandlePageFault(alloc, true); + pageFaultManager->verifyPageFault(alloc); EXPECT_EQ(pageFaultManager->allowMemoryAccessCalled, 1); EXPECT_EQ(pageFaultManager->transferToGpuCalled, 0); @@ -712,7 +670,7 @@ TEST_F(PageFaultManagerTest, givenAllocationMovedToGpuDomainWhenVerifyingPagefau EXPECT_EQ(pageFaultManager->transferToGpuCalled, 0); EXPECT_EQ(unifiedMemoryManager->nonGpuDomainAllocs.size(), 0u); - pageFaultManager->verifyAndHandlePageFault(alloc, true); + pageFaultManager->verifyPageFault(alloc); EXPECT_EQ(pageFaultManager->allowMemoryAccessCalled, 1); EXPECT_EQ(pageFaultManager->transferToCpuCalled, 1); EXPECT_EQ(pageFaultManager->transferToGpuCalled, 0); @@ -724,35 +682,6 @@ TEST_F(PageFaultManagerTest, givenAllocationMovedToGpuDomainWhenVerifyingPagefau EXPECT_EQ(unifiedMemoryManager->nonGpuDomainAllocs[0], alloc); } -TEST_F(PageFaultManagerTest, givenAllocationMovedToGpuDomainWhenVerifyingPagefaultWithHandlePageFaultFalseThenAllocationIsNotMovedToCpuDomain) { - void *cmdQ = reinterpret_cast(0xFFFF); - void *alloc = reinterpret_cast(0x1); - - memoryProperties.allocFlags.usmInitialPlacementGpu = 1; - pageFaultManager->insertAllocation(alloc, 10, unifiedMemoryManager.get(), cmdQ, memoryProperties); - EXPECT_EQ(pageFaultManager->transferToCpuCalled, 0); - EXPECT_EQ(pageFaultManager->memoryData.size(), 1u); - EXPECT_EQ(pageFaultManager->protectMemoryCalled, 1); - EXPECT_EQ(pageFaultManager->protectedMemoryAccessAddress, alloc); - EXPECT_EQ(pageFaultManager->protectedSize, 10u); - EXPECT_EQ(unifiedMemoryManager->nonGpuDomainAllocs.size(), 1u); - EXPECT_EQ(unifiedMemoryManager->nonGpuDomainAllocs[0], alloc); - - pageFaultManager->moveAllocationToGpuDomain(alloc); - EXPECT_EQ(pageFaultManager->allowMemoryAccessCalled, 0); - EXPECT_EQ(pageFaultManager->protectMemoryCalled, 1); - EXPECT_EQ(pageFaultManager->transferToCpuCalled, 0); - EXPECT_EQ(pageFaultManager->transferToGpuCalled, 0); - EXPECT_EQ(unifiedMemoryManager->nonGpuDomainAllocs.size(), 0u); - - pageFaultManager->verifyAndHandlePageFault(alloc, false); - EXPECT_EQ(pageFaultManager->allowMemoryAccessCalled, 0); - EXPECT_EQ(pageFaultManager->protectMemoryCalled, 1); - EXPECT_EQ(pageFaultManager->transferToCpuCalled, 0); - EXPECT_EQ(pageFaultManager->transferToGpuCalled, 0); - EXPECT_EQ(unifiedMemoryManager->nonGpuDomainAllocs.size(), 0u); -} - TEST_F(PageFaultManagerTest, givenUnifiedMemoryAllocWhenSetAubWritableIsCalledThenAllocIsAubWritable) { REQUIRE_SVM_OR_SKIP(executionEnvironment.rootDeviceEnvironments[0]->getHardwareInfo()); @@ -798,7 +727,7 @@ TEST_F(PageFaultManagerTest, givenUnifiedMemoryAllocWhenMigratedBetweenCpuAndGpu EXPECT_EQ(pageFaultManager->protectedMemoryAccessAddress, ptr); EXPECT_EQ(pageFaultManager->protectedSize, 10u); - pageFaultManager->verifyAndHandlePageFault(ptr, true); + pageFaultManager->verifyPageFault(ptr); EXPECT_EQ(pageFaultManager->transferToCpuCalled, 1); EXPECT_EQ(pageFaultManager->allowMemoryAccessCalled, 1); EXPECT_EQ(pageFaultManager->setCpuAllocEvictableCalled, 2); diff --git a/shared/test/unit_test/page_fault_manager/linux/cpu_page_fault_manager_linux_tests.cpp b/shared/test/unit_test/page_fault_manager/linux/cpu_page_fault_manager_linux_tests.cpp index f5e8846797..01fba78ec3 100644 --- a/shared/test/unit_test/page_fault_manager/linux/cpu_page_fault_manager_linux_tests.cpp +++ b/shared/test/unit_test/page_fault_manager/linux/cpu_page_fault_manager_linux_tests.cpp @@ -125,14 +125,10 @@ class MockFailPageFaultManager : public PageFaultManagerLinux { using PageFaultManagerLinux::checkFaultHandlerFromPageFaultManager; using PageFaultManagerLinux::PageFaultManagerLinux; using PageFaultManagerLinux::previousHandlerRestored; - using PageFaultManagerLinux::previousPageFaultHandlers; using PageFaultManagerLinux::registerFaultHandler; - bool verifyAndHandlePageFault(void *ptr, bool handlePageFault) override { + bool verifyPageFault(void *ptr) override { verifyCalled = true; - if (handlePageFault) { - numPageFaultHandled++; - } return false; } @@ -140,38 +136,22 @@ class MockFailPageFaultManager : public PageFaultManagerLinux { mockCalled = true; } - static void mockPageFaultHandler2(int signal, siginfo_t *info, void *context) { - mockCalled2 = true; - pageFaultHandlerWrapper(signal, info, context); - } - static void mockPageFaultSimpleHandler(int signal) { simpleMockCalled = true; } - static void mockPageFaultSimpleHandler2(int signal) { - simpleMockCalled2 = true; - } - ~MockFailPageFaultManager() override { mockCalled = false; - mockCalled2 = false; simpleMockCalled = false; - simpleMockCalled2 = false; } static bool mockCalled; - static bool mockCalled2; static bool simpleMockCalled; - static bool simpleMockCalled2; bool verifyCalled = false; - int numPageFaultHandled = 0; }; bool MockFailPageFaultManager::mockCalled = false; -bool MockFailPageFaultManager::mockCalled2 = false; bool MockFailPageFaultManager::simpleMockCalled = false; -bool MockFailPageFaultManager::simpleMockCalled2 = false; TEST_F(PageFaultManagerLinuxTest, givenPageFaultThatNEOShouldNotHandleAndSigInfoFlagSetThenSaSigactionIsCalled) { struct sigaction previousHandler = {}; @@ -204,7 +184,6 @@ TEST_F(PageFaultManagerLinuxTest, givenPageFaultThatNEOShouldNotHandleThenSaHand auto mockPageFaultManager = std::make_unique(); EXPECT_FALSE(MockFailPageFaultManager::mockCalled); EXPECT_FALSE(MockFailPageFaultManager::simpleMockCalled); - EXPECT_EQ(1ul, mockPageFaultManager->previousPageFaultHandlers.size()); std::raise(SIGSEGV); EXPECT_TRUE(mockPageFaultManager->verifyCalled); @@ -264,170 +243,3 @@ TEST_F(PageFaultManagerLinuxTest, givenDefaultSaHandlerWhenOverwritingNewHandler mockPageFaultManager.reset(); sigaction(SIGSEGV, &originalHandler, nullptr); } - -TEST_F(PageFaultManagerLinuxTest, givenPageFaultThatNEOShouldNotHandleWhenRegisterSimpleHandlerTwiceThenSimpleHandlerIsRegisteredOnce) { - struct sigaction previousHandler = {}; - struct sigaction previousHandler2 = {}; - struct sigaction mockHandler = {}; - struct sigaction mockHandler2 = {}; - mockHandler.sa_handler = MockFailPageFaultManager::mockPageFaultSimpleHandler; - auto retVal = sigaction(SIGSEGV, &mockHandler, &previousHandler); - EXPECT_EQ(retVal, 0); - - auto mockPageFaultManager = std::make_unique(); - EXPECT_FALSE(MockFailPageFaultManager::mockCalled); - EXPECT_FALSE(MockFailPageFaultManager::simpleMockCalled); - EXPECT_EQ(1ul, mockPageFaultManager->previousPageFaultHandlers.size()); - - std::raise(SIGSEGV); - EXPECT_TRUE(mockPageFaultManager->verifyCalled); - EXPECT_EQ(1, mockPageFaultManager->numPageFaultHandled); - EXPECT_FALSE(MockFailPageFaultManager::mockCalled); - EXPECT_TRUE(MockFailPageFaultManager::simpleMockCalled); - - MockFailPageFaultManager::simpleMockCalled = false; - - mockHandler2.sa_handler = MockFailPageFaultManager::mockPageFaultSimpleHandler; - retVal = sigaction(SIGSEGV, &mockHandler2, &previousHandler2); - EXPECT_EQ(retVal, 0); - mockPageFaultManager->registerFaultHandler(); - - std::raise(SIGSEGV); - EXPECT_TRUE(mockPageFaultManager->verifyCalled); - EXPECT_EQ(2, mockPageFaultManager->numPageFaultHandled); - EXPECT_FALSE(MockFailPageFaultManager::mockCalled); - EXPECT_TRUE(MockFailPageFaultManager::simpleMockCalled); - EXPECT_EQ(1ul, mockPageFaultManager->previousPageFaultHandlers.size()); - - mockPageFaultManager.reset(); - sigaction(SIGSEGV, &previousHandler, nullptr); -} - -TEST_F(PageFaultManagerLinuxTest, givenPageFaultThatNEOShouldNotHandleWhenRegisterTwoSimpleHandlersThenBothHandlersAreRegistered) { - struct sigaction previousHandler = {}; - struct sigaction previousHandler2 = {}; - struct sigaction mockHandler = {}; - struct sigaction mockHandler2 = {}; - mockHandler.sa_handler = MockFailPageFaultManager::mockPageFaultSimpleHandler; - auto retVal = sigaction(SIGSEGV, &mockHandler, &previousHandler); - EXPECT_EQ(retVal, 0); - - auto mockPageFaultManager = std::make_unique(); - EXPECT_FALSE(MockFailPageFaultManager::mockCalled); - EXPECT_FALSE(MockFailPageFaultManager::mockCalled2); - EXPECT_FALSE(MockFailPageFaultManager::simpleMockCalled); - EXPECT_FALSE(MockFailPageFaultManager::simpleMockCalled2); - EXPECT_EQ(1ul, mockPageFaultManager->previousPageFaultHandlers.size()); - - std::raise(SIGSEGV); - EXPECT_TRUE(mockPageFaultManager->verifyCalled); - EXPECT_FALSE(MockFailPageFaultManager::mockCalled); - EXPECT_FALSE(MockFailPageFaultManager::mockCalled2); - EXPECT_TRUE(MockFailPageFaultManager::simpleMockCalled); - EXPECT_FALSE(MockFailPageFaultManager::simpleMockCalled2); - - MockFailPageFaultManager::simpleMockCalled = false; - - mockHandler2.sa_handler = MockFailPageFaultManager::mockPageFaultSimpleHandler2; - retVal = sigaction(SIGSEGV, &mockHandler2, &previousHandler2); - EXPECT_EQ(retVal, 0); - mockPageFaultManager->registerFaultHandler(); - - std::raise(SIGSEGV); - EXPECT_TRUE(mockPageFaultManager->verifyCalled); - EXPECT_FALSE(MockFailPageFaultManager::mockCalled); - EXPECT_FALSE(MockFailPageFaultManager::mockCalled2); - EXPECT_FALSE(MockFailPageFaultManager::simpleMockCalled); - EXPECT_TRUE(MockFailPageFaultManager::simpleMockCalled2); - EXPECT_EQ(2ul, mockPageFaultManager->previousPageFaultHandlers.size()); - - mockPageFaultManager.reset(); - sigaction(SIGSEGV, &previousHandler, nullptr); -} - -TEST_F(PageFaultManagerLinuxTest, givenPageFaultThatNEOShouldNotHandleWhenRegisterTwoHandlersThenBothHandlersAreRegistered) { - struct sigaction previousHandler = {}; - struct sigaction previousHandler2 = {}; - struct sigaction mockHandler = {}; - struct sigaction mockHandler2 = {}; - mockHandler.sa_flags = SA_SIGINFO; - mockHandler.sa_sigaction = MockFailPageFaultManager::mockPageFaultHandler; - auto retVal = sigaction(SIGSEGV, &mockHandler, &previousHandler); - EXPECT_EQ(retVal, 0); - - auto mockPageFaultManager = std::make_unique(); - EXPECT_FALSE(MockFailPageFaultManager::mockCalled); - EXPECT_FALSE(MockFailPageFaultManager::mockCalled2); - EXPECT_FALSE(MockFailPageFaultManager::simpleMockCalled); - EXPECT_FALSE(MockFailPageFaultManager::simpleMockCalled2); - EXPECT_EQ(1ul, mockPageFaultManager->previousPageFaultHandlers.size()); - - std::raise(SIGSEGV); - EXPECT_TRUE(mockPageFaultManager->verifyCalled); - EXPECT_TRUE(MockFailPageFaultManager::mockCalled); - EXPECT_FALSE(MockFailPageFaultManager::mockCalled2); - EXPECT_FALSE(MockFailPageFaultManager::simpleMockCalled); - EXPECT_FALSE(MockFailPageFaultManager::simpleMockCalled2); - - MockFailPageFaultManager::mockCalled = false; - - mockHandler2.sa_flags = SA_SIGINFO; - mockHandler2.sa_sigaction = MockFailPageFaultManager::mockPageFaultHandler2; - retVal = sigaction(SIGSEGV, &mockHandler2, &previousHandler2); - EXPECT_EQ(retVal, 0); - mockPageFaultManager->registerFaultHandler(); - - std::raise(SIGSEGV); - EXPECT_TRUE(mockPageFaultManager->verifyCalled); - EXPECT_TRUE(MockFailPageFaultManager::mockCalled); - EXPECT_TRUE(MockFailPageFaultManager::mockCalled2); - EXPECT_FALSE(MockFailPageFaultManager::simpleMockCalled); - EXPECT_FALSE(MockFailPageFaultManager::simpleMockCalled2); - EXPECT_EQ(2ul, mockPageFaultManager->previousPageFaultHandlers.size()); - - mockPageFaultManager.reset(); - sigaction(SIGSEGV, &previousHandler, nullptr); -} - -TEST_F(PageFaultManagerLinuxTest, givenPageFaultThatNEOShouldNotHandleWhenRegisterSimpleAndRegularHandlersThenBothHandlersAreRegistered) { - struct sigaction previousHandler = {}; - struct sigaction previousHandler2 = {}; - struct sigaction mockHandler = {}; - struct sigaction mockHandler2 = {}; - mockHandler.sa_handler = MockFailPageFaultManager::mockPageFaultSimpleHandler; - auto retVal = sigaction(SIGSEGV, &mockHandler, &previousHandler); - EXPECT_EQ(retVal, 0); - - auto mockPageFaultManager = std::make_unique(); - EXPECT_FALSE(MockFailPageFaultManager::mockCalled); - EXPECT_FALSE(MockFailPageFaultManager::mockCalled2); - EXPECT_FALSE(MockFailPageFaultManager::simpleMockCalled); - EXPECT_FALSE(MockFailPageFaultManager::simpleMockCalled2); - EXPECT_EQ(1ul, mockPageFaultManager->previousPageFaultHandlers.size()); - - std::raise(SIGSEGV); - EXPECT_TRUE(mockPageFaultManager->verifyCalled); - EXPECT_FALSE(MockFailPageFaultManager::mockCalled); - EXPECT_FALSE(MockFailPageFaultManager::mockCalled2); - EXPECT_TRUE(MockFailPageFaultManager::simpleMockCalled); - EXPECT_FALSE(MockFailPageFaultManager::simpleMockCalled2); - - MockFailPageFaultManager::simpleMockCalled = false; - - mockHandler2.sa_flags = SA_SIGINFO; - mockHandler2.sa_sigaction = MockFailPageFaultManager::mockPageFaultHandler2; - retVal = sigaction(SIGSEGV, &mockHandler2, &previousHandler2); - EXPECT_EQ(retVal, 0); - mockPageFaultManager->registerFaultHandler(); - - std::raise(SIGSEGV); - EXPECT_TRUE(mockPageFaultManager->verifyCalled); - EXPECT_FALSE(MockFailPageFaultManager::mockCalled); - EXPECT_TRUE(MockFailPageFaultManager::mockCalled2); - EXPECT_TRUE(MockFailPageFaultManager::simpleMockCalled); - EXPECT_FALSE(MockFailPageFaultManager::simpleMockCalled2); - EXPECT_EQ(2ul, mockPageFaultManager->previousPageFaultHandlers.size()); - - mockPageFaultManager.reset(); - sigaction(SIGSEGV, &previousHandler, nullptr); -} 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 b24b1f4ade..c125a0c9a8 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 @@ -76,7 +76,7 @@ class MockFailPageFaultManager : public PageFaultManagerWindows { using PageFaultManagerWindows::checkFaultHandlerFromPageFaultManager; using PageFaultManagerWindows::PageFaultManagerWindows; - bool verifyAndHandlePageFault(void *ptr, bool handlePageFault) override { + bool verifyPageFault(void *ptr) override { verifyCalled = true; return false; }