[L0] Create/Destory Adapter Handle during lib init

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

Author: nrspruit

source/adapters/level_zero/CMakeLists.txt

@@ -122,6 +122,18 @@ add_ur_adapter(${TARGET_NAME}
     ${CMAKE_CURRENT_SOURCE_DIR}/../../ur/ur.cpp
 )
 
+if(WIN32)
+    target_sources(ur_adapter_level_zero
+        PRIVATE
+            ${CMAKE_CURRENT_SOURCE_DIR}/adapter_lib_init_windows.cpp
+    )
+else()
+    target_sources(ur_adapter_level_zero
+        PRIVATE
+            ${CMAKE_CURRENT_SOURCE_DIR}/adapter_lib_init_linux.cpp
+    )
+endif()
+
 # TODO: fix level_zero adapter conversion warnings
 target_compile_options(${TARGET_NAME} PRIVATE
     $<$<CXX_COMPILER_ID:MSVC>:/wd4805 /wd4244>

source/adapters/level_zero/adapter.cpp

@@ -11,6 +11,8 @@
 #include "adapter.hpp"
 #include "ur_level_zero.hpp"
 
+ur_adapter_handle_t_ *Adapter;
+
 ur_result_t initPlatforms(PlatformVec &platforms) noexcept try {
   uint32_t ZeDriverCount = 0;
   ZE2UR_CALL(zeDriverGet, (&ZeDriverCount, nullptr));
@@ -37,8 +39,7 @@ ur_result_t initPlatforms(PlatformVec &platforms) noexcept try {
 ur_result_t adapterStateInit() { return UR_RESULT_SUCCESS; }
 
 ur_adapter_handle_t_::ur_adapter_handle_t_() {
-
-  Adapter.PlatformCache.Compute = [](Result<PlatformVec> &result) {
+  PlatformCache.Compute = [](Result<PlatformVec> &result) {
     static std::once_flag ZeCallCountInitialized;
     try {
       std::call_once(ZeCallCountInitialized, []() {
@@ -52,7 +53,7 @@ ur_adapter_handle_t_::ur_adapter_handle_t_() {
     }
 
     // initialize level zero only once.
-    if (Adapter.ZeResult == std::nullopt) {
+    if (Adapter->ZeResult == std::nullopt) {
       // Setting these environment variables before running zeInit will enable
       // the validation layer in the Level Zero loader.
       if (UrL0Debug & UR_L0_DEBUG_VALIDATION) {
@@ -71,20 +72,20 @@ ur_adapter_handle_t_::ur_adapter_handle_t_() {
       // We must only initialize the driver once, even if urPlatformGet() is
       // called multiple times.  Declaring the return value as "static" ensures
       // it's only called once.
-      Adapter.ZeResult = ZE_CALL_NOCHECK(zeInit, (ZE_INIT_FLAG_GPU_ONLY));
+      Adapter->ZeResult = ZE_CALL_NOCHECK(zeInit, (ZE_INIT_FLAG_GPU_ONLY));
     }
-    assert(Adapter.ZeResult !=
+    assert(Adapter->ZeResult !=
            std::nullopt); // verify that level-zero is initialized
     PlatformVec platforms;
 
     // Absorb the ZE_RESULT_ERROR_UNINITIALIZED and just return 0 Platforms.
-    if (*Adapter.ZeResult == ZE_RESULT_ERROR_UNINITIALIZED) {
+    if (*Adapter->ZeResult == ZE_RESULT_ERROR_UNINITIALIZED) {
       result = std::move(platforms);
       return;
     }
-    if (*Adapter.ZeResult != ZE_RESULT_SUCCESS) {
+    if (*Adapter->ZeResult != ZE_RESULT_SUCCESS) {
       urPrint("zeInit: Level Zero initialization failure\n");
-      result = ze2urResult(*Adapter.ZeResult);
+      result = ze2urResult(*Adapter->ZeResult);
       return;
     }
 
@@ -97,8 +98,6 @@ ur_adapter_handle_t_::ur_adapter_handle_t_() {
   };
 }
 
-ur_adapter_handle_t_ Adapter{};
-
 ur_result_t adapterStateTeardown() {
   bool LeakFound = false;
 
@@ -203,11 +202,15 @@ UR_APIEXPORT ur_result_t UR_APICALL urAdapterGet(
                           ///< adapters available.
 ) {
   if (NumEntries > 0 && Adapters) {
-    std::lock_guard<std::mutex> Lock{Adapter.Mutex};
-    if (Adapter.RefCount++ == 0) {
-      adapterStateInit();
+    if (Adapter) {
+      std::lock_guard<std::mutex> Lock{Adapter->Mutex};
+      if (Adapter->RefCount++ == 0) {
+        adapterStateInit();
+      }
+      *Adapters = Adapter;
+    } else {
+      return UR_RESULT_ERROR_UNINITIALIZED;
     }
-    *Adapters = &Adapter;
   }
 
   if (NumAdapters) {
@@ -218,17 +221,24 @@ UR_APIEXPORT ur_result_t UR_APICALL urAdapterGet(
 }
 
 UR_APIEXPORT ur_result_t UR_APICALL urAdapterRelease(ur_adapter_handle_t) {
-  std::lock_guard<std::mutex> Lock{Adapter.Mutex};
-  if (--Adapter.RefCount == 0) {
-    return adapterStateTeardown();
+  // Check first if the Adapter pointer is valid
+  if (Adapter) {
+    std::lock_guard<std::mutex> Lock{Adapter->Mutex};
+    if (--Adapter->RefCount == 0) {
+      return adapterStateTeardown();
+    }
   }
 
   return UR_RESULT_SUCCESS;
 }
 
 UR_APIEXPORT ur_result_t UR_APICALL urAdapterRetain(ur_adapter_handle_t) {
-  std::lock_guard<std::mutex> Lock{Adapter.Mutex};
-  Adapter.RefCount++;
+  if (Adapter) {
+    std::lock_guard<std::mutex> Lock{Adapter->Mutex};
+    Adapter->RefCount++;
+  } else {
+    return UR_RESULT_ERROR_UNINITIALIZED;
+  }
 
   return UR_RESULT_SUCCESS;
 }
@@ -257,7 +267,7 @@ UR_APIEXPORT ur_result_t UR_APICALL urAdapterGetInfo(ur_adapter_handle_t,
   case UR_ADAPTER_INFO_BACKEND:
     return ReturnValue(UR_ADAPTER_BACKEND_LEVEL_ZERO);
   case UR_ADAPTER_INFO_REFERENCE_COUNT:
-    return ReturnValue(Adapter.RefCount.load());
+    return ReturnValue(Adapter->RefCount.load());
   default:
     return UR_RESULT_ERROR_INVALID_ENUMERATION;
   }

source/adapters/level_zero/adapter.hpp

@@ -25,4 +25,4 @@ struct ur_adapter_handle_t_ {
   ZeCache<Result<PlatformVec>> PlatformCache;
 };
 
-extern ur_adapter_handle_t_ Adapter;
+extern ur_adapter_handle_t_ *Adapter;

source/adapters/level_zero/adapter_lib_init_linux.cpp

@@ -0,0 +1,26 @@
+/*
+*
+* Copyright (C) 2024 Intel Corporation
+*
+* Part of the Unified-Runtime Project, under the Apache License v2.0 with LLVM Exceptions.
+* See LICENSE.TXT
+* SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+*
+* @file adapter_lib_init_linux.cpp
+*
+*/
+
+#include "adapter.hpp"
+#include "ur_level_zero.hpp"
+
+void __attribute__((constructor)) createAdapterHandle() {
+  if (!Adapter) {
+    Adapter = new ur_adapter_handle_t_();
+  }
+}
+
+void __attribute__((destructor)) deleteAdapterHandle() {
+  if (Adapter) {
+    delete Adapter;
+  }
+}

source/adapters/level_zero/adapter_lib_init_windows.cpp

@@ -0,0 +1,29 @@
+/*
+*
+* Copyright (C) 2024 Intel Corporation
+*
+* Part of the Unified-Runtime Project, under the Apache License v2.0 with LLVM Exceptions.
+* See LICENSE.TXT
+* SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+*
+* @file adapter_lib_init_windows.cpp
+*
+*/
+
+#include "adapter.hpp"
+#include "ur_level_zero.hpp"
+#include <windows.h>
+
+extern "C" BOOL APIENTRY DllMain(HINSTANCE hinstDLL, DWORD fdwReason,
+                                 LPVOID lpvReserved) {
+  if (fdwReason == DLL_PROCESS_DETACH) {
+    if (Adapter) {
+      delete Adapter;
+    }
+  } else if (fdwReason == DLL_PROCESS_ATTACH) {
+    if (!Adapter) {
+      Adapter = new ur_adapter_handle_t_();
+    }
+  }
+  return TRUE;
+}

source/adapters/level_zero/device.cpp

@@ -1442,7 +1442,7 @@ UR_APIEXPORT ur_result_t UR_APICALL urDeviceCreateWithNativeHandle(
   // a valid Level Zero device.
 
   ur_device_handle_t Dev = nullptr;
-  if (const auto *platforms = Adapter.PlatformCache->get_value()) {
+  if (const auto *platforms = Adapter->PlatformCache->get_value()) {
     for (const auto &p : *platforms) {
       Dev = p->getDeviceFromNativeHandle(ZeDevice);
       if (Dev) {
@@ -1453,7 +1453,7 @@ UR_APIEXPORT ur_result_t UR_APICALL urDeviceCreateWithNativeHandle(
       }
     }
   } else {
-    return Adapter.PlatformCache->get_error();
+    return Adapter->PlatformCache->get_error();
   }
 
   if (Dev == nullptr)

source/adapters/level_zero/platform.cpp

@@ -29,7 +29,7 @@ UR_APIEXPORT ur_result_t UR_APICALL urPlatformGet(
 ) {
   // Platform handles are cached for reuse. This is to ensure consistent
   // handle pointers across invocations and to improve retrieval performance.
-  if (const auto *cached_platforms = Adapter.PlatformCache->get_value();
+  if (const auto *cached_platforms = Adapter->PlatformCache->get_value();
       cached_platforms) {
     uint32_t nplatforms = (uint32_t)cached_platforms->size();
     if (NumPlatforms) {
@@ -41,7 +41,7 @@ UR_APIEXPORT ur_result_t UR_APICALL urPlatformGet(
       }
     }
   } else {
-    return Adapter.PlatformCache->get_error();
+    return Adapter->PlatformCache->get_error();
   }
 
   return UR_RESULT_SUCCESS;
@@ -133,7 +133,7 @@ UR_APIEXPORT ur_result_t UR_APICALL urPlatformCreateWithNativeHandle(
   auto ZeDriver = ur_cast<ze_driver_handle_t>(NativePlatform);
 
   uint32_t NumPlatforms = 0;
-  ur_adapter_handle_t AdapterHandle = &Adapter;
+  ur_adapter_handle_t AdapterHandle = Adapter;
   UR_CALL(urPlatformGet(&AdapterHandle, 1, 0, nullptr, &NumPlatforms));
 
   if (NumPlatforms) {

source/adapters/level_zero/queue.cpp

@@ -569,7 +569,7 @@ UR_APIEXPORT ur_result_t UR_APICALL urQueueCreateWithNativeHandle(
   // Maybe this is not completely correct.
   uint32_t NumEntries = 1;
   ur_platform_handle_t Platform{};
-  ur_adapter_handle_t AdapterHandle = &Adapter;
+  ur_adapter_handle_t AdapterHandle = Adapter;
   UR_CALL(urPlatformGet(&AdapterHandle, 1, NumEntries, &Platform, nullptr));
 
   ur_device_handle_t UrDevice = Device;