fix static loader to work with new api

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

Author: nrspruit

doc/loader_api.md

@@ -9,6 +9,25 @@ This document does not cover APIs specific to individual layers (ie. tracing) or
 
 Exposed Loader APIs will be defined in header files located in this repository at `include/loader`, and installed to `<prefix>/include/level_zero/loader`
 
+### zelGetLoaderVersion
+
+This API is used to retrieve the version information of the loader itself. Unlike `zelLoaderGetVersions`, this API provides a simplified interface to get only the loader's version without needing to query all components.
+
+- __*version__ Pointer to a `zel_component_version_t` structure that will be filled with the loader's version information. Must be a valid, non-null pointer.
+
+This function:
+- Returns `ZE_RESULT_SUCCESS` on successful retrieval of the loader version
+- Returns `ZE_RESULT_ERROR_INVALID_NULL_POINTER` if `version` is `nullptr`
+- Returns `ZE_RESULT_ERROR_UNINITIALIZED` if the loader library cannot be found or loaded (only possible in static builds with misconfigured library paths)
+- Does not require `zeInit()` or `zeInitDrivers()` to be called prior to invocation
+- Works with both static and dynamic loader builds without initialization
+- Is thread-safe and can be called from multiple threads
+
+The returned `zel_component_version_t` structure contains:
+- `component_name`: Set to `"loader"`
+- `spec_version`: The Level Zero API specification version (`ZE_API_VERSION_CURRENT`)
+- `component_lib_version`: The loader library version with `major`, `minor`, and `patch` fields
+
 ###  zelLoaderGetVersions
 
 This API is used to retreive the version information of the loader itself and of any layers that are enabled.
@@ -50,3 +69,5 @@ Disables the tracing layer intercepts at runtime by restoring the previous call
 This does not unload the tracing layer library such that one can call `zelEnableTracingLayer` and `zelDisableTracingLayer` as many times one needs to during the application.
 
 NOTE: The each call to `zelEnableTracingLayer` tracks a reference count of how many calls to enable have been seen. The Tracing Layer intercepts will not be removed until the reference count has reached 0 indicating that all users of the tracing layer have called `zelDisableTracingLayer`.
+
+

include/loader/ze_loader.h

