Call only zeInitDrivers for windows based on the ze_loader.dll version

Signed-off-by: Bogdan Pereanu <[email protected]>

Author: pereanub

src/plugins/intel_npu/src/utils/include/intel_npu/utils/zero/zero_api.hpp

@@ -80,13 +80,17 @@ class ZeroApi {
 
     static const std::shared_ptr<ZeroApi>& getInstance();
 
+    const uint32_t getVersion();
+
 #define symbol_statement(symbol) decltype(&::symbol) symbol;
     symbols_list();
     weak_symbols_list();
 #undef symbol_statement
 
 private:
     std::shared_ptr<void> lib;
+
+    uint32_t version = 0;
 };
 
 #define symbol_statement(symbol)                                                                            \

src/plugins/intel_npu/src/utils/src/zero/CMakeLists.txt

@@ -25,7 +25,11 @@ target_include_directories(${TARGET_NAME}
     $<TARGET_PROPERTY:LevelZero::NPUExt,INTERFACE_INCLUDE_DIRECTORIES>
     $<BUILD_INTERFACE:${NPU_UTILS_SOURCE_DIR}/include>)
 
-target_link_libraries(${TARGET_NAME} PUBLIC openvino::runtime::dev)
+if(WIN32)
+    target_link_libraries(${TARGET_NAME} PUBLIC openvino::runtime::dev Version.lib)
+else()
+    target_link_libraries(${TARGET_NAME} PUBLIC openvino::runtime::dev)
+endif()
 
 #
 # targets install

src/plugins/intel_npu/src/utils/src/zero/zero_api.cpp

@@ -4,18 +4,47 @@
 
 #include "intel_npu/utils/zero/zero_api.hpp"
 
