Refactor Init to delay Library Load

.github/workflows/build-quick-static-n-1.yml

@@ -54,6 +54,7 @@ jobs:
             -D CMAKE_CXX_COMPILER_LAUNCHER=ccache \
             -D CMAKE_BUILD_TYPE=Release \
             -D BUILD_STATIC=0 \
+            -D BUILD_L0_LOADER_TESTS=1 \
             ..
           make -j$(nproc)
 

.github/workflows/build-quick-static.yml

@@ -35,6 +35,7 @@ jobs:
               -D CMAKE_C_COMPILER_LAUNCHER=ccache \
               -D CMAKE_CXX_COMPILER_LAUNCHER=ccache \
               -D CMAKE_BUILD_TYPE=Release \
+              -D BUILD_L0_LOADER_TESTS=1 \
               -D BUILD_STATIC=0 \
               ..
             make -j$(nproc)

CHANGELOG.md

@@ -1,4 +1,6 @@
 # Level zero loader changelog
+## v1.26.0
+* Refactor L0 Init to delay loading of driver libraries until flags match the drivers requested.
 ## v1.25.2
 * Enable support for Dynamic Tracing of zer* APIs
 * Fix issues with zer* apis during validation layer intercepts

CMakeLists.txt

@@ -13,7 +13,7 @@ if(MSVC AND (MSVC_VERSION LESS 1900))
 endif()
 
 # This project follows semantic versioning (https://semver.org/)
-project(level-zero VERSION 1.25.2)
+project(level-zero VERSION 1.26.0)
 include(GNUInstallDirs)
 
 find_package(Git)

PRODUCT_GUID.txt

@@ -1,2 +1,2 @@
-1.25.2
-738dfd00-2750-4425-9d91-6b68a2590ded
+1.26.0
+af2b4113-ecb0-4777-b3ce-d81307ed1156

samples/zello_world/zello_world.cpp

@@ -42,6 +42,7 @@ int main( int argc, char *argv[] )
     bool tracing_runtime_enabled = false;
     bool legacy_init = false;
     bool tracing_enabled = false;