@@ -78,10 +78,10 @@ zelLoaderGetVersions(
  * version details (e.g., major, minor, patch), allowing applications to
  * query and validate the loader's compatibility at runtime.
  *
- * Does not require zeInitDrivers to be called prior to invocation unless the
- * application is using a static build of the loader.
+ * Does not require zeInit() or zeInitDrivers() to be called prior to invocation.
+ * Works with both static and dynamic loader builds without initialization.
  *
- * Thread-safety: This function is typically safe to call from multiple threads.
+ * Thread-safety: This function is safe to call from multiple threads.
  * The implementation does not modify global state other than filling the
  * supplied version structure.
  *
@@ -92,8 +92,8 @@ zelLoaderGetVersions(
  * @return
  *   - ZE_RESULT_SUCCESS on successful retrieval of the loader version.
  *   - ZE_RESULT_ERROR_INVALID_NULL_POINTER if version is nullptr.
- *   - ZE_RESULT_ERROR_UNINITIALIZED if the loader is not properly initialized.
- *     NOTE: this error only occurs with a static loader build.
+ *   - ZE_RESULT_ERROR_UNINITIALIZED if the loader library cannot be found or loaded
+ *     (only possible in static builds with misconfigured library paths).
  *   - Other ze_result_t error codes on failure conditions as defined by the API.
  *
  * @note The caller owns the memory for the version structure and must ensure

source/lib/ze_lib.cpp

@@ -394,12 +394,44 @@ zelGetLoaderVersion(
    zel_component_version_t *version)     //Pointer to version structure to be filled with loader version information
 {
 #ifdef L0_STATIC_LOADER_BUILD
-    if(!ze_lib::context || nullptr == ze_lib::context->loader)
-        return ZE_RESULT_ERROR_UNINITIALIZED;
+    // zelLoaderGetVersion doesn't require initialization, so we can load the library temporarily if needed
+    HMODULE loaderHandle = nullptr;
+    bool temporaryLoad = false;
+
+    if(ze_lib::context && ze_lib::context->loader) {
+        // Use existing loader
+        loaderHandle = ze_lib::context->loader;
+    } else {
+        // Temporarily load the loader library to get version info
+        std::string loaderLibraryPath;
+        auto loaderLibraryPathEnv = getenv_string("ZEL_LIBRARY_PATH");
+        if (!loaderLibraryPathEnv.empty()) {
+            loaderLibraryPath = loaderLibraryPathEnv;
+        }
+#ifdef _WIN32
+        else {
+            loaderLibraryPath = readLevelZeroLoaderLibraryPath();
+        }
+#endif
+        std::string loaderFullLibraryPath = create_library_path(MAKE_LIBRARY_NAME( "ze_loader", L0_LOADER_VERSION), loaderLibraryPath.c_str());
+        loaderHandle = LOAD_DRIVER_LIBRARY(loaderFullLibraryPath.c_str());
+        if (nullptr == loaderHandle) {
+            return ZE_RESULT_ERROR_UNINITIALIZED;
+        }
+        temporaryLoad = true;
+    }
+
     typedef ze_result_t (ZE_APICALL *zelLoaderGetVersion_t)(zel_component_version_t *version);
     auto getVersion = reinterpret_cast<zelLoaderGetVersion_t>(
-            GET_FUNCTION_PTR(ze_lib::context->loader, "zelLoaderGetVersion") );
-    return getVersion(version);
+            GET_FUNCTION_PTR(loaderHandle, "zelLoaderGetVersion") );
+    ze_result_t result = getVersion(version);
+
+    // Clean up temporary load
+    if (temporaryLoad && loaderHandle) {
+        FREE_DRIVER_LIBRARY(loaderHandle);
+    }
+
+    return result;
 #else
     return zelLoaderGetVersion(version);
 #endif

test/loader_api.cpp

@@ -136,19 +136,14 @@ TEST(
 
   zel_component_version_t version = {};
 
-#ifdef L0_STATIC_LOADER_BUILD
-  // Static build: requires initialization
-  EXPECT_EQ(ZE_RESULT_ERROR_UNINITIALIZED, zelGetLoaderVersion(&version));
-#else
-  // Dynamic build: works without initialization
+  // Both static and dynamic builds: works without initialization
   EXPECT_EQ(ZE_RESULT_SUCCESS, zelGetLoaderVersion(&version));
 
   EXPECT_STREQ(version.component_name, "loader");
   EXPECT_GT(version.spec_version, 0);
   EXPECT_GE(version.component_lib_version.major, 0);
   EXPECT_GE(version.component_lib_version.minor, 0);
   EXPECT_GE(version.component_lib_version.patch, 0);
-#endif
 }
 
 TEST(
@@ -158,13 +153,8 @@ TEST(
   // Get version before initialization
   zel_component_version_t version_before = {};
 
-#ifdef L0_STATIC_LOADER_BUILD
-  // Static build: should fail before init
-  EXPECT_EQ(ZE_RESULT_ERROR_UNINITIALIZED, zelGetLoaderVersion(&version_before));
-#else
-  // Dynamic build: should work before init
+  // Both static and dynamic builds: should work before init
   EXPECT_EQ(ZE_RESULT_SUCCESS, zelGetLoaderVersion(&version_before));
-#endif
 
   // Initialize drivers
   uint32_t pCount = 0;
@@ -177,14 +167,12 @@ TEST(
   zel_component_version_t version_after = {};
   EXPECT_EQ(ZE_RESULT_SUCCESS, zelGetLoaderVersion(&version_after));
 
-#ifndef L0_STATIC_LOADER_BUILD
-  // Dynamic build: verify both versions match
+  // Verify both versions match
   EXPECT_STREQ(version_before.component_name, version_after.component_name);
   EXPECT_EQ(version_before.spec_version, version_after.spec_version);
   EXPECT_EQ(version_before.component_lib_version.major, version_after.component_lib_version.major);
   EXPECT_EQ(version_before.component_lib_version.minor, version_after.component_lib_version.minor);
   EXPECT_EQ(version_before.component_lib_version.patch, version_after.component_lib_version.patch);
-#endif
 }
 
 TEST(