intel/compute-runtime
1
0
Fork 0
mirror of https://github.com/intel/compute-runtime.git synced 2026-01-07 12:42:54 +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

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