Updated thread state values, increased polling interval and updated tests

Signed-off-by: Neil R. Spruit <neil.r.spruit@intel.com>

Author: nrspruit

source/lib/ze_lib.cpp

@@ -27,11 +27,14 @@ namespace ze_lib
             ze_lib::context = nullptr;
         }
     }
+    #define ZEL_STABILITY_THREAD_STATE_RUNNING 1
+    #define ZEL_STABILITY_THREAD_STATE_POLLING 0
+    #define ZEL_STABILITY_THREAD_STATE_SHUTDOWN -1
     bool delayContextDestruction = false;
     std::mutex *stabilityMutex = nullptr;
     std::promise<int> *stabilityPromiseResult = nullptr;
     std::future<int> *resultFutureResult = nullptr;
-    std::atomic<int> *stabilityCheckThreadStarted = nullptr;
+    std::atomic<int> *stabilityCheckThreadStatus = nullptr;
     std::thread *stabilityThread = nullptr;
     #endif
     bool destruction = false;
@@ -49,8 +52,8 @@ namespace ze_lib
         if (loader) {
             FREE_DRIVER_LIBRARY( loader );
         }
-        if (ze_lib::stabilityCheckThreadStarted)
-            ze_lib::stabilityCheckThreadStarted->store(-1);
+        if (ze_lib::stabilityCheckThreadStatus)
+            ze_lib::stabilityCheckThreadStatus->store(ZEL_STABILITY_THREAD_STATE_SHUTDOWN);
         try {
             if (stabilityThread && stabilityThread->joinable()) {
                 stabilityThread->join();
@@ -74,9 +77,9 @@ namespace ze_lib
             delete resultFutureResult;
             resultFutureResult = nullptr;
         }
-        if (stabilityCheckThreadStarted) {
-            delete stabilityCheckThreadStarted;
-            stabilityCheckThreadStarted = nullptr;
+        if (stabilityCheckThreadStatus) {
+            delete stabilityCheckThreadStatus;
+            stabilityCheckThreadStatus = nullptr;
         }
 #endif
         ze_lib::destruction = true;
@@ -187,7 +190,7 @@ namespace ze_lib
         stabilityMutex = new std::mutex();
         stabilityPromiseResult = new std::promise<int>();
         resultFutureResult = new std::future<int>(stabilityPromiseResult->get_future());
-        stabilityCheckThreadStarted = new std::atomic<int>(0);
+        stabilityCheckThreadStatus = new std::atomic<int>(ZEL_STABILITY_THREAD_STATE_POLLING);
 #else
         result = zeLoaderInit();
         if( ZE_RESULT_SUCCESS == result ) {
@@ -451,6 +454,8 @@ zelSetDelayLoaderContextTeardown()
 #define ZEL_STABILITY_CHECK_RESULT_EXCEPTION 3
 // The stability check thread timeout in milliseconds
 #define ZEL_STABILITY_CHECK_THREAD_TIMEOUT 100
+// The stability check thread polling interval in nanoseconds
+#define ZEL_STABILITY_CHECK_THREAD_POLLING_INTERVAL 100
 
 /**
  * @brief Performs a stability check for the Level Zero loader.
@@ -532,23 +537,23 @@ zelCheckIsLoaderInTearDown() {
         std::lock_guard<std::mutex> lock(*ze_lib::stabilityMutex);
         *ze_lib::stabilityPromiseResult = std::promise<int>();
         *ze_lib::resultFutureResult = ze_lib::stabilityPromiseResult->get_future();
-        ze_lib::stabilityCheckThreadStarted->store(1);
+        ze_lib::stabilityCheckThreadStatus->store(ZEL_STABILITY_THREAD_STATE_RUNNING);
         std::call_once(stabilityThreadFlag, []() {
             ze_lib::stabilityThread =  new std::thread([]() {
             while (true) {
-                while(ze_lib::stabilityCheckThreadStarted && ze_lib::stabilityCheckThreadStarted->load() == 0) {
-                    std::this_thread::sleep_for(std::chrono::milliseconds(1));
+                while(ze_lib::stabilityCheckThreadStatus && ze_lib::stabilityCheckThreadStatus->load() == ZEL_STABILITY_THREAD_STATE_POLLING) {
+                    std::this_thread::sleep_for(std::chrono::nanoseconds(ZEL_STABILITY_CHECK_THREAD_POLLING_INTERVAL));
                 }
                 if (ze_lib::destruction || ze_lib::context == nullptr) {
                     break;
                 }
-                if (!ze_lib::stabilityCheckThreadStarted) {
+                if (!ze_lib::stabilityCheckThreadStatus) {
                     break;
                 }
-                if (ze_lib::stabilityCheckThreadStarted->load() == -1) {
+                if (ze_lib::stabilityCheckThreadStatus->load() == ZEL_STABILITY_THREAD_STATE_SHUTDOWN) {
                     break;
                 }
-                ze_lib::stabilityCheckThreadStarted->store(0);
+                ze_lib::stabilityCheckThreadStatus->store(ZEL_STABILITY_THREAD_STATE_POLLING);
                 int result = stabilityCheck();
                 if (result != ZEL_STABILITY_CHECK_RESULT_SUCCESS) {
                     if (ze_lib::context->debugTraceEnabled) {

test/CMakeLists.txt

@@ -97,6 +97,27 @@ endif()
 add_test(NAME tests_loader_teardown_check COMMAND tests --gtest_filter=*GivenLoaderNotInDestructionStateWhenCallingzelCheckIsLoaderInTearDownThenFalseIsReturned)
 set_property(TEST tests_loader_teardown_check PROPERTY ENVIRONMENT "ZE_ENABLE_LOADER_DEBUG_TRACE=1;ZE_ENABLE_NULL_DRIVER=1")
 
+add_test(NAME test_zello_world_legacy COMMAND zello_world --enable_legacy_init --enable_null_driver --force_loader_intercepts --enable_validation_layer --enable_tracing_layer --enable_tracing_layer_runtime)
+set_property(TEST test_zello_world_legacy PROPERTY ENVIRONMENT "ZE_ENABLE_LOADER_DEBUG_TRACE=1")
+
+add_test(NAME test_zello_world_legacy_intercept COMMAND zello_world --enable_legacy_init --enable_null_driver --force_loader_intercepts)
+set_property(TEST test_zello_world_legacy_intercept PROPERTY ENVIRONMENT "ZE_ENABLE_LOADER_DEBUG_TRACE=1")
+
+add_test(NAME test_zello_world_legacy_validation_layer COMMAND zello_world --enable_legacy_init --enable_null_driver --enable_validation_layer)
+set_property(TEST test_zello_world_legacy_validation_layer PROPERTY ENVIRONMENT "ZE_ENABLE_LOADER_DEBUG_TRACE=1")
+
+add_test(NAME test_zello_world_legacy_tracing COMMAND zello_world --enable_legacy_init --enable_null_driver --enable_tracing_layer)
+set_property(TEST test_zello_world_legacy_tracing PROPERTY ENVIRONMENT "ZE_ENABLE_LOADER_DEBUG_TRACE=1")
+
+add_test(NAME test_zello_world_legacy_dynamic_tracing COMMAND zello_world --enable_legacy_init --enable_null_driver --enable_tracing_layer_runtime)
+set_property(TEST test_zello_world_legacy_dynamic_tracing PROPERTY ENVIRONMENT "ZE_ENABLE_LOADER_DEBUG_TRACE=1")
+
+add_test(NAME test_zello_world_legacy_all_tracing COMMAND zello_world --enable_legacy_init --enable_null_driver --force_loader_intercepts --enable_validation_layer --enable_tracing_layer)
+set_property(TEST test_zello_world_legacy_all_tracing PROPERTY ENVIRONMENT "ZE_ENABLE_LOADER_DEBUG_TRACE=1")
+
+add_test(NAME test_zello_world_legacy_all_tracing_dynamic COMMAND zello_world --enable_legacy_init --enable_null_driver --force_loader_intercepts --enable_validation_layer --enable_tracing_layer_runtime)
+set_property(TEST test_zello_world_legacy_all_tracing_dynamic PROPERTY ENVIRONMENT "ZE_ENABLE_LOADER_DEBUG_TRACE=1")
+
 # These tests are currently not supported on Windows. The reason is that the std::cerr is not being redirected to a pipe in Windows to be then checked against the expected output.
 if(NOT MSVC)
     add_test(NAME tests_event_deadlock COMMAND tests --gtest_filter=*GivenLevelZeroLoaderPresentWhenCallingzeCommandListAppendMemoryCopyWithCircularDependencyOnEventsThenValidationLayerPrintsWarningOfDeadlock*)

test/loader_api.cpp

@@ -11,6 +11,7 @@
 #include "loader/ze_loader.h"
 #include "ze_api.h"
 #include "zes_api.h"
+#include "../source/lib/ze_lib.h" // Include the header file defining ze_lib
 
 #include <fstream>
 
@@ -374,6 +375,9 @@ TEST(
 
   EXPECT_EQ(ZE_RESULT_SUCCESS, zeInit(0));
   EXPECT_FALSE(zelCheckIsLoaderInTearDown());
+  EXPECT_FALSE(zelCheckIsLoaderInTearDown());
+  EXPECT_FALSE(zelCheckIsLoaderInTearDown());
+  EXPECT_FALSE(zelCheckIsLoaderInTearDown());
 }
 
 class CaptureOutput {