+#include <stdio.h>
+#ifdef _WIN32
+#    include <windows.h>
+#endif
+
 #include "openvino/util/file_util.hpp"
 #include "openvino/util/shared_object.hpp"
 
 namespace intel_npu {
 ZeroApi::ZeroApi() {
-    const std::string baseName = "ze_loader";
+    const std::string base_name = "ze_loader";
     try {
-        auto libpath = ov::util::make_plugin_library_name({}, baseName);
+        auto libpath = ov::util::make_plugin_library_name({}, base_name);
 #if !defined(_WIN32) && !defined(ANDROID)
         libpath = libpath + LIB_ZE_LOADER_SUFFIX;
 #endif
 
+#ifdef _WIN32
+        // Get required size for wide string
+        int size_needed = MultiByteToWideChar(CP_UTF8, 0, libpath.c_str(), -1, nullptr, 0);
+        // Create a buffer to hold wide characters
+        std::wstring wide(size_needed, 0);
+        // Convert to wide string
+        MultiByteToWideChar(CP_UTF8, 0, libpath.c_str(), -1, &wide[0], size_needed);
+        // Get const wchar_t*
+        const wchar_t* path = wide.c_str();
+
+        DWORD handle = 0;
+        DWORD size = GetFileVersionInfoSizeW(path, &handle);
+        std::vector<BYTE> data(size);
+        if (GetFileVersionInfoW(path, handle, size, data.data())) {
+            VS_FIXEDFILEINFO* loader_version = NULL;
+            uint32_t loader_version_size = 0;
+            if (VerQueryValueW(data.data(), L"\\", (LPVOID*)&loader_version, &loader_version_size) ||
+                !loader_version_size) {
+                // Version is in dwFileVersionMS (high: major.minor) and dwFileVersionLS (low: build.revision)
+                version = loader_version->dwFileVersionMS;
+            }
+        }
+#endif
+
 #if defined(OPENVINO_ENABLE_UNICODE_PATH_SUPPORT) && defined(_WIN32)
         this->lib = ov::util::load_shared_object(ov::util::string_to_wstring(libpath).c_str());
 #else
@@ -54,4 +83,8 @@ const std::shared_ptr<ZeroApi>& ZeroApi::getInstance() {
     return instance;
 }
 
+const uint32_t ZeroApi::getVersion() {
+    return version;
+}
+
 }  // namespace intel_npu

src/plugins/intel_npu/src/utils/src/zero/zero_init.cpp

@@ -74,6 +74,9 @@ void ZeroInitStructsHolder::initNpuDriver() {
     auto fallbackToZeDriverGet = [&]() {
         log.debug("ZeroInitStructsHolder - zeInitDrivers not supported, fallback to zeDriverGet");
 
+        log.debug("ZeroInitStructsHolder - performing zeInit on NPU only");
+        THROW_ON_FAIL_FOR_LEVELZERO("zeInit", zeInit(ZE_INIT_FLAG_VPU_ONLY));
+
         uint32_t drivers_count = 0;
         THROW_ON_FAIL_FOR_LEVELZERO("zeDriverGet", zeDriverGet(&drivers_count, nullptr));
 
@@ -84,31 +87,41 @@ void ZeroInitStructsHolder::initNpuDriver() {
         setNpuDriver(drivers_count, std::move(all_drivers));
     };
 
-    zel_version_t loader_version = {};
-    size_t num_components;
-    auto result = zelLoaderGetVersions(&num_components, nullptr);
-    if (result == ZE_RESULT_SUCCESS) {
-        zel_component_version_t* versions = new zel_component_version_t[num_components];
-        result = zelLoaderGetVersions(&num_components, versions);
+    uint32_t loader_version = zero_api->getVersion();
+    uint32_t major;
+    uint32_t minor;
+
+    if (loader_version == 0) {
+        log.debug("ZeroInitStructsHolder - performing zeInit on NPU only");
+        THROW_ON_FAIL_FOR_LEVELZERO("zeInit", zeInit(ZE_INIT_FLAG_VPU_ONLY));
 
+        zel_version_t zel_loader_version = {};
+        size_t num_components;
+        auto result = zelLoaderGetVersions(&num_components, nullptr);
         if (result == ZE_RESULT_SUCCESS) {
-            for (size_t i = 0; i < num_components; ++i) {
-                if (strncmp(versions[i].component_name, "loader", strlen("loader")) == 0) {
-                    loader_version = versions[i].component_lib_version;
-
-                    log.debug("ZeroInitStructsHolder - ze_loader.dll version: %d.%d.%d",
-                              loader_version.major,
-                              loader_version.minor,
-                              loader_version.patch);
+            std::vector<zel_component_version_t> versions(num_components);
+            result = zelLoaderGetVersions(&num_components, versions.data());
+            if (result == ZE_RESULT_SUCCESS) {
+                for (size_t i = 0; i < num_components; ++i) {
+                    if (strncmp(versions[i].component_name, "loader", strlen("loader")) == 0) {
+                        zel_loader_version = versions[i].component_lib_version;
+                        log.debug("ZeroInitStructsHolder - ze_loader.dll version: %d.%d.%d",
+                                  zel_loader_version.major,
+                                  zel_loader_version.minor,
+                                  zel_loader_version.patch);
+                    }
                 }
             }
         }
 
-        delete[] versions;
+        major = zel_loader_version.major > 0 ? zel_loader_version.major : 0;
+        minor = zel_loader_version.minor > 0 ? zel_loader_version.minor : 0;
+    } else {
+        major = (loader_version >> 16) & 0xffff;
+        minor = loader_version & 0xffff;
     }
 
-    if (loader_version.major > 1 || (loader_version.major == 1 && loader_version.minor > 18) ||
-        (loader_version.major == 1 && loader_version.minor == 18 && loader_version.patch >= 5)) {
+    if (major > 1 || (major == 1 && minor >= 19)) {
         uint32_t drivers_count = 0;
         ze_init_driver_type_desc_t desc = {};
         desc.stype = ZE_STRUCTURE_TYPE_INIT_DRIVER_TYPE_DESC;
@@ -138,9 +151,6 @@ void ZeroInitStructsHolder::initNpuDriver() {
 ZeroInitStructsHolder::ZeroInitStructsHolder()
     : zero_api(ZeroApi::getInstance()),
       log("NPUZeroInitStructsHolder", Logger::global().level()) {
-    log.debug("ZeroInitStructsHolder - performing zeInit on NPU only");
-    THROW_ON_FAIL_FOR_LEVELZERO("zeInit", zeInit(ZE_INIT_FLAG_VPU_ONLY));
-
     log.debug("ZeroInitStructsHolder - initialize NPU Driver");
     initNpuDriver();