Broadcast signal to all threads while handling USM pagefault

LukaszJobczyk · Compute-Runtime-Automation · commit 5739d526c469 · 2020-07-08T12:54:01.000+02:00
Related-To: NEO-4721

Change-Id: I77185f8db2576f626c1b6b5615ab5d8f9b22076f
Signed-off-by: Lukasz Jobczyk &lt;lukasz.jobczyk@intel.com&gt;
diff --git a/shared/source/page_fault_manager/cpu_page_fault_manager.cpp b/shared/source/page_fault_manager/cpu_page_fault_manager.cpp
@@ -66,6 +66,7 @@ bool PageFaultManager::verifyPageFault(void *ptr) {
         auto allocPtr = alloc.first;
         auto &pageFaultData = alloc.second;
         if (ptr >= allocPtr && ptr < ptrOffset(allocPtr, pageFaultData.size)) {
+            this->broadcastWaitSignal();
             this->allowCPUMemoryAccess(allocPtr, pageFaultData.size);
             this->setAubWritable(true, allocPtr, pageFaultData.unifiedMemoryManager);
             this->transferToCpu(allocPtr, pageFaultData.size, pageFaultData.cmdQ);
@@ -81,4 +82,9 @@ void PageFaultManager::setAubWritable(bool writable, void *ptr, SVMAllocsManager
     auto gpuAlloc = unifiedMemoryManager->getSVMAlloc(ptr)->gpuAllocations.getDefaultGraphicsAllocation();
     gpuAlloc->setAubWritable(writable, GraphicsAllocation::allBanks);
 }
+
+void PageFaultManager::waitForCopy() {
+    std::unique_lock<SpinLock> lock{mtx};
+}
+
 } // namespace NEO
diff --git a/shared/source/page_fault_manager/cpu_page_fault_manager.h b/shared/source/page_fault_manager/cpu_page_fault_manager.h
@@ -38,6 +38,9 @@ class PageFaultManager : public NonCopyableOrMovableClass {
     virtual void allowCPUMemoryAccess(void *ptr, size_t size) = 0;
     virtual void protectCPUMemoryAccess(void *ptr, size_t size) = 0;
 
+    virtual void broadcastWaitSignal() = 0;
+    MOCKABLE_VIRTUAL void waitForCopy();
+
     MOCKABLE_VIRTUAL bool verifyPageFault(void *ptr);
     MOCKABLE_VIRTUAL void transferToCpu(void *ptr, size_t size, void *cmdQ);
     MOCKABLE_VIRTUAL void transferToGpu(void *ptr, void *cmdQ);
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
@@ -9,7 +9,11 @@
 
 #include "shared/source/helpers/debug_helpers.h"
 
+#include <dirent.h>
 #include <sys/mman.h>
+#include <sys/syscall.h>
+#include <sys/types.h>
+#include <unistd.h>
 
 namespace NEO {
 std::unique_ptr<PageFaultManager> PageFaultManager::create() {
@@ -20,21 +24,30 @@ std::function<void(int signal, siginfo_t *info, void *context)> PageFaultManager
 
 PageFaultManagerLinux::PageFaultManagerLinux() {
     pageFaultHandler = [&](int signal, siginfo_t *info, void *context) {
-        if (!this->verifyPageFault(info->si_addr)) {
+        if (signal == SIGUSR1) {
+            this->waitForCopy();
+        } else if (!this->verifyPageFault(info->si_addr)) {
             callPreviousHandler(signal, info, context);
         }
     };
 
     struct sigaction pageFaultManagerHandler = {};
     pageFaultManagerHandler.sa_flags = SA_SIGINFO;
     pageFaultManagerHandler.sa_sigaction = pageFaultHandlerWrapper;
-    auto retVal = sigaction(SIGSEGV, &pageFaultManagerHandler, &previousHandler);
+
+    auto retVal = sigaction(SIGSEGV, &pageFaultManagerHandler, &previousPageFaultHandler);
+    UNRECOVERABLE_IF(retVal != 0);
+
+    retVal = sigaction(SIGUSR1, &pageFaultManagerHandler, &previousUserSignalHandler);
     UNRECOVERABLE_IF(retVal != 0);
 }
 
 PageFaultManagerLinux::~PageFaultManagerLinux() {
     if (!previousHandlerRestored) {
-        auto retVal = sigaction(SIGSEGV, &previousHandler, nullptr);
+        auto retVal = sigaction(SIGSEGV, &previousPageFaultHandler, nullptr);
+        UNRECOVERABLE_IF(retVal != 0);
+
+        retVal = sigaction(SIGUSR1, &previousUserSignalHandler, nullptr);
         UNRECOVERABLE_IF(retVal != 0);
     }
 }
@@ -54,18 +67,50 @@ void PageFaultManagerLinux::protectCPUMemoryAccess(void *ptr, size_t size) {
 }
 
 void PageFaultManagerLinux::callPreviousHandler(int signal, siginfo_t *info, void *context) {
-    if (previousHandler.sa_flags & SA_SIGINFO) {
-        previousHandler.sa_sigaction(signal, info, context);
+    if (previousPageFaultHandler.sa_flags & SA_SIGINFO) {
+        previousPageFaultHandler.sa_sigaction(signal, info, context);
     } else {
-        if (previousHandler.sa_handler == SIG_DFL) {
-            auto retVal = sigaction(SIGSEGV, &previousHandler, nullptr);
+        if (previousPageFaultHandler.sa_handler == SIG_DFL) {
+            auto retVal = sigaction(SIGSEGV, &previousPageFaultHandler, nullptr);
             UNRECOVERABLE_IF(retVal != 0);
             previousHandlerRestored = true;
-        } else if (previousHandler.sa_handler == SIG_IGN) {
+        } else if (previousPageFaultHandler.sa_handler == SIG_IGN) {
             return;
         } else {
-            previousHandler.sa_handler(signal);
+            previousPageFaultHandler.sa_handler(signal);
+        }
+    }
+}
+
+/* This function is a WA for USM issue in multithreaded environment
+   While handling page fault, before copy starts, user signal (SIGUSR1)
+   is broadcasted to ensure that every thread received signal and is
+   stucked on PageFaultHandler's mutex before copy from GPU to CPU proceeds. */
+void PageFaultManagerLinux::broadcastWaitSignal() {
+    auto selfThreadId = syscall(__NR_gettid);
+
+    auto procDir = opendir("/proc/self/task");
+    UNRECOVERABLE_IF(!procDir);
+
+    struct dirent *dirEntry;
+    while ((dirEntry = readdir(procDir)) != NULL) {
+        if (dirEntry->d_name[0] == '.') {
+            continue;
         }
+
+        int threadId = atoi(dirEntry->d_name);
+        if (threadId == selfThreadId) {
+            continue;
+        }
+
+        sendSignalToThread(threadId);
     }
+
+    closedir(procDir);
+}
+
+void PageFaultManagerLinux::sendSignalToThread(int threadId) {
+    syscall(SYS_tkill, threadId, SIGUSR1);
 }
+
 } // namespace NEO
diff --git a/shared/source/page_fault_manager/linux/cpu_page_fault_manager_linux.h b/shared/source/page_fault_manager/linux/cpu_page_fault_manager_linux.h
@@ -24,10 +24,15 @@ class PageFaultManagerLinux : public PageFaultManager {
     void allowCPUMemoryAccess(void *ptr, size_t size) override;
     void protectCPUMemoryAccess(void *ptr, size_t size) override;
 
+    void broadcastWaitSignal() override;
+    MOCKABLE_VIRTUAL void sendSignalToThread(int threadId);
+
     void callPreviousHandler(int signal, siginfo_t *info, void *context);
     bool previousHandlerRestored = false;
 
     static std::function<void(int signal, siginfo_t *info, void *context)> pageFaultHandler;
-    struct sigaction previousHandler = {};
+
+    struct sigaction previousPageFaultHandler = {};
+    struct sigaction previousUserSignalHandler = {};
 };
 } // 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
@@ -50,4 +50,7 @@ void PageFaultManagerWindows::protectCPUMemoryAccess(void *ptr, size_t size) {
     auto retVal = VirtualProtect(ptr, size, PAGE_NOACCESS, &previousState);
     UNRECOVERABLE_IF(!retVal);
 }
+
+void PageFaultManagerWindows::broadcastWaitSignal() {}
+
 } // namespace NEO
diff --git a/shared/source/page_fault_manager/windows/cpu_page_fault_manager_windows.h b/shared/source/page_fault_manager/windows/cpu_page_fault_manager_windows.h
@@ -25,6 +25,8 @@ class PageFaultManagerWindows : public PageFaultManager {
     void allowCPUMemoryAccess(void *ptr, size_t size) override;
     void protectCPUMemoryAccess(void *ptr, size_t size) override;
 
+    void broadcastWaitSignal() override;
+
     static std::function<LONG(struct _EXCEPTION_POINTERS *exceptionInfo)> pageFaultHandler;
     PVOID previousHandler;
 };
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
@@ -13,12 +13,59 @@
 
 #include <csignal>
 #include <sys/mman.h>
+#include <sys/syscall.h>
+#include <thread>
+#include <unistd.h>
 
 using namespace NEO;
 
 using PageFaultManagerLinuxTest = PageFaultManagerConfigFixture;
 using MockPageFaultManagerLinux = MockPageFaultManagerHandlerInvoke<PageFaultManagerLinux>;
 
+struct UserSignalMockPageFaultManagerLinux : public PageFaultManagerLinux {
+    using PageFaultManager::verifyPageFault;
+
+    UserSignalMockPageFaultManagerLinux() {
+        ownThread = std::thread([&]() {
+            while (!waitForCopyCalled) {
+                if (ownThreadId == -1) {
+                    ownThreadId = static_cast<int>(syscall(__NR_gettid));
+                }
+            }
+        });
+        while (ownThreadId == -1) {
+        }
+    }
+
+    void allowCPUMemoryAccess(void *ptr, size_t size) override {}
+    void transferToCpu(void *ptr, size_t size, void *cmdQ) override {}
+    void setAubWritable(bool writable, void *ptr, SVMAllocsManager *unifiedMemoryManager) override {}
+
+    void sendSignalToThread(int threadId) override {
+        PageFaultManagerLinux::sendSignalToThread(ownThreadId);
+    }
+
+    void waitForCopy() override {
+        PageFaultManagerLinux::waitForCopy();
+        waitForCopyCalled = true;
+    }
+
+    std::thread ownThread;
+    int ownThreadId = -1;
+    bool waitForCopyCalled = false;
+};
+
+TEST_F(PageFaultManagerLinuxTest, whenVeryfyingPageFaultThenUserSignalIsSentToOtherThreads) {
+    auto pageFaultManager = std::make_unique<UserSignalMockPageFaultManagerLinux>();
+
+    auto alloc = reinterpret_cast<void *>(0x1);
+    pageFaultManager->insertAllocation(alloc, 10, nullptr, nullptr);
+    pageFaultManager->verifyPageFault(alloc);
+    pageFaultManager->ownThread.join();
+
+    EXPECT_TRUE(pageFaultManager->waitForCopyCalled);
+}
+
 TEST_F(PageFaultManagerLinuxTest, whenPageFaultIsRaisedThenHandlerIsInvoked) {
     auto pageFaultManager = std::make_unique<MockPageFaultManagerLinux>();
     EXPECT_FALSE(pageFaultManager->handlerInvoked);
diff --git a/shared/test/unit_test/page_fault_manager/mock_cpu_page_fault_manager.h b/shared/test/unit_test/page_fault_manager/mock_cpu_page_fault_manager.h
@@ -49,6 +49,7 @@ class MockPageFaultManager : public PageFaultManager {
     void baseGpuTransfer(void *ptr, void *cmdQ) {
         PageFaultManager::transferToGpu(ptr, cmdQ);
     }
+    void broadcastWaitSignal() override {}
 
     int allowMemoryAccessCalled = 0;
     int protectMemoryCalled = 0;

Original file line number	Diff line number	Diff line change
`@@ -50,4 +50,7 @@ void PageFaultManagerWindows::protectCPUMemoryAccess(void *ptr, size_t size) {`
`50`	`50`	`auto retVal = VirtualProtect(ptr, size, PAGE_NOACCESS, &previousState);`
`51`	`51`	`UNRECOVERABLE_IF(!retVal);`
`52`	`52`	`}`
	`53`	`+`
	`54`	`+void PageFaultManagerWindows::broadcastWaitSignal() {}`
	`55`	`+`
`53`	`56`	`} // namespace NEO`
Original file line number	Diff line number	Diff line change
`@@ -49,6 +49,7 @@ class MockPageFaultManager : public PageFaultManager {`
`49`	`49`	`void baseGpuTransfer(void ptr, void cmdQ) {`
`50`	`50`	`PageFaultManager::transferToGpu(ptr, cmdQ);`
`51`	`51`	`}`
	`52`	`+ void broadcastWaitSignal() override {}`
`52`	`53`
`53`	`54`	`int allowMemoryAccessCalled = 0;`
`54`	`55`	`int protectMemoryCalled = 0;`