Increase refcount to ze_loader library when Level Zero provider is used

Author: vinser52

include/umf/base.h

@@ -1,6 +1,6 @@
 /*
  *
- * Copyright (C) 2023-2024 Intel Corporation
+ * Copyright (C) 2023-2025 Intel Corporation
  *
  * Under the Apache License v2.0 with LLVM Exceptions. See LICENSE.TXT.
  * SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
@@ -45,6 +45,8 @@ typedef enum umf_result_t {
     UMF_RESULT_ERROR_NOT_SUPPORTED = 5, ///< Operation not supported
     UMF_RESULT_ERROR_USER_SPECIFIC =
         6, ///< Failure in user provider code (i.e in user provided callback)
+    UMF_RESULT_ERROR_DEPENDENCY_UNAVAILABLE =
+        7, ///< External required dependency is unavailable or missing
     UMF_RESULT_ERROR_UNKNOWN = 0x7ffffffe ///< Unknown or internal error
 } umf_result_t;
 

src/libumf.c

@@ -1,6 +1,6 @@
 /*
  *
- * Copyright (C) 2024 Intel Corporation
+ * Copyright (C) 2024-2025 Intel Corporation
  *
  * Under the Apache License v2.0 with LLVM Exceptions. See LICENSE.TXT.
  * SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
@@ -12,6 +12,7 @@
 #include "base_alloc_global.h"
 #include "ipc_cache.h"
 #include "memspace_internal.h"
+#include "provider_level_zero_internal.h"
 #include "provider_tracking.h"
 #include "utils_common.h"
 #include "utils_log.h"
@@ -79,6 +80,7 @@ void umfTearDown(void) {
         LOG_DEBUG("UMF base allocator destroyed");
 
     fini_umfTearDown:
+        fini_ze_global_state();
         LOG_DEBUG("UMF library finalized");
     }
 }

src/provider/provider_level_zero.c

@@ -14,8 +14,19 @@
 #include <umf/memory_provider_ops.h>
 #include <umf/providers/provider_level_zero.h>
 
+#include "provider_level_zero_internal.h"
+#include "utils_load_library.h"
 #include "utils_log.h"
 
+static void *ze_lib_handle = NULL;
+
+void fini_ze_global_state(void) {
+    if (ze_lib_handle) {
+        utils_close_library(ze_lib_handle);
+        ze_lib_handle = NULL;
+    }
+}
+
 #if defined(UMF_NO_LEVEL_ZERO_PROVIDER)
 
 umf_result_t umfLevelZeroMemoryProviderParamsCreate(
@@ -105,7 +116,6 @@ umf_memory_provider_ops_t *umfLevelZeroMemoryProviderOps(void) {
 #include "utils_assert.h"
 #include "utils_common.h"
 #include "utils_concurrency.h"
-#include "utils_load_library.h"
 #include "utils_log.h"
 #include "utils_sanitizers.h"
 #include "ze_api.h"
@@ -207,32 +217,41 @@ static void init_ze_global_state(void) {
 #else
     const char *lib_name = "libze_loader.so";
 #endif
-    // check if Level Zero shared library is already loaded
-    // we pass 0 as a handle to search the global symbol table
+    // The Level Zero shared library should be already loaded by the user
+    // of the Level Zero provider. UMF just want to reuse it
+    // and increase the reference count to the the Level Zero shared library.
+    void *lib_handle =
+        utils_open_library(lib_name, UMF_UTIL_OPEN_LIBRARY_NO_LOAD);
+    if (!lib_handle) {
+        LOG_ERR("Failed to open Level Zero shared library");
+        Init_ze_global_state_failed = true;
+        return;
+    }
+
     *(void **)&g_ze_ops.zeMemAllocHost =
-        utils_get_symbol_addr(0, "zeMemAllocHost", lib_name);
+        utils_get_symbol_addr(lib_handle, "zeMemAllocHost", lib_name);
     *(void **)&g_ze_ops.zeMemAllocDevice =
-        utils_get_symbol_addr(0, "zeMemAllocDevice", lib_name);
+        utils_get_symbol_addr(lib_handle, "zeMemAllocDevice", lib_name);
     *(void **)&g_ze_ops.zeMemAllocShared =
-        utils_get_symbol_addr(0, "zeMemAllocShared", lib_name);
+        utils_get_symbol_addr(lib_handle, "zeMemAllocShared", lib_name);
     *(void **)&g_ze_ops.zeMemFree =
-        utils_get_symbol_addr(0, "zeMemFree", lib_name);
+        utils_get_symbol_addr(lib_handle, "zeMemFree", lib_name);
     *(void **)&g_ze_ops.zeMemGetIpcHandle =
-        utils_get_symbol_addr(0, "zeMemGetIpcHandle", lib_name);
+        utils_get_symbol_addr(lib_handle, "zeMemGetIpcHandle", lib_name);
     *(void **)&g_ze_ops.zeMemPutIpcHandle =
-        utils_get_symbol_addr(0, "zeMemPutIpcHandle", lib_name);
+        utils_get_symbol_addr(lib_handle, "zeMemPutIpcHandle", lib_name);
     *(void **)&g_ze_ops.zeMemOpenIpcHandle =
-        utils_get_symbol_addr(0, "zeMemOpenIpcHandle", lib_name);
+        utils_get_symbol_addr(lib_handle, "zeMemOpenIpcHandle", lib_name);
     *(void **)&g_ze_ops.zeMemCloseIpcHandle =
-        utils_get_symbol_addr(0, "zeMemCloseIpcHandle", lib_name);
-    *(void **)&g_ze_ops.zeContextMakeMemoryResident =
-        utils_get_symbol_addr(0, "zeContextMakeMemoryResident", lib_name);
+        utils_get_symbol_addr(lib_handle, "zeMemCloseIpcHandle", lib_name);
+    *(void **)&g_ze_ops.zeContextMakeMemoryResident = utils_get_symbol_addr(
+        lib_handle, "zeContextMakeMemoryResident", lib_name);
     *(void **)&g_ze_ops.zeDeviceGetProperties =
-        utils_get_symbol_addr(0, "zeDeviceGetProperties", lib_name);
+        utils_get_symbol_addr(lib_handle, "zeDeviceGetProperties", lib_name);
     *(void **)&g_ze_ops.zeMemFreeExt =
-        utils_get_symbol_addr(0, "zeMemFreeExt", lib_name);
+        utils_get_symbol_addr(lib_handle, "zeMemFreeExt", lib_name);
     *(void **)&g_ze_ops.zeMemGetAllocProperties =
-        utils_get_symbol_addr(0, "zeMemGetAllocProperties", lib_name);
+        utils_get_symbol_addr(lib_handle, "zeMemGetAllocProperties", lib_name);
 
     if (!g_ze_ops.zeMemAllocHost || !g_ze_ops.zeMemAllocDevice ||
         !g_ze_ops.zeMemAllocShared || !g_ze_ops.zeMemFree ||
@@ -244,7 +263,10 @@ static void init_ze_global_state(void) {
         // starting from Level Zero 1.6
         LOG_ERR("Required Level Zero symbols not found.");
         Init_ze_global_state_failed = true;
+        utils_close_library(lib_handle);
+        return;
     }
+    ze_lib_handle = lib_handle;
 }
 
 umf_result_t umfLevelZeroMemoryProviderParamsCreate(
@@ -551,7 +573,7 @@ static umf_result_t ze_memory_provider_initialize(void *params,
     utils_init_once(&ze_is_initialized, init_ze_global_state);
     if (Init_ze_global_state_failed) {
         LOG_ERR("Loading Level Zero symbols failed");
-        return UMF_RESULT_ERROR_UNKNOWN;
+        return UMF_RESULT_ERROR_DEPENDENCY_UNAVAILABLE;
     }
 
     ze_memory_provider_t *ze_provider =

src/provider/provider_level_zero_internal.h

@@ -0,0 +1,10 @@
+/*
+ *
+ * Copyright (C) 2025 Intel Corporation
+ *
+ * Under the Apache License v2.0 with LLVM Exceptions. See LICENSE.TXT.
+ * SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+ *
+ */
+
+void fini_ze_global_state(void);

