intel/compute-runtime
1
0
Fork 0
mirror of https://github.com/intel/compute-runtime.git synced 2025-12-28 00:03:14 +08:00
Code Issues Packages Projects Releases Wiki Activity

Revert "feature: capture multiple cpu pagefault handler"

Browse Source 
This reverts commit 44f2912195.

Signed-off-by: Compute-Runtime-Validation <compute-runtime-validation@intel.com>
This commit is contained in:
Compute-Runtime-Validation
2024-09-03 04:46:42 +02:00
committed by Compute-Runtime-Automation
parent b6eb4792dc
commit 5569ebbe1f
11 changed files with 35 additions and 317 deletions
Download Patch File Download Diff File Expand all files Collapse all files

2
shared/source/debug_settings/debug_variables_base.inl
View File

@@ -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")

8
shared/source/page_fault_manager/cpu_page_fault_manager.cpp
View File

@@ -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<SpinLock> 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;
}
}

2
shared/source/page_fault_manager/cpu_page_fault_manager.h
View File

@@ -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);

30
shared/source/page_fault_manager/linux/cpu_page_fault_manager_linux.cpp
View File

@@ -13,7 +13,6 @@
#include "shared/source/helpers/debug_helpers.h"
#include "shared/source/memory_manager/memory_operations_handler.h"
#include <algorithm>
#include <sys/mman.h>
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<int>(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) {

4
shared/source/page_fault_manager/linux/cpu_page_fault_manager_linux.h
View File

@@ -11,7 +11,6 @@
#include <csignal>
#include <functional>
#include <vector>
namespace NEO {
class PageFaultManagerLinux : public PageFaultManager {
@@ -36,9 +35,8 @@ class PageFaultManagerLinux : public PageFaultManager {
static std::function<void(int signal, siginfo_t *info, void *context)> pageFaultHandler;
std::vector<struct sigaction> previousPageFaultHandlers;
struct sigaction previousPageFaultHandler = {};
bool evictMemoryAfterCopy = false;
int handlerIndex = 0;
};
} // namespace NEO

2
shared/source/page_fault_manager/windows/cpu_page_fault_manager_windows.cpp
View File

@@ -39,7 +39,7 @@ bool PageFaultManagerWindows::checkFaultHandlerFromPageFaultManager() {
void PageFaultManagerWindows::registerFaultHandler() {
pageFaultHandler = [this](struct _EXCEPTION_POINTERS *exceptionInfo) {
if (static_cast<long>(exceptionInfo->ExceptionRecord->ExceptionCode) == EXCEPTION_ACCESS_VIOLATION) {
if (this->verifyAndHandlePageFault(reinterpret_cast<void *>(exceptionInfo->ExceptionRecord->ExceptionInformation[1]), true)) {
if (this->verifyPageFault(reinterpret_cast<void *>(exceptionInfo->ExceptionRecord->ExceptionInformation[1]))) {
// this is our fault that we serviced, continue app execution
return EXCEPTION_CONTINUE_EXECUTION;
}

9
shared/test/common/mocks/mock_cpu_page_fault_manager.h
View File

@@ -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;
};
@@ -130,8 +129,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);
}

2
shared/test/common/test_files/igdrcl.config
View File

@@ -27,7 +27,7 @@ SetCommandStreamReceiver = -1
TbxPort = 4321
TbxFrontdoorMode = 0
FlattenBatchBufferForAUBDump = 0
RegisterPageFaultHandlerOnMigration = 0
RegisterPageFaultHandlerOnMigration = 1
AddPatchInfoCommentsForAUBDump = 0
UseAubStream = 1
AUBDumpAllocsOnEnqueueReadOnly = 0

101
shared/test/unit_test/page_fault_manager/cpu_page_fault_manager_tests.cpp
View File

@@ -253,8 +253,6 @@ TEST_F(PageFaultManagerTest, givenUnifiedMemoryAllocWhenMoveToGpuDomainThenTrans
}
TEST_F(PageFaultManagerTest, givenUnifiedMemoryAllocWhenMoveToGpuDomainTwiceThenCheckFaultHandlerFromPageFaultManagerReturnsTrue) {
DebugManagerStateRestore restorer;
debugManager.flags.RegisterPageFaultHandlerOnMigration.set(true);
void *cmdQ = reinterpret_cast<void *>(0xFFFF);
void *alloc1 = reinterpret_cast<void *>(0x1);
void *alloc2 = reinterpret_cast<void *>(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<void *>(0xFFFF);
void *alloc1 = reinterpret_cast<void *>(0x1);
void *alloc2 = reinterpret_cast<void *>(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<void *>(0xFFFF);
void *alloc = reinterpret_cast<void *>(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);

190
shared/test/unit_test/page_fault_manager/linux/cpu_page_fault_manager_linux_tests.cpp
View File

@@ -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<MockFailPageFaultManager>();
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<MockFailPageFaultManager>();
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<MockFailPageFaultManager>();
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<MockFailPageFaultManager>();
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<MockFailPageFaultManager>();
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);
}

2
shared/test/unit_test/page_fault_manager/windows/cpu_page_fault_manager_windows_tests.cpp
View File

@@ -70,7 +70,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;
}