test: add support for alarm in Windows ULT

Signed-off-by: Mateusz Jablonski <[email protected]>

Author: JablonskiMateusz

opencl/test/unit_test/mock_gl/windows/mock_opengl32.cpp

@@ -215,7 +215,7 @@ BOOL WINAPI wglMakeCurrent(HDC arg1, HGLRC arg2) {
     }
     return (GLboolean)1;
 };
-PROC mockLoader(const char *name) {
+PROC __stdcall mockLoader(const char *name) {
     if (strcmp(name, "realFunction") == 0) {
         return reinterpret_cast<PROC>(*realFunction);
     }

opencl/test/unit_test/offline_compiler/main.cpp

@@ -217,6 +217,7 @@ int main(int argc, char **argv) {
     }
 
     retVal = RUN_ALL_TESTS();
+    cleanupSignals();
 
     if (showTestStats) {
         std::cout << getTestStats() << std::endl;

opencl/test/unit_test/offline_compiler/segfault_test/main.cpp

@@ -31,6 +31,7 @@ int main(int argc, char **argv) {
         return sigOut;
 
     retVal = RUN_ALL_TESTS();
+    cleanupSignals();
 
     return retVal;
 }

shared/test/common/common_main.cpp

@@ -421,6 +421,7 @@ int main(int argc, char **argv) {
         Device::createPerformanceCountersFunc = [](Device *) -> std::unique_ptr<NEO::PerformanceCounters> { return {}; };
 
         retVal = RUN_ALL_TESTS();
+        cleanupSignals();
 
         if (showTestStats) {
             std::cout << getTestStats() << std::endl;

shared/test/common/libult/signal_utils.h

@@ -1,5 +1,5 @@
 /*
- * Copyright (C) 2022 Intel Corporation
+ * Copyright (C) 2022-2023 Intel Corporation
  *
  * SPDX-License-Identifier: MIT
  *
@@ -12,3 +12,5 @@ int setAlarm(bool enableAlarm);
 int setSegv(bool enableSegv);
 
 int setAbrt(bool enableAbrt);
+
+void cleanupSignals();

shared/test/common/os_interface/linux/signal_utils.cpp

@@ -1,5 +1,5 @@
 /*
- * Copyright (C) 2022 Intel Corporation
+ * Copyright (C) 2022-2023 Intel Corporation
  *
  * SPDX-License-Identifier: MIT
  *
@@ -131,3 +131,5 @@ int setSegv(bool enableSegv) {
     }
     return 0;
 }
+
+void cleanupSignals() {}

shared/test/common/os_interface/windows/signal_utils.cpp

@@ -11,12 +11,21 @@
 
 #include "gtest/gtest.h"
 
+#include <condition_variable>
 #include <io.h>
 #include <signal.h>
+#include <thread>
 
 std::string lastTest("");
 static int newStdOut = -1;
 
+namespace NEO {
+extern const char *executionName;
+extern unsigned int ultIterationMaxTime;
+} // namespace NEO
+
+std::unique_ptr<std::thread> alarmThread;
+
 LONG WINAPI ultExceptionFilter(
     _In_ struct _EXCEPTION_POINTERS *exceptionInfo) {
     std::cout << "UnhandledException: 0x" << std::hex << exceptionInfo->ExceptionRecord->ExceptionCode << std::dec
@@ -49,9 +58,48 @@ int setAbrt(bool enableAbrt) {
 }
 
 int setAlarm(bool enableAlarm) {
+    std::cout << "enable SIGALRM handler: " << enableAlarm << std::endl;
+
+    if (enableAlarm) {
+        std::string envVar = std::string("NEO_") + NEO::executionName + "_DISABLE_TEST_ALARM";
+        char *envValue = getenv(envVar.c_str());
+        if (envValue != nullptr) {
+            enableAlarm = false;
+            std::cout << "WARNING: SIGALRM handler disabled by environment variable: " << envVar << std::endl;
+        }
+    }
+
+    if (enableAlarm) {
+        std::condition_variable threadStarted;
+        alarmThread = std::make_unique<std::thread>([&]() {
+            auto currentUltIterationMaxTime = NEO::ultIterationMaxTime;
+            auto ultIterationMaxTimeEnv = getenv("NEO_ULT_ITERATION_MAX_TIME");
+            if (ultIterationMaxTimeEnv != nullptr) {
+                currentUltIterationMaxTime = atoi(ultIterationMaxTimeEnv);
+            }
+            unsigned int alarmTime = currentUltIterationMaxTime * ::testing::GTEST_FLAG(repeat);
+            std::cout << "set timeout to: " << alarmTime << std::endl;
+            threadStarted.notify_all();
+            std::this_thread::sleep_for(std::chrono::seconds(alarmTime));
+            printf("timeout on %s\n", lastTest.c_str());
+            abort();
+        });
+
+        std::mutex mtx;
+        std::unique_lock<std::mutex> lock(mtx);
+        threadStarted.wait(lock);
+    }
+
     return 0;
 }
 
 int setSegv(bool enableSegv) {
     return 0;
 }
+
+void cleanupSignals() {
+    if (alarmThread) {
+        alarmThread->detach();
+        alarmThread.reset();
+    }
+}