src/utils/utils_load_library.c

@@ -1,6 +1,6 @@
 /*
  *
- * Copyright (C) 2024 Intel Corporation
+ * Copyright (C) 2024-2025 Intel Corporation
  *
  * Under the Apache License v2.0 with LLVM Exceptions. See LICENSE.TXT.
  * SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
@@ -32,7 +32,11 @@
 #ifdef _WIN32
 
 void *utils_open_library(const char *filename, int userFlags) {
-    (void)userFlags; //unused for win
+    if (userFlags & UMF_UTIL_OPEN_LIBRARY_NO_LOAD) {
+        HMODULE hModule;
+        BOOL ret = GetModuleHandleEx(0, TEXT(filename), &hModule);
+        return ret ? hModule : NULL;
+    }
     return LoadLibrary(TEXT(filename));
 }
 
@@ -66,6 +70,9 @@ void *utils_open_library(const char *filename, int userFlags) {
     if (userFlags & UMF_UTIL_OPEN_LIBRARY_GLOBAL) {
         dlopenFlags |= RTLD_GLOBAL;
     }
+    if (userFlags & UMF_UTIL_OPEN_LIBRARY_NO_LOAD) {
+        dlopenFlags |= RTLD_NOLOAD;
+    }
 
     void *handle = dlopen(filename, dlopenFlags);
     if (handle == NULL) {

src/utils/utils_load_library.h

@@ -1,6 +1,6 @@
 /*
  *
- * Copyright (C) 2024 Intel Corporation
+ * Copyright (C) 2024-2025 Intel Corporation
  *
  * Under the Apache License v2.0 with LLVM Exceptions. See LICENSE.TXT.
  * SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
@@ -17,7 +17,10 @@
 #ifdef __cplusplus
 extern "C" {
 #endif
+// The symbols defined by this library will be made available for symbol resolution of subsequently loaded libraries.
 #define UMF_UTIL_OPEN_LIBRARY_GLOBAL 1
+// Don't load the library. utils_open_library succeeds if the library is already loaded.
+#define UMF_UTIL_OPEN_LIBRARY_NO_LOAD 1 << 1
 
 void *utils_open_library(const char *filename, int userFlags);
 int utils_close_library(void *handle);