Add ULTs for multi drivers

Signed-off-by: Neil R. Spruit <[email protected]>

Author: nrspruit

scripts/templates/nullddi.cpp.mako

@@ -54,13 +54,23 @@ namespace driver
             // generic implementation
             %if re.match("Init", obj['name']):
             %if re.match("InitDrivers", obj['name']):
+            // Check compile-time definitions first
+            bool is_npu = false;
+            bool is_gpu = false;
+            #ifdef ZEL_NULL_DRIVER_TYPE_NPU
+            is_npu = true;
+            #endif
+
+            #ifdef ZEL_NULL_DRIVER_TYPE_GPU
+            is_gpu = true;
+            #endif
             auto driver_type = getenv_string( "ZEL_TEST_NULL_DRIVER_TYPE" );
-            if (std::strcmp(driver_type.c_str(), "GPU") == 0) {
+            if (std::strcmp(driver_type.c_str(), "GPU") == 0 || is_gpu) {
                 if (!(desc->flags & ZE_INIT_DRIVER_TYPE_FLAG_GPU)) {
                     return ${X}_RESULT_ERROR_UNINITIALIZED;
                 }
             }
-            if (std::strcmp(driver_type.c_str(), "NPU") == 0) {
+            if (std::strcmp(driver_type.c_str(), "NPU") == 0 || is_npu) {
                 if (!(desc->flags & ZE_INIT_DRIVER_TYPE_FLAG_NPU)) {
                     return ${X}_RESULT_ERROR_UNINITIALIZED;
                 }

source/drivers/null/CMakeLists.txt

@@ -48,6 +48,67 @@ add_library(ze_null_test2 SHARED
     ${CMAKE_CURRENT_SOURCE_DIR}/zer_nullddi.cpp
 )
 
+if(BUILD_L0_LOADER_TESTS)
+    # Add fake Intel GPU and NPU drivers for testing driver type initialization
+    add_library(ze_intel_gpu SHARED
+        ${CMAKE_CURRENT_SOURCE_DIR}/ze_null.h
+        ${CMAKE_CURRENT_SOURCE_DIR}/ze_null.cpp
+        ${CMAKE_CURRENT_SOURCE_DIR}/ze_nullddi.cpp
+        ${CMAKE_CURRENT_SOURCE_DIR}/zet_nullddi.cpp
+        ${CMAKE_CURRENT_SOURCE_DIR}/zes_nullddi.cpp
+        ${CMAKE_CURRENT_SOURCE_DIR}/zer_nullddi.cpp
+    )
+
+    add_library(ze_intel_npu SHARED
+        ${CMAKE_CURRENT_SOURCE_DIR}/ze_null.h
+        ${CMAKE_CURRENT_SOURCE_DIR}/ze_null.cpp
+        ${CMAKE_CURRENT_SOURCE_DIR}/ze_nullddi.cpp
+        ${CMAKE_CURRENT_SOURCE_DIR}/zet_nullddi.cpp
+        ${CMAKE_CURRENT_SOURCE_DIR}/zes_nullddi.cpp
+        ${CMAKE_CURRENT_SOURCE_DIR}/zer_nullddi.cpp
+    )
+    set_target_properties(ze_intel_gpu PROPERTIES
+        VERSION "${PROJECT_VERSION_MAJOR}.${PROJECT_VERSION_MINOR}.${PROJECT_VERSION_PATCH}"
+        SOVERSION "${PROJECT_VERSION_MAJOR}"
+        LIBRARY_OUTPUT_DIRECTORY "${CMAKE_BINARY_DIR}/lib_fake"
+        RUNTIME_OUTPUT_DIRECTORY "${CMAKE_BINARY_DIR}/bin_fake"
+    )
+
+    set_target_properties(ze_intel_npu PROPERTIES
+        VERSION "${PROJECT_VERSION_MAJOR}.${PROJECT_VERSION_MINOR}.${PROJECT_VERSION_PATCH}"
+        SOVERSION "${PROJECT_VERSION_MAJOR}"
+        LIBRARY_OUTPUT_DIRECTORY "${CMAKE_BINARY_DIR}/lib_fake"
+        RUNTIME_OUTPUT_DIRECTORY "${CMAKE_BINARY_DIR}/bin_fake"
+    )
+    target_include_directories(ze_intel_gpu
+        PUBLIC
+            ${CMAKE_CURRENT_SOURCE_DIR}
+    )
+
+    target_include_directories(ze_intel_npu
+        PUBLIC
+            ${CMAKE_CURRENT_SOURCE_DIR}
+    )
+    target_compile_definitions(ze_intel_gpu PUBLIC ZEL_NULL_DRIVER_ID=3 ZEL_NULL_DRIVER_TYPE_GPU=1)
+    target_compile_definitions(ze_intel_npu PUBLIC ZEL_NULL_DRIVER_ID=4 ZEL_NULL_DRIVER_TYPE_NPU=1)
+
+    # Install fake drivers to separate directory
+    if(INSTALL_NULL_DRIVER)
+        install(TARGETS ze_intel_gpu
+            ARCHIVE DESTINATION ${CMAKE_INSTALL_LIBDIR}_fake COMPONENT level-zero-devel
+            RUNTIME DESTINATION ${CMAKE_INSTALL_BINDIR}_fake COMPONENT level-zero
+            LIBRARY DESTINATION ${CMAKE_INSTALL_LIBDIR}_fake COMPONENT level-zero
+            NAMELINK_COMPONENT level-zero-devel
+        )
+        install(TARGETS ze_intel_npu
+            ARCHIVE DESTINATION ${CMAKE_INSTALL_LIBDIR}_fake COMPONENT level-zero-devel
+            RUNTIME DESTINATION ${CMAKE_INSTALL_BINDIR}_fake COMPONENT level-zero
+            LIBRARY DESTINATION ${CMAKE_INSTALL_LIBDIR}_fake COMPONENT level-zero
+            NAMELINK_COMPONENT level-zero-devel
+        )
+    endif()
+endif()
+
 set_target_properties(ze_null_test1 PROPERTIES
     VERSION "${PROJECT_VERSION_MAJOR}.${PROJECT_VERSION_MINOR}.${PROJECT_VERSION_PATCH}"
     SOVERSION "${PROJECT_VERSION_MAJOR}"

source/drivers/null/ze_null.cpp

@@ -376,9 +376,22 @@ namespace driver
             ze_device_properties_t deviceProperties = {};
             deviceProperties.stype = ZE_STRUCTURE_TYPE_DEVICE_PROPERTIES;
             deviceProperties.type = ZE_DEVICE_TYPE_GPU;
+
+            // Check compile-time definitions first
+            #ifdef ZEL_NULL_DRIVER_TYPE_NPU
+            deviceProperties.type = ZE_DEVICE_TYPE_VPU;
+            #endif
+
+            #ifdef ZEL_NULL_DRIVER_TYPE_GPU
+            deviceProperties.type = ZE_DEVICE_TYPE_GPU;
+            #endif
+
+            // Environment variable can override
             auto driver_type = getenv_string( "ZEL_TEST_NULL_DRIVER_TYPE" );
             if (std::strcmp(driver_type.c_str(), "NPU") == 0) {
                 deviceProperties.type = ZE_DEVICE_TYPE_VPU;
+            } else if (std::strcmp(driver_type.c_str(), "GPU") == 0) {
+                deviceProperties.type = ZE_DEVICE_TYPE_GPU;
             }
 #if defined(_WIN32)
             strcpy_s( deviceProperties.name, "Null Device" );

source/drivers/null/ze_nullddi.cpp

@@ -107,13 +107,23 @@ namespace driver
         else
         {
             // generic implementation
+            // Check compile-time definitions first
+            bool is_npu = false;
+            bool is_gpu = false;
+            #ifdef ZEL_NULL_DRIVER_TYPE_NPU
+            is_npu = true;
+            #endif
+
+            #ifdef ZEL_NULL_DRIVER_TYPE_GPU
+            is_gpu = true;
+            #endif
             auto driver_type = getenv_string( "ZEL_TEST_NULL_DRIVER_TYPE" );
-            if (std::strcmp(driver_type.c_str(), "GPU") == 0) {
+            if (std::strcmp(driver_type.c_str(), "GPU") == 0 || is_gpu) {
                 if (!(desc->flags & ZE_INIT_DRIVER_TYPE_FLAG_GPU)) {
                     return ZE_RESULT_ERROR_UNINITIALIZED;
                 }
             }
-            if (std::strcmp(driver_type.c_str(), "NPU") == 0) {
+            if (std::strcmp(driver_type.c_str(), "NPU") == 0 || is_npu) {
                 if (!(desc->flags & ZE_INIT_DRIVER_TYPE_FLAG_NPU)) {
                     return ZE_RESULT_ERROR_UNINITIALIZED;
                 }

source/loader/windows/driver_discovery_win.cpp

@@ -44,7 +44,7 @@ std::vector<DriverLibraryPath> discoverEnabledDrivers() {
         while (ss.good()) {
             std::string substr;
             getline(ss, substr, ',');
-            enabledDrivers.emplace_back(substr, true, false, false);
+            enabledDrivers.emplace_back(substr, true, ZEL_DRIVER_TYPE_FORCE_UINT32);
         }
     }
 

source/loader/ze_loader.cpp

@@ -419,6 +419,7 @@ namespace loader
                 }
                 bool integratedGPU = false;
                 bool discreteGPU = false;
+                bool npu = false;
                 bool other = false;
                 for( auto device : deviceHandles ) {
                     ze_device_properties_t deviceProperties = {};
@@ -438,18 +439,26 @@ namespace loader
                         } else {
                             discreteGPU = true;
                         }
+                    } else  if (deviceProperties.type == ZE_DEVICE_TYPE_VPU) {
+                        npu = true;
                     } else {
                         other = true;
                     }
                 }
-                if (integratedGPU && discreteGPU && other) {
+                if (driver.driverType == ZEL_DRIVER_TYPE_NPU && npu == false) {
+                    // Driver was forced to NPU but no NPU devices found, skip updating type.
+                    continue;
+                }
+                if (integratedGPU && discreteGPU && (other || npu)) {
                     driver.driverType = ZEL_DRIVER_TYPE_MIXED;
                 } else if (integratedGPU && discreteGPU) {
                     driver.driverType = ZEL_DRIVER_TYPE_GPU;
                 } else if (integratedGPU) {
                     driver.driverType = ZEL_DRIVER_TYPE_INTEGRATED_GPU;
                 } else if (discreteGPU) {
                     driver.driverType = ZEL_DRIVER_TYPE_DISCRETE_GPU;
+                } else if (npu) {
+                    driver.driverType = ZEL_DRIVER_TYPE_NPU;
                 } else if (other) {
                     driver.driverType = ZEL_DRIVER_TYPE_OTHER;
                 }
@@ -475,6 +484,10 @@ namespace loader
 
     ze_result_t context_t::init_driver(driver_t &driver, ze_init_flags_t flags, ze_init_driver_type_desc_t* desc) {
         bool loadDriver = false;
+        if (debugTraceEnabled) {
+            std::string message = "Initializing driver " + driver.name + " with type " + std::to_string(driver.driverType);\
+            debug_trace_message(message, "");
+        }
         if ((!desc && (flags == 0 || flags & ZE_INIT_FLAG_GPU_ONLY)) || (desc && desc->flags & ZE_INIT_DRIVER_TYPE_FLAG_GPU)) {
             if (driver.driverType == ZEL_DRIVER_TYPE_GPU || driver.driverType == ZEL_DRIVER_TYPE_DISCRETE_GPU || driver.driverType == ZEL_DRIVER_TYPE_INTEGRATED_GPU) {
                 if (debugTraceEnabled) {
@@ -695,6 +708,7 @@ namespace loader
                 allDrivers.rbegin()->handle = nullptr;
                 allDrivers.rbegin()->name = driverInfo.path;
                 allDrivers.rbegin()->customDriver = driverInfo.customDriver;
+                allDrivers.rbegin()->driverType = driverInfo.driverType;
             }
         }
         if(allDrivers.size()==0){

source/loader/zes_ldrddi.cpp

@@ -130,7 +130,7 @@ namespace loader
             if(drv.initStatus != ZE_RESULT_SUCCESS || drv.initSysManStatus != ZE_RESULT_SUCCESS)
                 continue;
             if (!drv.handle || !drv.ddiInitialized) {
-                auto res = loader::context->init_driver( drv, flags, nullptr);
+                auto res = loader::context->init_driver( drv, flags, nullptr );
                 if (res != ZE_RESULT_SUCCESS) {
                     continue;
                 }

test/CMakeLists.txt

@@ -11,7 +11,19 @@ add_executable(
 # Only include driver_ordering_unit_tests for static builds or non-Windows platforms
 # as it requires internal loader symbols that are not exported in Windows DLLs
 if(BUILD_STATIC OR NOT WIN32)
-  target_sources(tests PRIVATE driver_ordering_unit_tests.cpp init_driver_unit_tests.cpp)
+  target_sources(tests PRIVATE driver_ordering_unit_tests.cpp)
+endif()
+
+# For builds on non-Windows platforms, include init_driver_unit_tests
+# The tests rely on ablity to locate fake drivers by specific names which is not possible on Windows.
+if(NOT WIN32)
+  target_sources(tests PRIVATE init_driver_unit_tests.cpp)
+endif()
+
+# Only build init_driver_dynamic_unit_tests for dynamic builds on non-Windows platforms
+# as it requires internal loader symbols that are not exported in Windows DLLs
+if(NOT BUILD_STATIC AND NOT WIN32)
+  target_sources(tests PRIVATE init_driver_dynamic_unit_tests.cpp)
 endif()
 
 # For static builds, we need to include the loader source files directly
@@ -412,8 +424,8 @@ foreach(test_name IN ITEMS
   set_property(TEST ${test_name}_alt_drivers APPEND PROPERTY ENVIRONMENT "ZE_ENABLE_LOADER_DEBUG_TRACE=1;ZE_ENABLE_NULL_DRIVER=1;${ALT_DRIVERS_ENV}")
 endforeach()
 
-add_test(NAME tests_sigle_driver_sysman_vf_management_api COMMAND tests --gtest_filter=*GivenLevelZeroLoaderPresentWhenCallingSysManVfApisThenExpectNullDriverIsReachedSuccessfully)
-set_property(TEST tests_sigle_driver_sysman_vf_management_api PROPERTY ENVIRONMENT "ZE_ENABLE_NULL_DRIVER=1")
+add_test(NAME tests_single_driver_sysman_vf_management_api COMMAND tests --gtest_filter=*GivenLevelZeroLoaderPresentWhenCallingSysManVfApisThenExpectNullDriverIsReachedSuccessfully)
+set_property(TEST tests_single_driver_sysman_vf_management_api PROPERTY ENVIRONMENT "ZE_ENABLE_NULL_DRIVER=1")
 
 add_test(NAME tests_multi_driver_sysman_vf_management_api COMMAND tests --gtest_filter=*GivenLevelZeroLoaderPresentWhenCallingSysManVfApisThenExpectNullDriverIsReachedSuccessfully)
 if (MSVC)
@@ -629,7 +641,13 @@ set_property(TEST driver_ordering_parse_driver_order PROPERTY ENVIRONMENT "ZE_EN
 
 # Init Driver Unit Tests
 add_test(NAME init_driver_unit_tests COMMAND tests --gtest_filter=InitDriverUnitTest.*)
-set_property(TEST init_driver_unit_tests PROPERTY ENVIRONMENT "ZE_ENABLE_LOADER_DEBUG_TRACE=1;ZE_ENABLE_NULL_DRIVER=1")
+if (MSVC)
+  set_property(TEST init_driver_unit_tests PROPERTY ENVIRONMENT "ZE_ENABLE_LOADER_DEBUG_TRACE=1;ZE_ENABLE_NULL_DRIVER=1;")
+elseif(NOT BUILD_STATIC)
+  set_property(TEST init_driver_unit_tests PROPERTY ENVIRONMENT "ZE_ENABLE_LOADER_DEBUG_TRACE=1;ZE_ENABLE_NULL_DRIVER=1;LD_LIBRARY_PATH=${CMAKE_BINARY_DIR}/lib_fake:${CMAKE_BINARY_DIR}/lib/")
+else()
+  set_property(TEST init_driver_unit_tests PROPERTY ENVIRONMENT "ZE_ENABLE_LOADER_DEBUG_TRACE=1;ZE_ENABLE_NULL_DRIVER=1;")
+endif()
 
 # 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)