+    bool npu_test = false;
     if( argparse( argc, argv, "-null", "--enable_null_driver" ) )
     {
         putenv_safe( const_cast<char *>( "ZE_ENABLE_NULL_DRIVER=1" ) );
@@ -69,13 +70,25 @@ int main( int argc, char *argv[] )
     {
         legacy_init = true;
     }
+    if( argparse( argc, argv, "-npu", "--enable_npu" ) )
+    {
+        npu_test = true;
+    }
 
     ze_result_t status;
-    const ze_device_type_t type = ZE_DEVICE_TYPE_GPU;
+    ze_device_type_t type = ZE_DEVICE_TYPE_GPU;
+    if (npu_test) {
+        std::cout << "NPU Test Enabled. Looking for NPU devices." << std::endl;
+        type = ZE_DEVICE_TYPE_VPU;
+    }
 
     ze_init_driver_type_desc_t driverTypeDesc = {};
     driverTypeDesc.stype = ZE_STRUCTURE_TYPE_INIT_DRIVER_TYPE_DESC;
-    driverTypeDesc.flags = ZE_INIT_DRIVER_TYPE_FLAG_GPU;
+    if (npu_test) {
+        driverTypeDesc.flags = ZE_INIT_DRIVER_TYPE_FLAG_NPU;
+    } else {
+        driverTypeDesc.flags = ZE_INIT_DRIVER_TYPE_FLAG_GPU;
+    }
     driverTypeDesc.pNext = nullptr;
 
     ze_driver_handle_t pDriver = nullptr;

scripts/templates/ldrddi.cpp.mako

@@ -22,6 +22,17 @@ using namespace loader_driver_ddi;
 
 namespace loader
 {
+    __${x}dlllocal ze_result_t ${X}_APICALL
+    ${n}loaderInitDriverDDITables(loader::driver_t *driver) {
+        ze_result_t result = ZE_RESULT_SUCCESS;
+        %for tbl in th.get_pfntables(specs, meta, n, tags):
+        result = ${tbl['export']['name']}FromDriver(driver);
+        if (result != ZE_RESULT_SUCCESS) {
+            return result;
+        }
+        %endfor
+        return result;
+    }
     %for obj in th.extract_objs(specs, r"function"):
     <%
     ret_type = obj['return_type']
@@ -65,6 +76,12 @@ namespace loader
             if(drv.initStatus != ZE_RESULT_SUCCESS)
                 continue;
             %endif
+            if (!drv.handle || !drv.ddiInitialized) {
+                auto res = loader::context->init_driver( drv, flags, nullptr );
+                if (res != ZE_RESULT_SUCCESS) {
+                    continue;
+                }
+            }
         %if re.match(r"Init", obj['name']) and namespace == "zes":
             if (!drv.dditable.${n}.${th.get_table_name(n, tags, obj)}.${th.make_pfn_name(n, tags, obj)}) {
                 drv.initSysManStatus = ZE_RESULT_ERROR_UNINITIALIZED;
@@ -90,6 +107,13 @@ namespace loader
 
         %elif re.match(r"\w+DriverGet$", th.make_func_name(n, tags, obj)) or re.match(r"\w+InitDrivers$", th.make_func_name(n, tags, obj)):
         uint32_t total_driver_handle_count = 0;
+        %if re.match(r"\w+InitDrivers$", th.make_func_name(n, tags, obj)):
+        for( auto& drv : loader::context->zeDrivers ) {
+            if (!drv.handle || !drv.ddiInitialized) {
+                loader::context->init_driver( drv, 0, desc);
+            }
+        }
+        %endif
 
         {
             std::lock_guard<std::mutex> lock(loader::context->sortMutex);
@@ -122,15 +146,16 @@ namespace loader
         %endif
         {
             %if not (re.match(r"\w+InitDrivers$", th.make_func_name(n, tags, obj))) and namespace != "zes":
-            if(drv.initStatus != ZE_RESULT_SUCCESS)
+            if(drv.initStatus != ZE_RESULT_SUCCESS || !drv.ddiInitialized)
                 continue;
             %elif namespace == "zes":
-            if(drv.initStatus != ZE_RESULT_SUCCESS || drv.initSysManStatus != ZE_RESULT_SUCCESS)
+            if(drv.initStatus != ZE_RESULT_SUCCESS || drv.initSysManStatus != ZE_RESULT_SUCCESS || !drv.ddiInitialized)
                 continue;
             %else:
             if (!drv.dditable.${n}.${th.get_table_name(n, tags, obj)}.${th.make_pfn_name(n, tags, obj)}) {
                 %if re.match(r"\w+InitDrivers$", th.make_func_name(n, tags, obj)):
                 drv.initDriversStatus = ${X}_RESULT_ERROR_UNINITIALIZED;
+                result = ${X}_RESULT_ERROR_UNINITIALIZED;
                 %else:
                 drv.initStatus = ${X}_RESULT_ERROR_UNINITIALIZED;
                 %endif
@@ -179,7 +204,8 @@ namespace loader
                     for( uint32_t i = 0; i < library_driver_handle_count; ++i ) {
                         uint32_t driver_index = total_driver_handle_count + i;
                         %if namespace != "zes":
-                        drv.zerDriverHandle = phDrivers[ driver_index ];
+                        if (drv.zerddiInitResult == ZE_RESULT_SUCCESS)
+                            drv.zerDriverHandle = phDrivers[ driver_index ];
                         if (drv.driverDDIHandleSupportQueried == false) {
                             uint32_t extensionCount = 0;
                             ze_result_t res = drv.dditable.ze.Driver.pfnGetExtensionProperties(phDrivers[ driver_index ], &extensionCount, nullptr);
@@ -503,6 +529,52 @@ ${tbl['export']['name']}Legacy()
 
 %endfor
 
+%for tbl in th.get_pfntables(specs, meta, n, tags):
+///////////////////////////////////////////////////////////////////////////////
+/// @brief Exported function for filling application's ${tbl['name']} table
+///        with current process' addresses
+///
+/// @returns
+///     - ::${X}_RESULT_SUCCESS
+///     - ::${X}_RESULT_ERROR_UNINITIALIZED
+///     - ::${X}_RESULT_ERROR_INVALID_NULL_POINTER
+///     - ::${X}_RESULT_ERROR_UNSUPPORTED_VERSION
+__${x}dlllocal ${x}_result_t ${X}_APICALL
+${tbl['export']['name']}FromDriver(loader::driver_t *driver)
+{
+    ${x}_result_t result = ${X}_RESULT_SUCCESS;
+    if(driver->initStatus != ZE_RESULT_SUCCESS)
+        return driver->initStatus;
+    auto getTable = reinterpret_cast<${tbl['pfn']}>(
+        GET_FUNCTION_PTR( driver->handle, "${tbl['export']['name']}") );
+    if(!getTable) 
+    %if th.isNewProcTable(tbl['export']['name']) is True and namespace != "zer":
+    {
+        //It is valid to not have this proc addr table
+        return ${X}_RESULT_SUCCESS;
+    }
+    %else:
+        return driver->initStatus;
+    %endif
+    %if tbl['experimental'] is False and namespace != "zer": #//Experimental Tables may not be implemented in driver
+    auto getTableResult = getTable( loader::context->ddi_init_version, &driver->dditable.${n}.${tbl['name']});
+    if(getTableResult == ZE_RESULT_SUCCESS) {
+        loader::context->configured_version = loader::context->ddi_init_version;
+    } else
+        driver->initStatus = getTableResult;
+    %if namespace != "zes":
+    %if tbl['name'] == "Global" and namespace != "zer":
+    if (driver->dditable.ze.Global.pfnInitDrivers) {
+        loader::context->initDriversSupport = true;
+    }
+    %endif
+    %endif
+    %else:
+    result = getTable( loader::context->ddi_init_version, &driver->dditable.${n}.${tbl['name']});
+    %endif
+    return result;
+}
+%endfor
 %for tbl in th.get_pfntables(specs, meta, n, tags):
 ///////////////////////////////////////////////////////////////////////////////
 /// @brief Exported function for filling application's ${tbl['name']} table
@@ -534,63 +606,26 @@ ${tbl['export']['name']}(
     if( loader::context->version < version )
         return ${X}_RESULT_ERROR_UNSUPPORTED_VERSION;
 
+    loader::context->ddi_init_version = version;
+
     ${x}_result_t result = ${X}_RESULT_SUCCESS;
 
-    %if tbl['experimental'] is False and namespace != "zer": #//Experimental Tables may not be implemented in driver
-    bool atLeastOneDriverValid = false;
-    %endif
-    // Load the device-driver DDI tables
     %if namespace != "zes":
-    for( auto& drv : loader::context->zeDrivers )
+    auto driverCount = loader::context->zeDrivers.size();
+    auto firstDriver = &loader::context->zeDrivers[0];
     %else:
-    for( auto& drv : *loader::context->sysmanInstanceDrivers )
+    auto driverCount = loader::context->sysmanInstanceDrivers->size();
+    auto firstDriver = &loader::context->sysmanInstanceDrivers->at(0);
     %endif
-    {
-        if(drv.initStatus != ZE_RESULT_SUCCESS)
-            continue;
-        auto getTable = reinterpret_cast<${tbl['pfn']}>(
-            GET_FUNCTION_PTR( drv.handle, "${tbl['export']['name']}") );
-        if(!getTable) 
-        %if th.isNewProcTable(tbl['export']['name']) is True and namespace != "zer":
-        {
-            atLeastOneDriverValid = true;
-            //It is valid to not have this proc addr table
-            continue; 
-        }
-        %else:
-            continue; 
-        %endif
-        %if tbl['experimental'] is False and namespace != "zer": #//Experimental Tables may not be implemented in driver
-        auto getTableResult = getTable( version, &drv.dditable.${n}.${tbl['name']});
-        if(getTableResult == ZE_RESULT_SUCCESS) {
-            atLeastOneDriverValid = true;
-            loader::context->configured_version = version;
-        } else
-            drv.initStatus = getTableResult;
-        %if namespace != "zes":
-        %if tbl['name'] == "Global" and namespace != "zer":
-        if (drv.dditable.ze.Global.pfnInitDrivers) {
-            loader::context->initDriversSupport = true;
-        }
-        %endif
-        %endif
-        %else:
-        result = getTable( version, &drv.dditable.${n}.${tbl['name']});
-        %endif
+    if (driverCount == 1 && firstDriver && !loader::context->forceIntercept) {
+        result = ${tbl['export']['name']}FromDriver(firstDriver);
     }
 
-    %if tbl['experimental'] is False and namespace != "zer": #//Experimental Tables may not be implemented in driver
-    if(!atLeastOneDriverValid)
-        result = ${X}_RESULT_ERROR_UNINITIALIZED;
-    else
-        result = ${X}_RESULT_SUCCESS;
-    %endif
-
     if( ${X}_RESULT_SUCCESS == result )
     {
         %if namespace != "zes":
         if( ( loader::context->zeDrivers.size() > 1 ) || loader::context->forceIntercept )
-        %else:
+        %elif namespace == "zes":
         if( ( loader::context->sysmanInstanceDrivers->size() > 1 ) || loader::context->forceIntercept )
         %endif
         {

scripts/templates/ldrddi.h.mako

@@ -20,6 +20,10 @@ from templates import helper as th
 
 namespace loader
 {
+    ///////////////////////////////////////////////////////////////////////////////
+    // Forward declaration for driver_t so this header can reference loader::driver_t*
+    // without requiring inclusion of ze_loader_internal.h (which includes this file).
+    struct driver_t;
     ///////////////////////////////////////////////////////////////////////////////
     %for obj in th.extract_objs(specs, r"handle"):
     %if 'class' in obj:
@@ -32,6 +36,8 @@ namespace loader
 
     %endif
     %endfor
+    __${x}dlllocal ze_result_t ${X}_APICALL
+    ${n}loaderInitDriverDDITables(loader::driver_t *driver);
 }
 
 namespace loader_driver_ddi
@@ -57,6 +63,8 @@ extern "C" {
 %for tbl in th.get_pfntables(specs, meta, n, tags):
 __${x}dlllocal void ${X}_APICALL
 ${tbl['export']['name']}Legacy();
+__${x}dlllocal ze_result_t ${X}_APICALL
+${tbl['export']['name']}FromDriver(loader::driver_t *driver);
 %endfor
 
 #if defined(__cplusplus)

scripts/templates/ldrddi_driver_ddi.cpp.mako

@@ -103,8 +103,15 @@ namespace loader_driver_ddi
         // Check if the default driver supports DDI Handles
         if (loader::context->defaultZerDriverHandle == nullptr) {
             %if ret_type == 'ze_result_t':
+            if (loader::context->zeDrivers.front().zerddiInitResult == ZE_RESULT_ERROR_UNSUPPORTED_FEATURE) {
+                return ${X}_RESULT_ERROR_UNSUPPORTED_FEATURE;
+            }
             return ${X}_RESULT_ERROR_UNINITIALIZED;
             %else:
+            if (loader::context->zeDrivers.front().zerddiInitResult == ZE_RESULT_ERROR_UNSUPPORTED_FEATURE) {
+                error_state::setErrorDesc("ERROR UNSUPPORTED FEATURE");
+                return ${failure_return};
+            }
             error_state::setErrorDesc("ERROR UNINITIALIZED");
             return ${failure_return};
             %endif

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;
                 }

scripts/templates/ze_loader_internal.h.mako

@@ -70,6 +70,13 @@ namespace loader
         bool driverDDIHandleSupportQueried = false;
         ze_driver_handle_t zerDriverHandle = nullptr;
         bool zerDriverDDISupported = true;
+        ze_api_version_t versionRequested = ZE_API_VERSION_CURRENT;
+        bool ddiInitialized = false;
+        bool customDriver = false;
+        ze_result_t zeddiInitResult = ZE_RESULT_ERROR_UNINITIALIZED;
+        ze_result_t zetddiInitResult = ZE_RESULT_ERROR_UNINITIALIZED;
+        ze_result_t zesddiInitResult = ZE_RESULT_ERROR_UNINITIALIZED;
+        ze_result_t zerddiInitResult = ZE_RESULT_ERROR_UNINITIALIZED;
     };
 
     using driver_vector_t = std::vector< driver_t >;
@@ -98,6 +105,7 @@ namespace loader
         std::unordered_map<ze_sampler_object_t *, ze_sampler_handle_t>        sampler_handle_map;
         ze_api_version_t version = ZE_API_VERSION_CURRENT;
         ze_api_version_t configured_version = ZE_API_VERSION_CURRENT;
+        ze_api_version_t ddi_init_version = ZE_API_VERSION_CURRENT;
 
         driver_vector_t allDrivers;
         driver_vector_t zeDrivers;
@@ -113,10 +121,9 @@ namespace loader
         std::vector<zel_component_version_t> compVersions;
         const char *LOADER_COMP_NAME = "loader";
 
-        ze_result_t check_drivers(ze_init_flags_t flags, ze_init_driver_type_desc_t* desc, ze_global_dditable_t *globalInitStored, zes_global_dditable_t *sysmanGlobalInitStored, bool *requireDdiReinit, bool sysmanOnly);
         void debug_trace_message(std::string errorMessage, std::string errorValue);
         ze_result_t init();
-        ze_result_t init_driver(driver_t &driver, ze_init_flags_t flags, ze_init_driver_type_desc_t* desc, ze_global_dditable_t *globalInitStored, zes_global_dditable_t *sysmanGlobalInitStored, bool sysmanOnly);
+        ze_result_t init_driver(driver_t &driver, ze_init_flags_t flags, ze_init_driver_type_desc_t* desc);
         void add_loader_version();
         bool driverSorting(driver_vector_t *drivers, ze_init_driver_type_desc_t* desc, bool sysmanOnly);
         void driverOrdering(driver_vector_t *drivers);
@@ -130,6 +137,7 @@ namespace loader
         std::atomic<bool> sortingInProgress = {false};
         std::mutex sortMutex;
         bool instrumentationEnabled = false;
+        bool pciOrderingRequested = false;
         dditable_t tracing_dditable = {};
         std::shared_ptr<Logger> zel_logger;
         ze_driver_handle_t defaultZerDriverHandle = nullptr;