diff --git a/scripts/templates/ldrddi.cpp.mako b/scripts/templates/ldrddi.cpp.mako index 2a3ebdca..f49f5ed4 100644 --- a/scripts/templates/ldrddi.cpp.mako +++ b/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,17 @@ namespace loader if(drv.initStatus != ZE_RESULT_SUCCESS) continue; %endif + if (!drv.handle || !drv.ddiInitialized) { + %if namespace != "zes": + bool sysmanInit = false; + %else: + bool sysmanInit = true; + %endif + auto res = loader::context->init_driver( drv, flags, nullptr, nullptr, nullptr, sysmanInit ); + 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 +112,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, nullptr, nullptr, false ); + } + } + %endif { std::lock_guard lock(loader::context->sortMutex); @@ -124,15 +153,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 @@ -495,6 +525,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: + { + //It is valid to not have this proc addr table + return ${X}_RESULT_SUCCESS; + } + %else: + return driver->initStatus; + %endif + %if tbl['experimental'] is False: #//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": + 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 @@ -526,63 +602,17 @@ ${tbl['export']['name']}( if( loader::context->version < version ) return ${X}_RESULT_ERROR_UNSUPPORTED_VERSION; - ${x}_result_t result = ${X}_RESULT_SUCCESS; - - %if tbl['experimental'] is False: #//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 ) - %else: - for( auto& drv : *loader::context->sysmanInstanceDrivers ) - %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: - { - atLeastOneDriverValid = true; - //It is valid to not have this proc addr table - continue; - } - %else: - continue; - %endif - %if tbl['experimental'] is False: #//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": - if (drv.dditable.ze.Global.pfnInitDrivers) { - loader::context->initDriversSupport = true; - } - %endif - %endif - %else: - result = getTable( version, &drv.dditable.${n}.${tbl['name']}); - %endif - } + loader::context->ddi_init_version = version; - %if tbl['experimental'] is False: #//Experimental Tables may not be implemented in driver - if(!atLeastOneDriverValid) - result = ${X}_RESULT_ERROR_UNINITIALIZED; - else - result = ${X}_RESULT_SUCCESS; - %endif + ${x}_result_t result = ${X}_RESULT_SUCCESS; if( ${X}_RESULT_SUCCESS == result ) { - %if namespace != "zes": + %if tbl['name'] == "Global": + if( true ) + %elif 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 { diff --git a/scripts/templates/ldrddi.h.mako b/scripts/templates/ldrddi.h.mako index 7c4a3ae5..5885d026 100644 --- a/scripts/templates/ldrddi.h.mako +++ b/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) diff --git a/scripts/templates/ze_loader_internal.h.mako b/scripts/templates/ze_loader_internal.h.mako index 03803765..5ea114c4 100644 --- a/scripts/templates/ze_loader_internal.h.mako +++ b/scripts/templates/ze_loader_internal.h.mako @@ -69,6 +69,8 @@ namespace loader bool legacyInitAttempted = false; bool driverDDIHandleSupportQueried = false; ze_driver_handle_t zerDriverHandle = nullptr; + ze_api_version_t versionRequested = ZE_API_VERSION_CURRENT; + bool ddiInitialized = false; }; using driver_vector_t = std::vector< driver_t >; @@ -97,6 +99,7 @@ namespace loader std::unordered_map 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; @@ -129,6 +132,7 @@ namespace loader std::atomic sortingInProgress = {false}; std::mutex sortMutex; bool instrumentationEnabled = false; + bool pciOrderingRequested = false; dditable_t tracing_dditable = {}; std::shared_ptr zel_logger; ze_driver_handle_t* defaultZerDriverHandle = nullptr; diff --git a/source/loader/ze_ldrddi.cpp b/source/loader/ze_ldrddi.cpp index e4d867b2..db86f15c 100644 --- a/source/loader/ze_ldrddi.cpp +++ b/source/loader/ze_ldrddi.cpp @@ -13,6 +13,131 @@ using namespace loader_driver_ddi; namespace loader { + __zedlllocal ze_result_t ZE_APICALL + zeloaderInitDriverDDITables(loader::driver_t *driver) { + ze_result_t result = ZE_RESULT_SUCCESS; + result = zeGetGlobalProcAddrTableFromDriver(driver); + if (result != ZE_RESULT_SUCCESS) { + return result; + } + result = zeGetRTASBuilderProcAddrTableFromDriver(driver); + if (result != ZE_RESULT_SUCCESS) { + return result; + } + result = zeGetRTASBuilderExpProcAddrTableFromDriver(driver); + if (result != ZE_RESULT_SUCCESS) { + return result; + } + result = zeGetRTASParallelOperationProcAddrTableFromDriver(driver); + if (result != ZE_RESULT_SUCCESS) { + return result; + } + result = zeGetRTASParallelOperationExpProcAddrTableFromDriver(driver); + if (result != ZE_RESULT_SUCCESS) { + return result; + } + result = zeGetDriverProcAddrTableFromDriver(driver); + if (result != ZE_RESULT_SUCCESS) { + return result; + } + result = zeGetDriverExpProcAddrTableFromDriver(driver); + if (result != ZE_RESULT_SUCCESS) { + return result; + } + result = zeGetDeviceProcAddrTableFromDriver(driver); + if (result != ZE_RESULT_SUCCESS) { + return result; + } + result = zeGetDeviceExpProcAddrTableFromDriver(driver); + if (result != ZE_RESULT_SUCCESS) { + return result; + } + result = zeGetContextProcAddrTableFromDriver(driver); + if (result != ZE_RESULT_SUCCESS) { + return result; + } + result = zeGetCommandQueueProcAddrTableFromDriver(driver); + if (result != ZE_RESULT_SUCCESS) { + return result; + } + result = zeGetCommandListProcAddrTableFromDriver(driver); + if (result != ZE_RESULT_SUCCESS) { + return result; + } + result = zeGetCommandListExpProcAddrTableFromDriver(driver); + if (result != ZE_RESULT_SUCCESS) { + return result; + } + result = zeGetEventProcAddrTableFromDriver(driver); + if (result != ZE_RESULT_SUCCESS) { + return result; + } + result = zeGetEventExpProcAddrTableFromDriver(driver); + if (result != ZE_RESULT_SUCCESS) { + return result; + } + result = zeGetEventPoolProcAddrTableFromDriver(driver); + if (result != ZE_RESULT_SUCCESS) { + return result; + } + result = zeGetFenceProcAddrTableFromDriver(driver); + if (result != ZE_RESULT_SUCCESS) { + return result; + } + result = zeGetImageProcAddrTableFromDriver(driver); + if (result != ZE_RESULT_SUCCESS) { + return result; + } + result = zeGetImageExpProcAddrTableFromDriver(driver); + if (result != ZE_RESULT_SUCCESS) { + return result; + } + result = zeGetKernelProcAddrTableFromDriver(driver); + if (result != ZE_RESULT_SUCCESS) { + return result; + } + result = zeGetKernelExpProcAddrTableFromDriver(driver); + if (result != ZE_RESULT_SUCCESS) { + return result; + } + result = zeGetMemProcAddrTableFromDriver(driver); + if (result != ZE_RESULT_SUCCESS) { + return result; + } + result = zeGetMemExpProcAddrTableFromDriver(driver); + if (result != ZE_RESULT_SUCCESS) { + return result; + } + result = zeGetModuleProcAddrTableFromDriver(driver); + if (result != ZE_RESULT_SUCCESS) { + return result; + } + result = zeGetModuleBuildLogProcAddrTableFromDriver(driver); + if (result != ZE_RESULT_SUCCESS) { + return result; + } + result = zeGetPhysicalMemProcAddrTableFromDriver(driver); + if (result != ZE_RESULT_SUCCESS) { + return result; + } + result = zeGetSamplerProcAddrTableFromDriver(driver); + if (result != ZE_RESULT_SUCCESS) { + return result; + } + result = zeGetVirtualMemProcAddrTableFromDriver(driver); + if (result != ZE_RESULT_SUCCESS) { + return result; + } + result = zeGetFabricEdgeExpProcAddrTableFromDriver(driver); + if (result != ZE_RESULT_SUCCESS) { + return result; + } + result = zeGetFabricVertexExpProcAddrTableFromDriver(driver); + if (result != ZE_RESULT_SUCCESS) { + return result; + } + return result; + } /////////////////////////////////////////////////////////////////////////////// /// @brief Intercept function for zeInit __zedlllocal ze_result_t ZE_APICALL @@ -28,6 +153,13 @@ namespace loader { if(drv.initStatus != ZE_RESULT_SUCCESS) continue; + if (!drv.handle || !drv.ddiInitialized) { + bool sysmanInit = false; + auto res = loader::context->init_driver( drv, flags, nullptr, nullptr, nullptr, sysmanInit ); + if (res != ZE_RESULT_SUCCESS) { + continue; + } + } drv.initStatus = drv.dditable.ze.Global.pfnInit( flags ); if(drv.initStatus == ZE_RESULT_SUCCESS) atLeastOneDriverValid = true; @@ -72,7 +204,7 @@ namespace loader for( auto& drv : loader::context->zeDrivers ) { - if(drv.initStatus != ZE_RESULT_SUCCESS) + if(drv.initStatus != ZE_RESULT_SUCCESS || !drv.ddiInitialized) continue; if( ( 0 < *pCount ) && ( *pCount == total_driver_handle_count)) @@ -202,6 +334,11 @@ namespace loader ze_result_t result = ZE_RESULT_SUCCESS; uint32_t total_driver_handle_count = 0; + for( auto& drv : loader::context->zeDrivers ) { + if (!drv.handle || !drv.ddiInitialized) { + loader::context->init_driver( drv, 0, desc, nullptr, nullptr, false ); + } + } { std::lock_guard lock(loader::context->sortMutex); @@ -219,6 +356,7 @@ namespace loader { if (!drv.dditable.ze.Global.pfnInitDrivers) { drv.initDriversStatus = ZE_RESULT_ERROR_UNINITIALIZED; + result = ZE_RESULT_ERROR_UNINITIALIZED; continue; } @@ -7627,100 +7765,26 @@ zeGetFabricVertexExpProcAddrTableLegacy() /// - ::ZE_RESULT_ERROR_UNINITIALIZED /// - ::ZE_RESULT_ERROR_INVALID_NULL_POINTER /// - ::ZE_RESULT_ERROR_UNSUPPORTED_VERSION -ZE_DLLEXPORT ze_result_t ZE_APICALL -zeGetGlobalProcAddrTable( - ze_api_version_t version, ///< [in] API version requested - ze_global_dditable_t* pDdiTable ///< [in,out] pointer to table of DDI function pointers - ) +__zedlllocal ze_result_t ZE_APICALL +zeGetGlobalProcAddrTableFromDriver(loader::driver_t *driver) { - if( loader::context->zeDrivers.size() < 1 ) { - return ZE_RESULT_ERROR_UNINITIALIZED; - } - - if( nullptr == pDdiTable ) - return ZE_RESULT_ERROR_INVALID_NULL_POINTER; - - if( loader::context->version < version ) - return ZE_RESULT_ERROR_UNSUPPORTED_VERSION; - ze_result_t result = ZE_RESULT_SUCCESS; - - bool atLeastOneDriverValid = false; - // Load the device-driver DDI tables - for( auto& drv : loader::context->zeDrivers ) - { - if(drv.initStatus != ZE_RESULT_SUCCESS) - continue; - auto getTable = reinterpret_cast( - GET_FUNCTION_PTR( drv.handle, "zeGetGlobalProcAddrTable") ); - if(!getTable) - continue; - auto getTableResult = getTable( version, &drv.dditable.ze.Global); - if(getTableResult == ZE_RESULT_SUCCESS) { - atLeastOneDriverValid = true; - loader::context->configured_version = version; - } else - drv.initStatus = getTableResult; - if (drv.dditable.ze.Global.pfnInitDrivers) { - loader::context->initDriversSupport = true; - } - } - - if(!atLeastOneDriverValid) - result = ZE_RESULT_ERROR_UNINITIALIZED; - else - result = ZE_RESULT_SUCCESS; - - if( ZE_RESULT_SUCCESS == result ) - { - if( ( loader::context->zeDrivers.size() > 1 ) || loader::context->forceIntercept ) - { - // return pointers to loader's DDIs - loader::loaderDispatch->pCore->Global = new ze_global_dditable_t; - if (version >= ZE_API_VERSION_1_0) { - pDdiTable->pfnInit = loader::zeInit; - } - if (version >= ZE_API_VERSION_1_10) { - pDdiTable->pfnInitDrivers = loader::zeInitDrivers; - } - zeGetGlobalProcAddrTableLegacy(); - } - else - { - // return pointers directly to driver's DDIs - *pDdiTable = loader::context->zeDrivers.front().dditable.ze.Global; - } - } - - // If the validation layer is enabled, then intercept the loader's DDIs - if(( ZE_RESULT_SUCCESS == result ) && ( nullptr != loader::context->validationLayer )) - { - auto getTable = reinterpret_cast( - GET_FUNCTION_PTR(loader::context->validationLayer, "zeGetGlobalProcAddrTable") ); - if(!getTable) - return ZE_RESULT_ERROR_UNINITIALIZED; - result = getTable( version, pDdiTable ); - } - - // If the API tracing layer is enabled, then intercept the loader's DDIs - if(( ZE_RESULT_SUCCESS == result ) && ( nullptr != loader::context->tracingLayer )) - { - auto getTable = reinterpret_cast( - GET_FUNCTION_PTR(loader::context->tracingLayer, "zeGetGlobalProcAddrTable") ); - if(!getTable) - return ZE_RESULT_ERROR_UNINITIALIZED; - ze_global_dditable_t dditable; - memcpy(&dditable, pDdiTable, sizeof(ze_global_dditable_t)); - result = getTable( version, &dditable ); - loader::context->tracing_dditable.ze.Global = dditable; - if ( loader::context->tracingLayerEnabled ) { - result = getTable( version, pDdiTable ); - } + if(driver->initStatus != ZE_RESULT_SUCCESS) + return driver->initStatus; + auto getTable = reinterpret_cast( + GET_FUNCTION_PTR( driver->handle, "zeGetGlobalProcAddrTable") ); + if(!getTable) + return driver->initStatus; + auto getTableResult = getTable( loader::context->ddi_init_version, &driver->dditable.ze.Global); + if(getTableResult == ZE_RESULT_SUCCESS) { + loader::context->configured_version = loader::context->ddi_init_version; + } else + driver->initStatus = getTableResult; + if (driver->dditable.ze.Global.pfnInitDrivers) { + loader::context->initDriversSupport = true; } - return result; } - /////////////////////////////////////////////////////////////////////////////// /// @brief Exported function for filling application's RTASBuilder table /// with current process' addresses @@ -7730,126 +7794,23 @@ zeGetGlobalProcAddrTable( /// - ::ZE_RESULT_ERROR_UNINITIALIZED /// - ::ZE_RESULT_ERROR_INVALID_NULL_POINTER /// - ::ZE_RESULT_ERROR_UNSUPPORTED_VERSION -ZE_DLLEXPORT ze_result_t ZE_APICALL -zeGetRTASBuilderProcAddrTable( - ze_api_version_t version, ///< [in] API version requested - ze_rtas_builder_dditable_t* pDdiTable ///< [in,out] pointer to table of DDI function pointers - ) +__zedlllocal ze_result_t ZE_APICALL +zeGetRTASBuilderProcAddrTableFromDriver(loader::driver_t *driver) { - if( loader::context->zeDrivers.size() < 1 ) { - return ZE_RESULT_ERROR_UNINITIALIZED; - } - - if( nullptr == pDdiTable ) - return ZE_RESULT_ERROR_INVALID_NULL_POINTER; - - if( loader::context->version < version ) - return ZE_RESULT_ERROR_UNSUPPORTED_VERSION; - ze_result_t result = ZE_RESULT_SUCCESS; - - bool atLeastOneDriverValid = false; - // Load the device-driver DDI tables - for( auto& drv : loader::context->zeDrivers ) - { - if(drv.initStatus != ZE_RESULT_SUCCESS) - continue; - auto getTable = reinterpret_cast( - GET_FUNCTION_PTR( drv.handle, "zeGetRTASBuilderProcAddrTable") ); - if(!getTable) - continue; - auto getTableResult = getTable( version, &drv.dditable.ze.RTASBuilder); - if(getTableResult == ZE_RESULT_SUCCESS) { - atLeastOneDriverValid = true; - loader::context->configured_version = version; - } else - drv.initStatus = getTableResult; - } - - if(!atLeastOneDriverValid) - result = ZE_RESULT_ERROR_UNINITIALIZED; - else - result = ZE_RESULT_SUCCESS; - - if( ZE_RESULT_SUCCESS == result ) - { - if( ( loader::context->zeDrivers.size() > 1 ) || loader::context->forceIntercept ) - { - // return pointers to loader's DDIs - loader::loaderDispatch->pCore->RTASBuilder = new ze_rtas_builder_dditable_t; - if (version >= ZE_API_VERSION_1_13) { - if (loader::context->driverDDIPathDefault) { - pDdiTable->pfnCreateExt = loader_driver_ddi::zeRTASBuilderCreateExt; - } else { - pDdiTable->pfnCreateExt = loader::zeRTASBuilderCreateExt; - } - } - if (version >= ZE_API_VERSION_1_13) { - if (loader::context->driverDDIPathDefault) { - pDdiTable->pfnGetBuildPropertiesExt = loader_driver_ddi::zeRTASBuilderGetBuildPropertiesExt; - } else { - pDdiTable->pfnGetBuildPropertiesExt = loader::zeRTASBuilderGetBuildPropertiesExt; - } - } - if (version >= ZE_API_VERSION_1_13) { - if (loader::context->driverDDIPathDefault) { - pDdiTable->pfnBuildExt = loader_driver_ddi::zeRTASBuilderBuildExt; - } else { - pDdiTable->pfnBuildExt = loader::zeRTASBuilderBuildExt; - } - } - if (version >= ZE_API_VERSION_1_13) { - if (loader::context->driverDDIPathDefault) { - pDdiTable->pfnCommandListAppendCopyExt = loader_driver_ddi::zeRTASBuilderCommandListAppendCopyExt; - } else { - pDdiTable->pfnCommandListAppendCopyExt = loader::zeRTASBuilderCommandListAppendCopyExt; - } - } - if (version >= ZE_API_VERSION_1_13) { - if (loader::context->driverDDIPathDefault) { - pDdiTable->pfnDestroyExt = loader_driver_ddi::zeRTASBuilderDestroyExt; - } else { - pDdiTable->pfnDestroyExt = loader::zeRTASBuilderDestroyExt; - } - } - zeGetRTASBuilderProcAddrTableLegacy(); - } - else - { - // return pointers directly to driver's DDIs - *pDdiTable = loader::context->zeDrivers.front().dditable.ze.RTASBuilder; - } - } - - // If the validation layer is enabled, then intercept the loader's DDIs - if(( ZE_RESULT_SUCCESS == result ) && ( nullptr != loader::context->validationLayer )) - { - auto getTable = reinterpret_cast( - GET_FUNCTION_PTR(loader::context->validationLayer, "zeGetRTASBuilderProcAddrTable") ); - if(!getTable) - return ZE_RESULT_ERROR_UNINITIALIZED; - result = getTable( version, pDdiTable ); - } - - // If the API tracing layer is enabled, then intercept the loader's DDIs - if(( ZE_RESULT_SUCCESS == result ) && ( nullptr != loader::context->tracingLayer )) - { - auto getTable = reinterpret_cast( - GET_FUNCTION_PTR(loader::context->tracingLayer, "zeGetRTASBuilderProcAddrTable") ); - if(!getTable) - return ZE_RESULT_ERROR_UNINITIALIZED; - ze_rtas_builder_dditable_t dditable; - memcpy(&dditable, pDdiTable, sizeof(ze_rtas_builder_dditable_t)); - result = getTable( version, &dditable ); - loader::context->tracing_dditable.ze.RTASBuilder = dditable; - if ( loader::context->tracingLayerEnabled ) { - result = getTable( version, pDdiTable ); - } - } - + if(driver->initStatus != ZE_RESULT_SUCCESS) + return driver->initStatus; + auto getTable = reinterpret_cast( + GET_FUNCTION_PTR( driver->handle, "zeGetRTASBuilderProcAddrTable") ); + if(!getTable) + return driver->initStatus; + auto getTableResult = getTable( loader::context->ddi_init_version, &driver->dditable.ze.RTASBuilder); + if(getTableResult == ZE_RESULT_SUCCESS) { + loader::context->configured_version = loader::context->ddi_init_version; + } else + driver->initStatus = getTableResult; return result; } - /////////////////////////////////////////////////////////////////////////////// /// @brief Exported function for filling application's RTASBuilderExp table /// with current process' addresses @@ -7859,38 +7820,898 @@ zeGetRTASBuilderProcAddrTable( /// - ::ZE_RESULT_ERROR_UNINITIALIZED /// - ::ZE_RESULT_ERROR_INVALID_NULL_POINTER /// - ::ZE_RESULT_ERROR_UNSUPPORTED_VERSION -ZE_DLLEXPORT ze_result_t ZE_APICALL -zeGetRTASBuilderExpProcAddrTable( - ze_api_version_t version, ///< [in] API version requested - ze_rtas_builder_exp_dditable_t* pDdiTable ///< [in,out] pointer to table of DDI function pointers - ) +__zedlllocal ze_result_t ZE_APICALL +zeGetRTASBuilderExpProcAddrTableFromDriver(loader::driver_t *driver) { - if( loader::context->zeDrivers.size() < 1 ) { - return ZE_RESULT_ERROR_UNINITIALIZED; - } - - if( nullptr == pDdiTable ) - return ZE_RESULT_ERROR_INVALID_NULL_POINTER; - - if( loader::context->version < version ) - return ZE_RESULT_ERROR_UNSUPPORTED_VERSION; - ze_result_t result = ZE_RESULT_SUCCESS; - - // Load the device-driver DDI tables - for( auto& drv : loader::context->zeDrivers ) - { - if(drv.initStatus != ZE_RESULT_SUCCESS) - continue; - auto getTable = reinterpret_cast( - GET_FUNCTION_PTR( drv.handle, "zeGetRTASBuilderExpProcAddrTable") ); - if(!getTable) - continue; - result = getTable( version, &drv.dditable.ze.RTASBuilderExp); - } - - - if( ZE_RESULT_SUCCESS == result ) + if(driver->initStatus != ZE_RESULT_SUCCESS) + return driver->initStatus; + auto getTable = reinterpret_cast( + GET_FUNCTION_PTR( driver->handle, "zeGetRTASBuilderExpProcAddrTable") ); + if(!getTable) + return driver->initStatus; + result = getTable( loader::context->ddi_init_version, &driver->dditable.ze.RTASBuilderExp); + return result; +} +/////////////////////////////////////////////////////////////////////////////// +/// @brief Exported function for filling application's RTASParallelOperation table +/// with current process' addresses +/// +/// @returns +/// - ::ZE_RESULT_SUCCESS +/// - ::ZE_RESULT_ERROR_UNINITIALIZED +/// - ::ZE_RESULT_ERROR_INVALID_NULL_POINTER +/// - ::ZE_RESULT_ERROR_UNSUPPORTED_VERSION +__zedlllocal ze_result_t ZE_APICALL +zeGetRTASParallelOperationProcAddrTableFromDriver(loader::driver_t *driver) +{ + ze_result_t result = ZE_RESULT_SUCCESS; + if(driver->initStatus != ZE_RESULT_SUCCESS) + return driver->initStatus; + auto getTable = reinterpret_cast( + GET_FUNCTION_PTR( driver->handle, "zeGetRTASParallelOperationProcAddrTable") ); + if(!getTable) + return driver->initStatus; + auto getTableResult = getTable( loader::context->ddi_init_version, &driver->dditable.ze.RTASParallelOperation); + if(getTableResult == ZE_RESULT_SUCCESS) { + loader::context->configured_version = loader::context->ddi_init_version; + } else + driver->initStatus = getTableResult; + return result; +} +/////////////////////////////////////////////////////////////////////////////// +/// @brief Exported function for filling application's RTASParallelOperationExp table +/// with current process' addresses +/// +/// @returns +/// - ::ZE_RESULT_SUCCESS +/// - ::ZE_RESULT_ERROR_UNINITIALIZED +/// - ::ZE_RESULT_ERROR_INVALID_NULL_POINTER +/// - ::ZE_RESULT_ERROR_UNSUPPORTED_VERSION +__zedlllocal ze_result_t ZE_APICALL +zeGetRTASParallelOperationExpProcAddrTableFromDriver(loader::driver_t *driver) +{ + ze_result_t result = ZE_RESULT_SUCCESS; + if(driver->initStatus != ZE_RESULT_SUCCESS) + return driver->initStatus; + auto getTable = reinterpret_cast( + GET_FUNCTION_PTR( driver->handle, "zeGetRTASParallelOperationExpProcAddrTable") ); + if(!getTable) + return driver->initStatus; + result = getTable( loader::context->ddi_init_version, &driver->dditable.ze.RTASParallelOperationExp); + return result; +} +/////////////////////////////////////////////////////////////////////////////// +/// @brief Exported function for filling application's Driver table +/// with current process' addresses +/// +/// @returns +/// - ::ZE_RESULT_SUCCESS +/// - ::ZE_RESULT_ERROR_UNINITIALIZED +/// - ::ZE_RESULT_ERROR_INVALID_NULL_POINTER +/// - ::ZE_RESULT_ERROR_UNSUPPORTED_VERSION +__zedlllocal ze_result_t ZE_APICALL +zeGetDriverProcAddrTableFromDriver(loader::driver_t *driver) +{ + ze_result_t result = ZE_RESULT_SUCCESS; + if(driver->initStatus != ZE_RESULT_SUCCESS) + return driver->initStatus; + auto getTable = reinterpret_cast( + GET_FUNCTION_PTR( driver->handle, "zeGetDriverProcAddrTable") ); + if(!getTable) + return driver->initStatus; + auto getTableResult = getTable( loader::context->ddi_init_version, &driver->dditable.ze.Driver); + if(getTableResult == ZE_RESULT_SUCCESS) { + loader::context->configured_version = loader::context->ddi_init_version; + } else + driver->initStatus = getTableResult; + return result; +} +/////////////////////////////////////////////////////////////////////////////// +/// @brief Exported function for filling application's DriverExp table +/// with current process' addresses +/// +/// @returns +/// - ::ZE_RESULT_SUCCESS +/// - ::ZE_RESULT_ERROR_UNINITIALIZED +/// - ::ZE_RESULT_ERROR_INVALID_NULL_POINTER +/// - ::ZE_RESULT_ERROR_UNSUPPORTED_VERSION +__zedlllocal ze_result_t ZE_APICALL +zeGetDriverExpProcAddrTableFromDriver(loader::driver_t *driver) +{ + ze_result_t result = ZE_RESULT_SUCCESS; + if(driver->initStatus != ZE_RESULT_SUCCESS) + return driver->initStatus; + auto getTable = reinterpret_cast( + GET_FUNCTION_PTR( driver->handle, "zeGetDriverExpProcAddrTable") ); + if(!getTable) + return driver->initStatus; + result = getTable( loader::context->ddi_init_version, &driver->dditable.ze.DriverExp); + return result; +} +/////////////////////////////////////////////////////////////////////////////// +/// @brief Exported function for filling application's Device table +/// with current process' addresses +/// +/// @returns +/// - ::ZE_RESULT_SUCCESS +/// - ::ZE_RESULT_ERROR_UNINITIALIZED +/// - ::ZE_RESULT_ERROR_INVALID_NULL_POINTER +/// - ::ZE_RESULT_ERROR_UNSUPPORTED_VERSION +__zedlllocal ze_result_t ZE_APICALL +zeGetDeviceProcAddrTableFromDriver(loader::driver_t *driver) +{ + ze_result_t result = ZE_RESULT_SUCCESS; + if(driver->initStatus != ZE_RESULT_SUCCESS) + return driver->initStatus; + auto getTable = reinterpret_cast( + GET_FUNCTION_PTR( driver->handle, "zeGetDeviceProcAddrTable") ); + if(!getTable) + return driver->initStatus; + auto getTableResult = getTable( loader::context->ddi_init_version, &driver->dditable.ze.Device); + if(getTableResult == ZE_RESULT_SUCCESS) { + loader::context->configured_version = loader::context->ddi_init_version; + } else + driver->initStatus = getTableResult; + return result; +} +/////////////////////////////////////////////////////////////////////////////// +/// @brief Exported function for filling application's DeviceExp table +/// with current process' addresses +/// +/// @returns +/// - ::ZE_RESULT_SUCCESS +/// - ::ZE_RESULT_ERROR_UNINITIALIZED +/// - ::ZE_RESULT_ERROR_INVALID_NULL_POINTER +/// - ::ZE_RESULT_ERROR_UNSUPPORTED_VERSION +__zedlllocal ze_result_t ZE_APICALL +zeGetDeviceExpProcAddrTableFromDriver(loader::driver_t *driver) +{ + ze_result_t result = ZE_RESULT_SUCCESS; + if(driver->initStatus != ZE_RESULT_SUCCESS) + return driver->initStatus; + auto getTable = reinterpret_cast( + GET_FUNCTION_PTR( driver->handle, "zeGetDeviceExpProcAddrTable") ); + if(!getTable) + return driver->initStatus; + result = getTable( loader::context->ddi_init_version, &driver->dditable.ze.DeviceExp); + return result; +} +/////////////////////////////////////////////////////////////////////////////// +/// @brief Exported function for filling application's Context table +/// with current process' addresses +/// +/// @returns +/// - ::ZE_RESULT_SUCCESS +/// - ::ZE_RESULT_ERROR_UNINITIALIZED +/// - ::ZE_RESULT_ERROR_INVALID_NULL_POINTER +/// - ::ZE_RESULT_ERROR_UNSUPPORTED_VERSION +__zedlllocal ze_result_t ZE_APICALL +zeGetContextProcAddrTableFromDriver(loader::driver_t *driver) +{ + ze_result_t result = ZE_RESULT_SUCCESS; + if(driver->initStatus != ZE_RESULT_SUCCESS) + return driver->initStatus; + auto getTable = reinterpret_cast( + GET_FUNCTION_PTR( driver->handle, "zeGetContextProcAddrTable") ); + if(!getTable) + return driver->initStatus; + auto getTableResult = getTable( loader::context->ddi_init_version, &driver->dditable.ze.Context); + if(getTableResult == ZE_RESULT_SUCCESS) { + loader::context->configured_version = loader::context->ddi_init_version; + } else + driver->initStatus = getTableResult; + return result; +} +/////////////////////////////////////////////////////////////////////////////// +/// @brief Exported function for filling application's CommandQueue table +/// with current process' addresses +/// +/// @returns +/// - ::ZE_RESULT_SUCCESS +/// - ::ZE_RESULT_ERROR_UNINITIALIZED +/// - ::ZE_RESULT_ERROR_INVALID_NULL_POINTER +/// - ::ZE_RESULT_ERROR_UNSUPPORTED_VERSION +__zedlllocal ze_result_t ZE_APICALL +zeGetCommandQueueProcAddrTableFromDriver(loader::driver_t *driver) +{ + ze_result_t result = ZE_RESULT_SUCCESS; + if(driver->initStatus != ZE_RESULT_SUCCESS) + return driver->initStatus; + auto getTable = reinterpret_cast( + GET_FUNCTION_PTR( driver->handle, "zeGetCommandQueueProcAddrTable") ); + if(!getTable) + return driver->initStatus; + auto getTableResult = getTable( loader::context->ddi_init_version, &driver->dditable.ze.CommandQueue); + if(getTableResult == ZE_RESULT_SUCCESS) { + loader::context->configured_version = loader::context->ddi_init_version; + } else + driver->initStatus = getTableResult; + return result; +} +/////////////////////////////////////////////////////////////////////////////// +/// @brief Exported function for filling application's CommandList table +/// with current process' addresses +/// +/// @returns +/// - ::ZE_RESULT_SUCCESS +/// - ::ZE_RESULT_ERROR_UNINITIALIZED +/// - ::ZE_RESULT_ERROR_INVALID_NULL_POINTER +/// - ::ZE_RESULT_ERROR_UNSUPPORTED_VERSION +__zedlllocal ze_result_t ZE_APICALL +zeGetCommandListProcAddrTableFromDriver(loader::driver_t *driver) +{ + ze_result_t result = ZE_RESULT_SUCCESS; + if(driver->initStatus != ZE_RESULT_SUCCESS) + return driver->initStatus; + auto getTable = reinterpret_cast( + GET_FUNCTION_PTR( driver->handle, "zeGetCommandListProcAddrTable") ); + if(!getTable) + return driver->initStatus; + auto getTableResult = getTable( loader::context->ddi_init_version, &driver->dditable.ze.CommandList); + if(getTableResult == ZE_RESULT_SUCCESS) { + loader::context->configured_version = loader::context->ddi_init_version; + } else + driver->initStatus = getTableResult; + return result; +} +/////////////////////////////////////////////////////////////////////////////// +/// @brief Exported function for filling application's CommandListExp table +/// with current process' addresses +/// +/// @returns +/// - ::ZE_RESULT_SUCCESS +/// - ::ZE_RESULT_ERROR_UNINITIALIZED +/// - ::ZE_RESULT_ERROR_INVALID_NULL_POINTER +/// - ::ZE_RESULT_ERROR_UNSUPPORTED_VERSION +__zedlllocal ze_result_t ZE_APICALL +zeGetCommandListExpProcAddrTableFromDriver(loader::driver_t *driver) +{ + ze_result_t result = ZE_RESULT_SUCCESS; + if(driver->initStatus != ZE_RESULT_SUCCESS) + return driver->initStatus; + auto getTable = reinterpret_cast( + GET_FUNCTION_PTR( driver->handle, "zeGetCommandListExpProcAddrTable") ); + if(!getTable) + return driver->initStatus; + result = getTable( loader::context->ddi_init_version, &driver->dditable.ze.CommandListExp); + return result; +} +/////////////////////////////////////////////////////////////////////////////// +/// @brief Exported function for filling application's Event table +/// with current process' addresses +/// +/// @returns +/// - ::ZE_RESULT_SUCCESS +/// - ::ZE_RESULT_ERROR_UNINITIALIZED +/// - ::ZE_RESULT_ERROR_INVALID_NULL_POINTER +/// - ::ZE_RESULT_ERROR_UNSUPPORTED_VERSION +__zedlllocal ze_result_t ZE_APICALL +zeGetEventProcAddrTableFromDriver(loader::driver_t *driver) +{ + ze_result_t result = ZE_RESULT_SUCCESS; + if(driver->initStatus != ZE_RESULT_SUCCESS) + return driver->initStatus; + auto getTable = reinterpret_cast( + GET_FUNCTION_PTR( driver->handle, "zeGetEventProcAddrTable") ); + if(!getTable) + return driver->initStatus; + auto getTableResult = getTable( loader::context->ddi_init_version, &driver->dditable.ze.Event); + if(getTableResult == ZE_RESULT_SUCCESS) { + loader::context->configured_version = loader::context->ddi_init_version; + } else + driver->initStatus = getTableResult; + return result; +} +/////////////////////////////////////////////////////////////////////////////// +/// @brief Exported function for filling application's EventExp table +/// with current process' addresses +/// +/// @returns +/// - ::ZE_RESULT_SUCCESS +/// - ::ZE_RESULT_ERROR_UNINITIALIZED +/// - ::ZE_RESULT_ERROR_INVALID_NULL_POINTER +/// - ::ZE_RESULT_ERROR_UNSUPPORTED_VERSION +__zedlllocal ze_result_t ZE_APICALL +zeGetEventExpProcAddrTableFromDriver(loader::driver_t *driver) +{ + ze_result_t result = ZE_RESULT_SUCCESS; + if(driver->initStatus != ZE_RESULT_SUCCESS) + return driver->initStatus; + auto getTable = reinterpret_cast( + GET_FUNCTION_PTR( driver->handle, "zeGetEventExpProcAddrTable") ); + if(!getTable) + return driver->initStatus; + result = getTable( loader::context->ddi_init_version, &driver->dditable.ze.EventExp); + return result; +} +/////////////////////////////////////////////////////////////////////////////// +/// @brief Exported function for filling application's EventPool table +/// with current process' addresses +/// +/// @returns +/// - ::ZE_RESULT_SUCCESS +/// - ::ZE_RESULT_ERROR_UNINITIALIZED +/// - ::ZE_RESULT_ERROR_INVALID_NULL_POINTER +/// - ::ZE_RESULT_ERROR_UNSUPPORTED_VERSION +__zedlllocal ze_result_t ZE_APICALL +zeGetEventPoolProcAddrTableFromDriver(loader::driver_t *driver) +{ + ze_result_t result = ZE_RESULT_SUCCESS; + if(driver->initStatus != ZE_RESULT_SUCCESS) + return driver->initStatus; + auto getTable = reinterpret_cast( + GET_FUNCTION_PTR( driver->handle, "zeGetEventPoolProcAddrTable") ); + if(!getTable) + return driver->initStatus; + auto getTableResult = getTable( loader::context->ddi_init_version, &driver->dditable.ze.EventPool); + if(getTableResult == ZE_RESULT_SUCCESS) { + loader::context->configured_version = loader::context->ddi_init_version; + } else + driver->initStatus = getTableResult; + return result; +} +/////////////////////////////////////////////////////////////////////////////// +/// @brief Exported function for filling application's Fence table +/// with current process' addresses +/// +/// @returns +/// - ::ZE_RESULT_SUCCESS +/// - ::ZE_RESULT_ERROR_UNINITIALIZED +/// - ::ZE_RESULT_ERROR_INVALID_NULL_POINTER +/// - ::ZE_RESULT_ERROR_UNSUPPORTED_VERSION +__zedlllocal ze_result_t ZE_APICALL +zeGetFenceProcAddrTableFromDriver(loader::driver_t *driver) +{ + ze_result_t result = ZE_RESULT_SUCCESS; + if(driver->initStatus != ZE_RESULT_SUCCESS) + return driver->initStatus; + auto getTable = reinterpret_cast( + GET_FUNCTION_PTR( driver->handle, "zeGetFenceProcAddrTable") ); + if(!getTable) + return driver->initStatus; + auto getTableResult = getTable( loader::context->ddi_init_version, &driver->dditable.ze.Fence); + if(getTableResult == ZE_RESULT_SUCCESS) { + loader::context->configured_version = loader::context->ddi_init_version; + } else + driver->initStatus = getTableResult; + return result; +} +/////////////////////////////////////////////////////////////////////////////// +/// @brief Exported function for filling application's Image table +/// with current process' addresses +/// +/// @returns +/// - ::ZE_RESULT_SUCCESS +/// - ::ZE_RESULT_ERROR_UNINITIALIZED +/// - ::ZE_RESULT_ERROR_INVALID_NULL_POINTER +/// - ::ZE_RESULT_ERROR_UNSUPPORTED_VERSION +__zedlllocal ze_result_t ZE_APICALL +zeGetImageProcAddrTableFromDriver(loader::driver_t *driver) +{ + ze_result_t result = ZE_RESULT_SUCCESS; + if(driver->initStatus != ZE_RESULT_SUCCESS) + return driver->initStatus; + auto getTable = reinterpret_cast( + GET_FUNCTION_PTR( driver->handle, "zeGetImageProcAddrTable") ); + if(!getTable) + return driver->initStatus; + auto getTableResult = getTable( loader::context->ddi_init_version, &driver->dditable.ze.Image); + if(getTableResult == ZE_RESULT_SUCCESS) { + loader::context->configured_version = loader::context->ddi_init_version; + } else + driver->initStatus = getTableResult; + return result; +} +/////////////////////////////////////////////////////////////////////////////// +/// @brief Exported function for filling application's ImageExp table +/// with current process' addresses +/// +/// @returns +/// - ::ZE_RESULT_SUCCESS +/// - ::ZE_RESULT_ERROR_UNINITIALIZED +/// - ::ZE_RESULT_ERROR_INVALID_NULL_POINTER +/// - ::ZE_RESULT_ERROR_UNSUPPORTED_VERSION +__zedlllocal ze_result_t ZE_APICALL +zeGetImageExpProcAddrTableFromDriver(loader::driver_t *driver) +{ + ze_result_t result = ZE_RESULT_SUCCESS; + if(driver->initStatus != ZE_RESULT_SUCCESS) + return driver->initStatus; + auto getTable = reinterpret_cast( + GET_FUNCTION_PTR( driver->handle, "zeGetImageExpProcAddrTable") ); + if(!getTable) + return driver->initStatus; + result = getTable( loader::context->ddi_init_version, &driver->dditable.ze.ImageExp); + return result; +} +/////////////////////////////////////////////////////////////////////////////// +/// @brief Exported function for filling application's Kernel table +/// with current process' addresses +/// +/// @returns +/// - ::ZE_RESULT_SUCCESS +/// - ::ZE_RESULT_ERROR_UNINITIALIZED +/// - ::ZE_RESULT_ERROR_INVALID_NULL_POINTER +/// - ::ZE_RESULT_ERROR_UNSUPPORTED_VERSION +__zedlllocal ze_result_t ZE_APICALL +zeGetKernelProcAddrTableFromDriver(loader::driver_t *driver) +{ + ze_result_t result = ZE_RESULT_SUCCESS; + if(driver->initStatus != ZE_RESULT_SUCCESS) + return driver->initStatus; + auto getTable = reinterpret_cast( + GET_FUNCTION_PTR( driver->handle, "zeGetKernelProcAddrTable") ); + if(!getTable) + return driver->initStatus; + auto getTableResult = getTable( loader::context->ddi_init_version, &driver->dditable.ze.Kernel); + if(getTableResult == ZE_RESULT_SUCCESS) { + loader::context->configured_version = loader::context->ddi_init_version; + } else + driver->initStatus = getTableResult; + return result; +} +/////////////////////////////////////////////////////////////////////////////// +/// @brief Exported function for filling application's KernelExp table +/// with current process' addresses +/// +/// @returns +/// - ::ZE_RESULT_SUCCESS +/// - ::ZE_RESULT_ERROR_UNINITIALIZED +/// - ::ZE_RESULT_ERROR_INVALID_NULL_POINTER +/// - ::ZE_RESULT_ERROR_UNSUPPORTED_VERSION +__zedlllocal ze_result_t ZE_APICALL +zeGetKernelExpProcAddrTableFromDriver(loader::driver_t *driver) +{ + ze_result_t result = ZE_RESULT_SUCCESS; + if(driver->initStatus != ZE_RESULT_SUCCESS) + return driver->initStatus; + auto getTable = reinterpret_cast( + GET_FUNCTION_PTR( driver->handle, "zeGetKernelExpProcAddrTable") ); + if(!getTable) + return driver->initStatus; + result = getTable( loader::context->ddi_init_version, &driver->dditable.ze.KernelExp); + return result; +} +/////////////////////////////////////////////////////////////////////////////// +/// @brief Exported function for filling application's Mem table +/// with current process' addresses +/// +/// @returns +/// - ::ZE_RESULT_SUCCESS +/// - ::ZE_RESULT_ERROR_UNINITIALIZED +/// - ::ZE_RESULT_ERROR_INVALID_NULL_POINTER +/// - ::ZE_RESULT_ERROR_UNSUPPORTED_VERSION +__zedlllocal ze_result_t ZE_APICALL +zeGetMemProcAddrTableFromDriver(loader::driver_t *driver) +{ + ze_result_t result = ZE_RESULT_SUCCESS; + if(driver->initStatus != ZE_RESULT_SUCCESS) + return driver->initStatus; + auto getTable = reinterpret_cast( + GET_FUNCTION_PTR( driver->handle, "zeGetMemProcAddrTable") ); + if(!getTable) + return driver->initStatus; + auto getTableResult = getTable( loader::context->ddi_init_version, &driver->dditable.ze.Mem); + if(getTableResult == ZE_RESULT_SUCCESS) { + loader::context->configured_version = loader::context->ddi_init_version; + } else + driver->initStatus = getTableResult; + return result; +} +/////////////////////////////////////////////////////////////////////////////// +/// @brief Exported function for filling application's MemExp table +/// with current process' addresses +/// +/// @returns +/// - ::ZE_RESULT_SUCCESS +/// - ::ZE_RESULT_ERROR_UNINITIALIZED +/// - ::ZE_RESULT_ERROR_INVALID_NULL_POINTER +/// - ::ZE_RESULT_ERROR_UNSUPPORTED_VERSION +__zedlllocal ze_result_t ZE_APICALL +zeGetMemExpProcAddrTableFromDriver(loader::driver_t *driver) +{ + ze_result_t result = ZE_RESULT_SUCCESS; + if(driver->initStatus != ZE_RESULT_SUCCESS) + return driver->initStatus; + auto getTable = reinterpret_cast( + GET_FUNCTION_PTR( driver->handle, "zeGetMemExpProcAddrTable") ); + if(!getTable) + return driver->initStatus; + result = getTable( loader::context->ddi_init_version, &driver->dditable.ze.MemExp); + return result; +} +/////////////////////////////////////////////////////////////////////////////// +/// @brief Exported function for filling application's Module table +/// with current process' addresses +/// +/// @returns +/// - ::ZE_RESULT_SUCCESS +/// - ::ZE_RESULT_ERROR_UNINITIALIZED +/// - ::ZE_RESULT_ERROR_INVALID_NULL_POINTER +/// - ::ZE_RESULT_ERROR_UNSUPPORTED_VERSION +__zedlllocal ze_result_t ZE_APICALL +zeGetModuleProcAddrTableFromDriver(loader::driver_t *driver) +{ + ze_result_t result = ZE_RESULT_SUCCESS; + if(driver->initStatus != ZE_RESULT_SUCCESS) + return driver->initStatus; + auto getTable = reinterpret_cast( + GET_FUNCTION_PTR( driver->handle, "zeGetModuleProcAddrTable") ); + if(!getTable) + return driver->initStatus; + auto getTableResult = getTable( loader::context->ddi_init_version, &driver->dditable.ze.Module); + if(getTableResult == ZE_RESULT_SUCCESS) { + loader::context->configured_version = loader::context->ddi_init_version; + } else + driver->initStatus = getTableResult; + return result; +} +/////////////////////////////////////////////////////////////////////////////// +/// @brief Exported function for filling application's ModuleBuildLog table +/// with current process' addresses +/// +/// @returns +/// - ::ZE_RESULT_SUCCESS +/// - ::ZE_RESULT_ERROR_UNINITIALIZED +/// - ::ZE_RESULT_ERROR_INVALID_NULL_POINTER +/// - ::ZE_RESULT_ERROR_UNSUPPORTED_VERSION +__zedlllocal ze_result_t ZE_APICALL +zeGetModuleBuildLogProcAddrTableFromDriver(loader::driver_t *driver) +{ + ze_result_t result = ZE_RESULT_SUCCESS; + if(driver->initStatus != ZE_RESULT_SUCCESS) + return driver->initStatus; + auto getTable = reinterpret_cast( + GET_FUNCTION_PTR( driver->handle, "zeGetModuleBuildLogProcAddrTable") ); + if(!getTable) + return driver->initStatus; + auto getTableResult = getTable( loader::context->ddi_init_version, &driver->dditable.ze.ModuleBuildLog); + if(getTableResult == ZE_RESULT_SUCCESS) { + loader::context->configured_version = loader::context->ddi_init_version; + } else + driver->initStatus = getTableResult; + return result; +} +/////////////////////////////////////////////////////////////////////////////// +/// @brief Exported function for filling application's PhysicalMem table +/// with current process' addresses +/// +/// @returns +/// - ::ZE_RESULT_SUCCESS +/// - ::ZE_RESULT_ERROR_UNINITIALIZED +/// - ::ZE_RESULT_ERROR_INVALID_NULL_POINTER +/// - ::ZE_RESULT_ERROR_UNSUPPORTED_VERSION +__zedlllocal ze_result_t ZE_APICALL +zeGetPhysicalMemProcAddrTableFromDriver(loader::driver_t *driver) +{ + ze_result_t result = ZE_RESULT_SUCCESS; + if(driver->initStatus != ZE_RESULT_SUCCESS) + return driver->initStatus; + auto getTable = reinterpret_cast( + GET_FUNCTION_PTR( driver->handle, "zeGetPhysicalMemProcAddrTable") ); + if(!getTable) + return driver->initStatus; + auto getTableResult = getTable( loader::context->ddi_init_version, &driver->dditable.ze.PhysicalMem); + if(getTableResult == ZE_RESULT_SUCCESS) { + loader::context->configured_version = loader::context->ddi_init_version; + } else + driver->initStatus = getTableResult; + return result; +} +/////////////////////////////////////////////////////////////////////////////// +/// @brief Exported function for filling application's Sampler table +/// with current process' addresses +/// +/// @returns +/// - ::ZE_RESULT_SUCCESS +/// - ::ZE_RESULT_ERROR_UNINITIALIZED +/// - ::ZE_RESULT_ERROR_INVALID_NULL_POINTER +/// - ::ZE_RESULT_ERROR_UNSUPPORTED_VERSION +__zedlllocal ze_result_t ZE_APICALL +zeGetSamplerProcAddrTableFromDriver(loader::driver_t *driver) +{ + ze_result_t result = ZE_RESULT_SUCCESS; + if(driver->initStatus != ZE_RESULT_SUCCESS) + return driver->initStatus; + auto getTable = reinterpret_cast( + GET_FUNCTION_PTR( driver->handle, "zeGetSamplerProcAddrTable") ); + if(!getTable) + return driver->initStatus; + auto getTableResult = getTable( loader::context->ddi_init_version, &driver->dditable.ze.Sampler); + if(getTableResult == ZE_RESULT_SUCCESS) { + loader::context->configured_version = loader::context->ddi_init_version; + } else + driver->initStatus = getTableResult; + return result; +} +/////////////////////////////////////////////////////////////////////////////// +/// @brief Exported function for filling application's VirtualMem table +/// with current process' addresses +/// +/// @returns +/// - ::ZE_RESULT_SUCCESS +/// - ::ZE_RESULT_ERROR_UNINITIALIZED +/// - ::ZE_RESULT_ERROR_INVALID_NULL_POINTER +/// - ::ZE_RESULT_ERROR_UNSUPPORTED_VERSION +__zedlllocal ze_result_t ZE_APICALL +zeGetVirtualMemProcAddrTableFromDriver(loader::driver_t *driver) +{ + ze_result_t result = ZE_RESULT_SUCCESS; + if(driver->initStatus != ZE_RESULT_SUCCESS) + return driver->initStatus; + auto getTable = reinterpret_cast( + GET_FUNCTION_PTR( driver->handle, "zeGetVirtualMemProcAddrTable") ); + if(!getTable) + return driver->initStatus; + auto getTableResult = getTable( loader::context->ddi_init_version, &driver->dditable.ze.VirtualMem); + if(getTableResult == ZE_RESULT_SUCCESS) { + loader::context->configured_version = loader::context->ddi_init_version; + } else + driver->initStatus = getTableResult; + return result; +} +/////////////////////////////////////////////////////////////////////////////// +/// @brief Exported function for filling application's FabricEdgeExp table +/// with current process' addresses +/// +/// @returns +/// - ::ZE_RESULT_SUCCESS +/// - ::ZE_RESULT_ERROR_UNINITIALIZED +/// - ::ZE_RESULT_ERROR_INVALID_NULL_POINTER +/// - ::ZE_RESULT_ERROR_UNSUPPORTED_VERSION +__zedlllocal ze_result_t ZE_APICALL +zeGetFabricEdgeExpProcAddrTableFromDriver(loader::driver_t *driver) +{ + ze_result_t result = ZE_RESULT_SUCCESS; + if(driver->initStatus != ZE_RESULT_SUCCESS) + return driver->initStatus; + auto getTable = reinterpret_cast( + GET_FUNCTION_PTR( driver->handle, "zeGetFabricEdgeExpProcAddrTable") ); + if(!getTable) + return driver->initStatus; + result = getTable( loader::context->ddi_init_version, &driver->dditable.ze.FabricEdgeExp); + return result; +} +/////////////////////////////////////////////////////////////////////////////// +/// @brief Exported function for filling application's FabricVertexExp table +/// with current process' addresses +/// +/// @returns +/// - ::ZE_RESULT_SUCCESS +/// - ::ZE_RESULT_ERROR_UNINITIALIZED +/// - ::ZE_RESULT_ERROR_INVALID_NULL_POINTER +/// - ::ZE_RESULT_ERROR_UNSUPPORTED_VERSION +__zedlllocal ze_result_t ZE_APICALL +zeGetFabricVertexExpProcAddrTableFromDriver(loader::driver_t *driver) +{ + ze_result_t result = ZE_RESULT_SUCCESS; + if(driver->initStatus != ZE_RESULT_SUCCESS) + return driver->initStatus; + auto getTable = reinterpret_cast( + GET_FUNCTION_PTR( driver->handle, "zeGetFabricVertexExpProcAddrTable") ); + if(!getTable) + return driver->initStatus; + result = getTable( loader::context->ddi_init_version, &driver->dditable.ze.FabricVertexExp); + return result; +} +/////////////////////////////////////////////////////////////////////////////// +/// @brief Exported function for filling application's Global table +/// with current process' addresses +/// +/// @returns +/// - ::ZE_RESULT_SUCCESS +/// - ::ZE_RESULT_ERROR_UNINITIALIZED +/// - ::ZE_RESULT_ERROR_INVALID_NULL_POINTER +/// - ::ZE_RESULT_ERROR_UNSUPPORTED_VERSION +ZE_DLLEXPORT ze_result_t ZE_APICALL +zeGetGlobalProcAddrTable( + ze_api_version_t version, ///< [in] API version requested + ze_global_dditable_t* pDdiTable ///< [in,out] pointer to table of DDI function pointers + ) +{ + if( loader::context->zeDrivers.size() < 1 ) { + return ZE_RESULT_ERROR_UNINITIALIZED; + } + + if( nullptr == pDdiTable ) + return ZE_RESULT_ERROR_INVALID_NULL_POINTER; + + if( loader::context->version < version ) + return ZE_RESULT_ERROR_UNSUPPORTED_VERSION; + + loader::context->ddi_init_version = version; + + ze_result_t result = ZE_RESULT_SUCCESS; + + if( ZE_RESULT_SUCCESS == result ) + { + if( true ) + { + // return pointers to loader's DDIs + loader::loaderDispatch->pCore->Global = new ze_global_dditable_t; + if (version >= ZE_API_VERSION_1_0) { + pDdiTable->pfnInit = loader::zeInit; + } + if (version >= ZE_API_VERSION_1_10) { + pDdiTable->pfnInitDrivers = loader::zeInitDrivers; + } + zeGetGlobalProcAddrTableLegacy(); + } + else + { + // return pointers directly to driver's DDIs + *pDdiTable = loader::context->zeDrivers.front().dditable.ze.Global; + } + } + + // If the validation layer is enabled, then intercept the loader's DDIs + if(( ZE_RESULT_SUCCESS == result ) && ( nullptr != loader::context->validationLayer )) + { + auto getTable = reinterpret_cast( + GET_FUNCTION_PTR(loader::context->validationLayer, "zeGetGlobalProcAddrTable") ); + if(!getTable) + return ZE_RESULT_ERROR_UNINITIALIZED; + result = getTable( version, pDdiTable ); + } + + // If the API tracing layer is enabled, then intercept the loader's DDIs + if(( ZE_RESULT_SUCCESS == result ) && ( nullptr != loader::context->tracingLayer )) + { + auto getTable = reinterpret_cast( + GET_FUNCTION_PTR(loader::context->tracingLayer, "zeGetGlobalProcAddrTable") ); + if(!getTable) + return ZE_RESULT_ERROR_UNINITIALIZED; + ze_global_dditable_t dditable; + memcpy(&dditable, pDdiTable, sizeof(ze_global_dditable_t)); + result = getTable( version, &dditable ); + loader::context->tracing_dditable.ze.Global = dditable; + if ( loader::context->tracingLayerEnabled ) { + result = getTable( version, pDdiTable ); + } + } + + return result; +} + +/////////////////////////////////////////////////////////////////////////////// +/// @brief Exported function for filling application's RTASBuilder table +/// with current process' addresses +/// +/// @returns +/// - ::ZE_RESULT_SUCCESS +/// - ::ZE_RESULT_ERROR_UNINITIALIZED +/// - ::ZE_RESULT_ERROR_INVALID_NULL_POINTER +/// - ::ZE_RESULT_ERROR_UNSUPPORTED_VERSION +ZE_DLLEXPORT ze_result_t ZE_APICALL +zeGetRTASBuilderProcAddrTable( + ze_api_version_t version, ///< [in] API version requested + ze_rtas_builder_dditable_t* pDdiTable ///< [in,out] pointer to table of DDI function pointers + ) +{ + if( loader::context->zeDrivers.size() < 1 ) { + return ZE_RESULT_ERROR_UNINITIALIZED; + } + + if( nullptr == pDdiTable ) + return ZE_RESULT_ERROR_INVALID_NULL_POINTER; + + if( loader::context->version < version ) + return ZE_RESULT_ERROR_UNSUPPORTED_VERSION; + + loader::context->ddi_init_version = version; + + ze_result_t result = ZE_RESULT_SUCCESS; + + if( ZE_RESULT_SUCCESS == result ) + { + if( ( loader::context->zeDrivers.size() > 1 ) || loader::context->forceIntercept ) + { + // return pointers to loader's DDIs + loader::loaderDispatch->pCore->RTASBuilder = new ze_rtas_builder_dditable_t; + if (version >= ZE_API_VERSION_1_13) { + if (loader::context->driverDDIPathDefault) { + pDdiTable->pfnCreateExt = loader_driver_ddi::zeRTASBuilderCreateExt; + } else { + pDdiTable->pfnCreateExt = loader::zeRTASBuilderCreateExt; + } + } + if (version >= ZE_API_VERSION_1_13) { + if (loader::context->driverDDIPathDefault) { + pDdiTable->pfnGetBuildPropertiesExt = loader_driver_ddi::zeRTASBuilderGetBuildPropertiesExt; + } else { + pDdiTable->pfnGetBuildPropertiesExt = loader::zeRTASBuilderGetBuildPropertiesExt; + } + } + if (version >= ZE_API_VERSION_1_13) { + if (loader::context->driverDDIPathDefault) { + pDdiTable->pfnBuildExt = loader_driver_ddi::zeRTASBuilderBuildExt; + } else { + pDdiTable->pfnBuildExt = loader::zeRTASBuilderBuildExt; + } + } + if (version >= ZE_API_VERSION_1_13) { + if (loader::context->driverDDIPathDefault) { + pDdiTable->pfnCommandListAppendCopyExt = loader_driver_ddi::zeRTASBuilderCommandListAppendCopyExt; + } else { + pDdiTable->pfnCommandListAppendCopyExt = loader::zeRTASBuilderCommandListAppendCopyExt; + } + } + if (version >= ZE_API_VERSION_1_13) { + if (loader::context->driverDDIPathDefault) { + pDdiTable->pfnDestroyExt = loader_driver_ddi::zeRTASBuilderDestroyExt; + } else { + pDdiTable->pfnDestroyExt = loader::zeRTASBuilderDestroyExt; + } + } + zeGetRTASBuilderProcAddrTableLegacy(); + } + else + { + // return pointers directly to driver's DDIs + *pDdiTable = loader::context->zeDrivers.front().dditable.ze.RTASBuilder; + } + } + + // If the validation layer is enabled, then intercept the loader's DDIs + if(( ZE_RESULT_SUCCESS == result ) && ( nullptr != loader::context->validationLayer )) + { + auto getTable = reinterpret_cast( + GET_FUNCTION_PTR(loader::context->validationLayer, "zeGetRTASBuilderProcAddrTable") ); + if(!getTable) + return ZE_RESULT_ERROR_UNINITIALIZED; + result = getTable( version, pDdiTable ); + } + + // If the API tracing layer is enabled, then intercept the loader's DDIs + if(( ZE_RESULT_SUCCESS == result ) && ( nullptr != loader::context->tracingLayer )) + { + auto getTable = reinterpret_cast( + GET_FUNCTION_PTR(loader::context->tracingLayer, "zeGetRTASBuilderProcAddrTable") ); + if(!getTable) + return ZE_RESULT_ERROR_UNINITIALIZED; + ze_rtas_builder_dditable_t dditable; + memcpy(&dditable, pDdiTable, sizeof(ze_rtas_builder_dditable_t)); + result = getTable( version, &dditable ); + loader::context->tracing_dditable.ze.RTASBuilder = dditable; + if ( loader::context->tracingLayerEnabled ) { + result = getTable( version, pDdiTable ); + } + } + + return result; +} + +/////////////////////////////////////////////////////////////////////////////// +/// @brief Exported function for filling application's RTASBuilderExp table +/// with current process' addresses +/// +/// @returns +/// - ::ZE_RESULT_SUCCESS +/// - ::ZE_RESULT_ERROR_UNINITIALIZED +/// - ::ZE_RESULT_ERROR_INVALID_NULL_POINTER +/// - ::ZE_RESULT_ERROR_UNSUPPORTED_VERSION +ZE_DLLEXPORT ze_result_t ZE_APICALL +zeGetRTASBuilderExpProcAddrTable( + ze_api_version_t version, ///< [in] API version requested + ze_rtas_builder_exp_dditable_t* pDdiTable ///< [in,out] pointer to table of DDI function pointers + ) +{ + if( loader::context->zeDrivers.size() < 1 ) { + return ZE_RESULT_ERROR_UNINITIALIZED; + } + + if( nullptr == pDdiTable ) + return ZE_RESULT_ERROR_INVALID_NULL_POINTER; + + if( loader::context->version < version ) + return ZE_RESULT_ERROR_UNSUPPORTED_VERSION; + + loader::context->ddi_init_version = version; + + ze_result_t result = ZE_RESULT_SUCCESS; + + if( ZE_RESULT_SUCCESS == result ) { if( ( loader::context->zeDrivers.size() > 1 ) || loader::context->forceIntercept ) { @@ -7987,30 +8808,9 @@ zeGetRTASParallelOperationProcAddrTable( if( loader::context->version < version ) return ZE_RESULT_ERROR_UNSUPPORTED_VERSION; - ze_result_t result = ZE_RESULT_SUCCESS; + loader::context->ddi_init_version = version; - bool atLeastOneDriverValid = false; - // Load the device-driver DDI tables - for( auto& drv : loader::context->zeDrivers ) - { - if(drv.initStatus != ZE_RESULT_SUCCESS) - continue; - auto getTable = reinterpret_cast( - GET_FUNCTION_PTR( drv.handle, "zeGetRTASParallelOperationProcAddrTable") ); - if(!getTable) - continue; - auto getTableResult = getTable( version, &drv.dditable.ze.RTASParallelOperation); - if(getTableResult == ZE_RESULT_SUCCESS) { - atLeastOneDriverValid = true; - loader::context->configured_version = version; - } else - drv.initStatus = getTableResult; - } - - if(!atLeastOneDriverValid) - result = ZE_RESULT_ERROR_UNINITIALIZED; - else - result = ZE_RESULT_SUCCESS; + ze_result_t result = ZE_RESULT_SUCCESS; if( ZE_RESULT_SUCCESS == result ) { @@ -8109,20 +8909,9 @@ zeGetRTASParallelOperationExpProcAddrTable( if( loader::context->version < version ) return ZE_RESULT_ERROR_UNSUPPORTED_VERSION; - ze_result_t result = ZE_RESULT_SUCCESS; - - // Load the device-driver DDI tables - for( auto& drv : loader::context->zeDrivers ) - { - if(drv.initStatus != ZE_RESULT_SUCCESS) - continue; - auto getTable = reinterpret_cast( - GET_FUNCTION_PTR( drv.handle, "zeGetRTASParallelOperationExpProcAddrTable") ); - if(!getTable) - continue; - result = getTable( version, &drv.dditable.ze.RTASParallelOperationExp); - } + loader::context->ddi_init_version = version; + ze_result_t result = ZE_RESULT_SUCCESS; if( ZE_RESULT_SUCCESS == result ) { @@ -8221,30 +9010,9 @@ zeGetDriverProcAddrTable( if( loader::context->version < version ) return ZE_RESULT_ERROR_UNSUPPORTED_VERSION; - ze_result_t result = ZE_RESULT_SUCCESS; + loader::context->ddi_init_version = version; - bool atLeastOneDriverValid = false; - // Load the device-driver DDI tables - for( auto& drv : loader::context->zeDrivers ) - { - if(drv.initStatus != ZE_RESULT_SUCCESS) - continue; - auto getTable = reinterpret_cast( - GET_FUNCTION_PTR( drv.handle, "zeGetDriverProcAddrTable") ); - if(!getTable) - continue; - auto getTableResult = getTable( version, &drv.dditable.ze.Driver); - if(getTableResult == ZE_RESULT_SUCCESS) { - atLeastOneDriverValid = true; - loader::context->configured_version = version; - } else - drv.initStatus = getTableResult; - } - - if(!atLeastOneDriverValid) - result = ZE_RESULT_ERROR_UNINITIALIZED; - else - result = ZE_RESULT_SUCCESS; + ze_result_t result = ZE_RESULT_SUCCESS; if( ZE_RESULT_SUCCESS == result ) { @@ -8374,20 +9142,9 @@ zeGetDriverExpProcAddrTable( if( loader::context->version < version ) return ZE_RESULT_ERROR_UNSUPPORTED_VERSION; - ze_result_t result = ZE_RESULT_SUCCESS; - - // Load the device-driver DDI tables - for( auto& drv : loader::context->zeDrivers ) - { - if(drv.initStatus != ZE_RESULT_SUCCESS) - continue; - auto getTable = reinterpret_cast( - GET_FUNCTION_PTR( drv.handle, "zeGetDriverExpProcAddrTable") ); - if(!getTable) - continue; - result = getTable( version, &drv.dditable.ze.DriverExp); - } + loader::context->ddi_init_version = version; + ze_result_t result = ZE_RESULT_SUCCESS; if( ZE_RESULT_SUCCESS == result ) { @@ -8465,30 +9222,9 @@ zeGetDeviceProcAddrTable( if( loader::context->version < version ) return ZE_RESULT_ERROR_UNSUPPORTED_VERSION; - ze_result_t result = ZE_RESULT_SUCCESS; + loader::context->ddi_init_version = version; - bool atLeastOneDriverValid = false; - // Load the device-driver DDI tables - for( auto& drv : loader::context->zeDrivers ) - { - if(drv.initStatus != ZE_RESULT_SUCCESS) - continue; - auto getTable = reinterpret_cast( - GET_FUNCTION_PTR( drv.handle, "zeGetDeviceProcAddrTable") ); - if(!getTable) - continue; - auto getTableResult = getTable( version, &drv.dditable.ze.Device); - if(getTableResult == ZE_RESULT_SUCCESS) { - atLeastOneDriverValid = true; - loader::context->configured_version = version; - } else - drv.initStatus = getTableResult; - } - - if(!atLeastOneDriverValid) - result = ZE_RESULT_ERROR_UNINITIALIZED; - else - result = ZE_RESULT_SUCCESS; + ze_result_t result = ZE_RESULT_SUCCESS; if( ZE_RESULT_SUCCESS == result ) { @@ -8720,20 +9456,9 @@ zeGetDeviceExpProcAddrTable( if( loader::context->version < version ) return ZE_RESULT_ERROR_UNSUPPORTED_VERSION; - ze_result_t result = ZE_RESULT_SUCCESS; - - // Load the device-driver DDI tables - for( auto& drv : loader::context->zeDrivers ) - { - if(drv.initStatus != ZE_RESULT_SUCCESS) - continue; - auto getTable = reinterpret_cast( - GET_FUNCTION_PTR( drv.handle, "zeGetDeviceExpProcAddrTable") ); - if(!getTable) - continue; - result = getTable( version, &drv.dditable.ze.DeviceExp); - } + loader::context->ddi_init_version = version; + ze_result_t result = ZE_RESULT_SUCCESS; if( ZE_RESULT_SUCCESS == result ) { @@ -8811,30 +9536,9 @@ zeGetContextProcAddrTable( if( loader::context->version < version ) return ZE_RESULT_ERROR_UNSUPPORTED_VERSION; - ze_result_t result = ZE_RESULT_SUCCESS; + loader::context->ddi_init_version = version; - bool atLeastOneDriverValid = false; - // Load the device-driver DDI tables - for( auto& drv : loader::context->zeDrivers ) - { - if(drv.initStatus != ZE_RESULT_SUCCESS) - continue; - auto getTable = reinterpret_cast( - GET_FUNCTION_PTR( drv.handle, "zeGetContextProcAddrTable") ); - if(!getTable) - continue; - auto getTableResult = getTable( version, &drv.dditable.ze.Context); - if(getTableResult == ZE_RESULT_SUCCESS) { - atLeastOneDriverValid = true; - loader::context->configured_version = version; - } else - drv.initStatus = getTableResult; - } - - if(!atLeastOneDriverValid) - result = ZE_RESULT_ERROR_UNINITIALIZED; - else - result = ZE_RESULT_SUCCESS; + ze_result_t result = ZE_RESULT_SUCCESS; if( ZE_RESULT_SUCCESS == result ) { @@ -8968,30 +9672,9 @@ zeGetCommandQueueProcAddrTable( if( loader::context->version < version ) return ZE_RESULT_ERROR_UNSUPPORTED_VERSION; - ze_result_t result = ZE_RESULT_SUCCESS; + loader::context->ddi_init_version = version; - bool atLeastOneDriverValid = false; - // Load the device-driver DDI tables - for( auto& drv : loader::context->zeDrivers ) - { - if(drv.initStatus != ZE_RESULT_SUCCESS) - continue; - auto getTable = reinterpret_cast( - GET_FUNCTION_PTR( drv.handle, "zeGetCommandQueueProcAddrTable") ); - if(!getTable) - continue; - auto getTableResult = getTable( version, &drv.dditable.ze.CommandQueue); - if(getTableResult == ZE_RESULT_SUCCESS) { - atLeastOneDriverValid = true; - loader::context->configured_version = version; - } else - drv.initStatus = getTableResult; - } - - if(!atLeastOneDriverValid) - result = ZE_RESULT_ERROR_UNINITIALIZED; - else - result = ZE_RESULT_SUCCESS; + ze_result_t result = ZE_RESULT_SUCCESS; if( ZE_RESULT_SUCCESS == result ) { @@ -9104,30 +9787,9 @@ zeGetCommandListProcAddrTable( if( loader::context->version < version ) return ZE_RESULT_ERROR_UNSUPPORTED_VERSION; - ze_result_t result = ZE_RESULT_SUCCESS; + loader::context->ddi_init_version = version; - bool atLeastOneDriverValid = false; - // Load the device-driver DDI tables - for( auto& drv : loader::context->zeDrivers ) - { - if(drv.initStatus != ZE_RESULT_SUCCESS) - continue; - auto getTable = reinterpret_cast( - GET_FUNCTION_PTR( drv.handle, "zeGetCommandListProcAddrTable") ); - if(!getTable) - continue; - auto getTableResult = getTable( version, &drv.dditable.ze.CommandList); - if(getTableResult == ZE_RESULT_SUCCESS) { - atLeastOneDriverValid = true; - loader::context->configured_version = version; - } else - drv.initStatus = getTableResult; - } - - if(!atLeastOneDriverValid) - result = ZE_RESULT_ERROR_UNINITIALIZED; - else - result = ZE_RESULT_SUCCESS; + ze_result_t result = ZE_RESULT_SUCCESS; if( ZE_RESULT_SUCCESS == result ) { @@ -9464,20 +10126,9 @@ zeGetCommandListExpProcAddrTable( if( loader::context->version < version ) return ZE_RESULT_ERROR_UNSUPPORTED_VERSION; - ze_result_t result = ZE_RESULT_SUCCESS; - - // Load the device-driver DDI tables - for( auto& drv : loader::context->zeDrivers ) - { - if(drv.initStatus != ZE_RESULT_SUCCESS) - continue; - auto getTable = reinterpret_cast( - GET_FUNCTION_PTR( drv.handle, "zeGetCommandListExpProcAddrTable") ); - if(!getTable) - continue; - result = getTable( version, &drv.dditable.ze.CommandListExp); - } + loader::context->ddi_init_version = version; + ze_result_t result = ZE_RESULT_SUCCESS; if( ZE_RESULT_SUCCESS == result ) { @@ -9604,30 +10255,9 @@ zeGetEventProcAddrTable( if( loader::context->version < version ) return ZE_RESULT_ERROR_UNSUPPORTED_VERSION; - ze_result_t result = ZE_RESULT_SUCCESS; + loader::context->ddi_init_version = version; - bool atLeastOneDriverValid = false; - // Load the device-driver DDI tables - for( auto& drv : loader::context->zeDrivers ) - { - if(drv.initStatus != ZE_RESULT_SUCCESS) - continue; - auto getTable = reinterpret_cast( - GET_FUNCTION_PTR( drv.handle, "zeGetEventProcAddrTable") ); - if(!getTable) - continue; - auto getTableResult = getTable( version, &drv.dditable.ze.Event); - if(getTableResult == ZE_RESULT_SUCCESS) { - atLeastOneDriverValid = true; - loader::context->configured_version = version; - } else - drv.initStatus = getTableResult; - } - - if(!atLeastOneDriverValid) - result = ZE_RESULT_ERROR_UNINITIALIZED; - else - result = ZE_RESULT_SUCCESS; + ze_result_t result = ZE_RESULT_SUCCESS; if( ZE_RESULT_SUCCESS == result ) { @@ -9775,20 +10405,9 @@ zeGetEventExpProcAddrTable( if( loader::context->version < version ) return ZE_RESULT_ERROR_UNSUPPORTED_VERSION; - ze_result_t result = ZE_RESULT_SUCCESS; - - // Load the device-driver DDI tables - for( auto& drv : loader::context->zeDrivers ) - { - if(drv.initStatus != ZE_RESULT_SUCCESS) - continue; - auto getTable = reinterpret_cast( - GET_FUNCTION_PTR( drv.handle, "zeGetEventExpProcAddrTable") ); - if(!getTable) - continue; - result = getTable( version, &drv.dditable.ze.EventExp); - } + loader::context->ddi_init_version = version; + ze_result_t result = ZE_RESULT_SUCCESS; if( ZE_RESULT_SUCCESS == result ) { @@ -9866,30 +10485,9 @@ zeGetEventPoolProcAddrTable( if( loader::context->version < version ) return ZE_RESULT_ERROR_UNSUPPORTED_VERSION; - ze_result_t result = ZE_RESULT_SUCCESS; + loader::context->ddi_init_version = version; - bool atLeastOneDriverValid = false; - // Load the device-driver DDI tables - for( auto& drv : loader::context->zeDrivers ) - { - if(drv.initStatus != ZE_RESULT_SUCCESS) - continue; - auto getTable = reinterpret_cast( - GET_FUNCTION_PTR( drv.handle, "zeGetEventPoolProcAddrTable") ); - if(!getTable) - continue; - auto getTableResult = getTable( version, &drv.dditable.ze.EventPool); - if(getTableResult == ZE_RESULT_SUCCESS) { - atLeastOneDriverValid = true; - loader::context->configured_version = version; - } else - drv.initStatus = getTableResult; - } - - if(!atLeastOneDriverValid) - result = ZE_RESULT_ERROR_UNINITIALIZED; - else - result = ZE_RESULT_SUCCESS; + ze_result_t result = ZE_RESULT_SUCCESS; if( ZE_RESULT_SUCCESS == result ) { @@ -10016,30 +10614,9 @@ zeGetFenceProcAddrTable( if( loader::context->version < version ) return ZE_RESULT_ERROR_UNSUPPORTED_VERSION; - ze_result_t result = ZE_RESULT_SUCCESS; + loader::context->ddi_init_version = version; - bool atLeastOneDriverValid = false; - // Load the device-driver DDI tables - for( auto& drv : loader::context->zeDrivers ) - { - if(drv.initStatus != ZE_RESULT_SUCCESS) - continue; - auto getTable = reinterpret_cast( - GET_FUNCTION_PTR( drv.handle, "zeGetFenceProcAddrTable") ); - if(!getTable) - continue; - auto getTableResult = getTable( version, &drv.dditable.ze.Fence); - if(getTableResult == ZE_RESULT_SUCCESS) { - atLeastOneDriverValid = true; - loader::context->configured_version = version; - } else - drv.initStatus = getTableResult; - } - - if(!atLeastOneDriverValid) - result = ZE_RESULT_ERROR_UNINITIALIZED; - else - result = ZE_RESULT_SUCCESS; + ze_result_t result = ZE_RESULT_SUCCESS; if( ZE_RESULT_SUCCESS == result ) { @@ -10145,30 +10722,9 @@ zeGetImageProcAddrTable( if( loader::context->version < version ) return ZE_RESULT_ERROR_UNSUPPORTED_VERSION; - ze_result_t result = ZE_RESULT_SUCCESS; + loader::context->ddi_init_version = version; - bool atLeastOneDriverValid = false; - // Load the device-driver DDI tables - for( auto& drv : loader::context->zeDrivers ) - { - if(drv.initStatus != ZE_RESULT_SUCCESS) - continue; - auto getTable = reinterpret_cast( - GET_FUNCTION_PTR( drv.handle, "zeGetImageProcAddrTable") ); - if(!getTable) - continue; - auto getTableResult = getTable( version, &drv.dditable.ze.Image); - if(getTableResult == ZE_RESULT_SUCCESS) { - atLeastOneDriverValid = true; - loader::context->configured_version = version; - } else - drv.initStatus = getTableResult; - } - - if(!atLeastOneDriverValid) - result = ZE_RESULT_ERROR_UNINITIALIZED; - else - result = ZE_RESULT_SUCCESS; + ze_result_t result = ZE_RESULT_SUCCESS; if( ZE_RESULT_SUCCESS == result ) { @@ -10274,20 +10830,9 @@ zeGetImageExpProcAddrTable( if( loader::context->version < version ) return ZE_RESULT_ERROR_UNSUPPORTED_VERSION; - ze_result_t result = ZE_RESULT_SUCCESS; - - // Load the device-driver DDI tables - for( auto& drv : loader::context->zeDrivers ) - { - if(drv.initStatus != ZE_RESULT_SUCCESS) - continue; - auto getTable = reinterpret_cast( - GET_FUNCTION_PTR( drv.handle, "zeGetImageExpProcAddrTable") ); - if(!getTable) - continue; - result = getTable( version, &drv.dditable.ze.ImageExp); - } + loader::context->ddi_init_version = version; + ze_result_t result = ZE_RESULT_SUCCESS; if( ZE_RESULT_SUCCESS == result ) { @@ -10379,30 +10924,9 @@ zeGetKernelProcAddrTable( if( loader::context->version < version ) return ZE_RESULT_ERROR_UNSUPPORTED_VERSION; - ze_result_t result = ZE_RESULT_SUCCESS; + loader::context->ddi_init_version = version; - bool atLeastOneDriverValid = false; - // Load the device-driver DDI tables - for( auto& drv : loader::context->zeDrivers ) - { - if(drv.initStatus != ZE_RESULT_SUCCESS) - continue; - auto getTable = reinterpret_cast( - GET_FUNCTION_PTR( drv.handle, "zeGetKernelProcAddrTable") ); - if(!getTable) - continue; - auto getTableResult = getTable( version, &drv.dditable.ze.Kernel); - if(getTableResult == ZE_RESULT_SUCCESS) { - atLeastOneDriverValid = true; - loader::context->configured_version = version; - } else - drv.initStatus = getTableResult; - } - - if(!atLeastOneDriverValid) - result = ZE_RESULT_ERROR_UNINITIALIZED; - else - result = ZE_RESULT_SUCCESS; + ze_result_t result = ZE_RESULT_SUCCESS; if( ZE_RESULT_SUCCESS == result ) { @@ -10557,20 +11081,9 @@ zeGetKernelExpProcAddrTable( if( loader::context->version < version ) return ZE_RESULT_ERROR_UNSUPPORTED_VERSION; - ze_result_t result = ZE_RESULT_SUCCESS; - - // Load the device-driver DDI tables - for( auto& drv : loader::context->zeDrivers ) - { - if(drv.initStatus != ZE_RESULT_SUCCESS) - continue; - auto getTable = reinterpret_cast( - GET_FUNCTION_PTR( drv.handle, "zeGetKernelExpProcAddrTable") ); - if(!getTable) - continue; - result = getTable( version, &drv.dditable.ze.KernelExp); - } + loader::context->ddi_init_version = version; + ze_result_t result = ZE_RESULT_SUCCESS; if( ZE_RESULT_SUCCESS == result ) { @@ -10669,30 +11182,9 @@ zeGetMemProcAddrTable( if( loader::context->version < version ) return ZE_RESULT_ERROR_UNSUPPORTED_VERSION; - ze_result_t result = ZE_RESULT_SUCCESS; + loader::context->ddi_init_version = version; - bool atLeastOneDriverValid = false; - // Load the device-driver DDI tables - for( auto& drv : loader::context->zeDrivers ) - { - if(drv.initStatus != ZE_RESULT_SUCCESS) - continue; - auto getTable = reinterpret_cast( - GET_FUNCTION_PTR( drv.handle, "zeGetMemProcAddrTable") ); - if(!getTable) - continue; - auto getTableResult = getTable( version, &drv.dditable.ze.Mem); - if(getTableResult == ZE_RESULT_SUCCESS) { - atLeastOneDriverValid = true; - loader::context->configured_version = version; - } else - drv.initStatus = getTableResult; - } - - if(!atLeastOneDriverValid) - result = ZE_RESULT_ERROR_UNINITIALIZED; - else - result = ZE_RESULT_SUCCESS; + ze_result_t result = ZE_RESULT_SUCCESS; if( ZE_RESULT_SUCCESS == result ) { @@ -10847,20 +11339,9 @@ zeGetMemExpProcAddrTable( if( loader::context->version < version ) return ZE_RESULT_ERROR_UNSUPPORTED_VERSION; - ze_result_t result = ZE_RESULT_SUCCESS; - - // Load the device-driver DDI tables - for( auto& drv : loader::context->zeDrivers ) - { - if(drv.initStatus != ZE_RESULT_SUCCESS) - continue; - auto getTable = reinterpret_cast( - GET_FUNCTION_PTR( drv.handle, "zeGetMemExpProcAddrTable") ); - if(!getTable) - continue; - result = getTable( version, &drv.dditable.ze.MemExp); - } + loader::context->ddi_init_version = version; + ze_result_t result = ZE_RESULT_SUCCESS; if( ZE_RESULT_SUCCESS == result ) { @@ -10959,30 +11440,9 @@ zeGetModuleProcAddrTable( if( loader::context->version < version ) return ZE_RESULT_ERROR_UNSUPPORTED_VERSION; - ze_result_t result = ZE_RESULT_SUCCESS; + loader::context->ddi_init_version = version; - bool atLeastOneDriverValid = false; - // Load the device-driver DDI tables - for( auto& drv : loader::context->zeDrivers ) - { - if(drv.initStatus != ZE_RESULT_SUCCESS) - continue; - auto getTable = reinterpret_cast( - GET_FUNCTION_PTR( drv.handle, "zeGetModuleProcAddrTable") ); - if(!getTable) - continue; - auto getTableResult = getTable( version, &drv.dditable.ze.Module); - if(getTableResult == ZE_RESULT_SUCCESS) { - atLeastOneDriverValid = true; - loader::context->configured_version = version; - } else - drv.initStatus = getTableResult; - } - - if(!atLeastOneDriverValid) - result = ZE_RESULT_ERROR_UNINITIALIZED; - else - result = ZE_RESULT_SUCCESS; + ze_result_t result = ZE_RESULT_SUCCESS; if( ZE_RESULT_SUCCESS == result ) { @@ -11116,30 +11576,9 @@ zeGetModuleBuildLogProcAddrTable( if( loader::context->version < version ) return ZE_RESULT_ERROR_UNSUPPORTED_VERSION; - ze_result_t result = ZE_RESULT_SUCCESS; + loader::context->ddi_init_version = version; - bool atLeastOneDriverValid = false; - // Load the device-driver DDI tables - for( auto& drv : loader::context->zeDrivers ) - { - if(drv.initStatus != ZE_RESULT_SUCCESS) - continue; - auto getTable = reinterpret_cast( - GET_FUNCTION_PTR( drv.handle, "zeGetModuleBuildLogProcAddrTable") ); - if(!getTable) - continue; - auto getTableResult = getTable( version, &drv.dditable.ze.ModuleBuildLog); - if(getTableResult == ZE_RESULT_SUCCESS) { - atLeastOneDriverValid = true; - loader::context->configured_version = version; - } else - drv.initStatus = getTableResult; - } - - if(!atLeastOneDriverValid) - result = ZE_RESULT_ERROR_UNINITIALIZED; - else - result = ZE_RESULT_SUCCESS; + ze_result_t result = ZE_RESULT_SUCCESS; if( ZE_RESULT_SUCCESS == result ) { @@ -11224,30 +11663,9 @@ zeGetPhysicalMemProcAddrTable( if( loader::context->version < version ) return ZE_RESULT_ERROR_UNSUPPORTED_VERSION; - ze_result_t result = ZE_RESULT_SUCCESS; + loader::context->ddi_init_version = version; - bool atLeastOneDriverValid = false; - // Load the device-driver DDI tables - for( auto& drv : loader::context->zeDrivers ) - { - if(drv.initStatus != ZE_RESULT_SUCCESS) - continue; - auto getTable = reinterpret_cast( - GET_FUNCTION_PTR( drv.handle, "zeGetPhysicalMemProcAddrTable") ); - if(!getTable) - continue; - auto getTableResult = getTable( version, &drv.dditable.ze.PhysicalMem); - if(getTableResult == ZE_RESULT_SUCCESS) { - atLeastOneDriverValid = true; - loader::context->configured_version = version; - } else - drv.initStatus = getTableResult; - } - - if(!atLeastOneDriverValid) - result = ZE_RESULT_ERROR_UNINITIALIZED; - else - result = ZE_RESULT_SUCCESS; + ze_result_t result = ZE_RESULT_SUCCESS; if( ZE_RESULT_SUCCESS == result ) { @@ -11332,30 +11750,9 @@ zeGetSamplerProcAddrTable( if( loader::context->version < version ) return ZE_RESULT_ERROR_UNSUPPORTED_VERSION; - ze_result_t result = ZE_RESULT_SUCCESS; + loader::context->ddi_init_version = version; - bool atLeastOneDriverValid = false; - // Load the device-driver DDI tables - for( auto& drv : loader::context->zeDrivers ) - { - if(drv.initStatus != ZE_RESULT_SUCCESS) - continue; - auto getTable = reinterpret_cast( - GET_FUNCTION_PTR( drv.handle, "zeGetSamplerProcAddrTable") ); - if(!getTable) - continue; - auto getTableResult = getTable( version, &drv.dditable.ze.Sampler); - if(getTableResult == ZE_RESULT_SUCCESS) { - atLeastOneDriverValid = true; - loader::context->configured_version = version; - } else - drv.initStatus = getTableResult; - } - - if(!atLeastOneDriverValid) - result = ZE_RESULT_ERROR_UNINITIALIZED; - else - result = ZE_RESULT_SUCCESS; + ze_result_t result = ZE_RESULT_SUCCESS; if( ZE_RESULT_SUCCESS == result ) { @@ -11440,30 +11837,9 @@ zeGetVirtualMemProcAddrTable( if( loader::context->version < version ) return ZE_RESULT_ERROR_UNSUPPORTED_VERSION; - ze_result_t result = ZE_RESULT_SUCCESS; + loader::context->ddi_init_version = version; - bool atLeastOneDriverValid = false; - // Load the device-driver DDI tables - for( auto& drv : loader::context->zeDrivers ) - { - if(drv.initStatus != ZE_RESULT_SUCCESS) - continue; - auto getTable = reinterpret_cast( - GET_FUNCTION_PTR( drv.handle, "zeGetVirtualMemProcAddrTable") ); - if(!getTable) - continue; - auto getTableResult = getTable( version, &drv.dditable.ze.VirtualMem); - if(getTableResult == ZE_RESULT_SUCCESS) { - atLeastOneDriverValid = true; - loader::context->configured_version = version; - } else - drv.initStatus = getTableResult; - } - - if(!atLeastOneDriverValid) - result = ZE_RESULT_ERROR_UNINITIALIZED; - else - result = ZE_RESULT_SUCCESS; + ze_result_t result = ZE_RESULT_SUCCESS; if( ZE_RESULT_SUCCESS == result ) { @@ -11583,20 +11959,9 @@ zeGetFabricEdgeExpProcAddrTable( if( loader::context->version < version ) return ZE_RESULT_ERROR_UNSUPPORTED_VERSION; - ze_result_t result = ZE_RESULT_SUCCESS; - - // Load the device-driver DDI tables - for( auto& drv : loader::context->zeDrivers ) - { - if(drv.initStatus != ZE_RESULT_SUCCESS) - continue; - auto getTable = reinterpret_cast( - GET_FUNCTION_PTR( drv.handle, "zeGetFabricEdgeExpProcAddrTable") ); - if(!getTable) - continue; - result = getTable( version, &drv.dditable.ze.FabricEdgeExp); - } + loader::context->ddi_init_version = version; + ze_result_t result = ZE_RESULT_SUCCESS; if( ZE_RESULT_SUCCESS == result ) { @@ -11688,20 +12053,9 @@ zeGetFabricVertexExpProcAddrTable( if( loader::context->version < version ) return ZE_RESULT_ERROR_UNSUPPORTED_VERSION; - ze_result_t result = ZE_RESULT_SUCCESS; - - // Load the device-driver DDI tables - for( auto& drv : loader::context->zeDrivers ) - { - if(drv.initStatus != ZE_RESULT_SUCCESS) - continue; - auto getTable = reinterpret_cast( - GET_FUNCTION_PTR( drv.handle, "zeGetFabricVertexExpProcAddrTable") ); - if(!getTable) - continue; - result = getTable( version, &drv.dditable.ze.FabricVertexExp); - } + loader::context->ddi_init_version = version; + ze_result_t result = ZE_RESULT_SUCCESS; if( ZE_RESULT_SUCCESS == result ) { diff --git a/source/loader/ze_ldrddi.h b/source/loader/ze_ldrddi.h index 485fef93..331113f8 100644 --- a/source/loader/ze_ldrddi.h +++ b/source/loader/ze_ldrddi.h @@ -11,6 +11,10 @@ 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; /////////////////////////////////////////////////////////////////////////////// using ze_driver_object_t = object_t < ze_driver_handle_t >; using ze_driver_factory_t = singleton_factory_t < ze_driver_object_t, ze_driver_handle_t >; @@ -75,6 +79,8 @@ namespace loader using ze_rtas_parallel_operation_exp_object_t = object_t < ze_rtas_parallel_operation_exp_handle_t >; using ze_rtas_parallel_operation_exp_factory_t = singleton_factory_t < ze_rtas_parallel_operation_exp_object_t, ze_rtas_parallel_operation_exp_handle_t >; + __zedlllocal ze_result_t ZE_APICALL + zeloaderInitDriverDDITables(loader::driver_t *driver); } namespace loader_driver_ddi @@ -1658,64 +1664,124 @@ extern "C" { __zedlllocal void ZE_APICALL zeGetGlobalProcAddrTableLegacy(); +__zedlllocal ze_result_t ZE_APICALL +zeGetGlobalProcAddrTableFromDriver(loader::driver_t *driver); __zedlllocal void ZE_APICALL zeGetRTASBuilderProcAddrTableLegacy(); +__zedlllocal ze_result_t ZE_APICALL +zeGetRTASBuilderProcAddrTableFromDriver(loader::driver_t *driver); __zedlllocal void ZE_APICALL zeGetRTASBuilderExpProcAddrTableLegacy(); +__zedlllocal ze_result_t ZE_APICALL +zeGetRTASBuilderExpProcAddrTableFromDriver(loader::driver_t *driver); __zedlllocal void ZE_APICALL zeGetRTASParallelOperationProcAddrTableLegacy(); +__zedlllocal ze_result_t ZE_APICALL +zeGetRTASParallelOperationProcAddrTableFromDriver(loader::driver_t *driver); __zedlllocal void ZE_APICALL zeGetRTASParallelOperationExpProcAddrTableLegacy(); +__zedlllocal ze_result_t ZE_APICALL +zeGetRTASParallelOperationExpProcAddrTableFromDriver(loader::driver_t *driver); __zedlllocal void ZE_APICALL zeGetDriverProcAddrTableLegacy(); +__zedlllocal ze_result_t ZE_APICALL +zeGetDriverProcAddrTableFromDriver(loader::driver_t *driver); __zedlllocal void ZE_APICALL zeGetDriverExpProcAddrTableLegacy(); +__zedlllocal ze_result_t ZE_APICALL +zeGetDriverExpProcAddrTableFromDriver(loader::driver_t *driver); __zedlllocal void ZE_APICALL zeGetDeviceProcAddrTableLegacy(); +__zedlllocal ze_result_t ZE_APICALL +zeGetDeviceProcAddrTableFromDriver(loader::driver_t *driver); __zedlllocal void ZE_APICALL zeGetDeviceExpProcAddrTableLegacy(); +__zedlllocal ze_result_t ZE_APICALL +zeGetDeviceExpProcAddrTableFromDriver(loader::driver_t *driver); __zedlllocal void ZE_APICALL zeGetContextProcAddrTableLegacy(); +__zedlllocal ze_result_t ZE_APICALL +zeGetContextProcAddrTableFromDriver(loader::driver_t *driver); __zedlllocal void ZE_APICALL zeGetCommandQueueProcAddrTableLegacy(); +__zedlllocal ze_result_t ZE_APICALL +zeGetCommandQueueProcAddrTableFromDriver(loader::driver_t *driver); __zedlllocal void ZE_APICALL zeGetCommandListProcAddrTableLegacy(); +__zedlllocal ze_result_t ZE_APICALL +zeGetCommandListProcAddrTableFromDriver(loader::driver_t *driver); __zedlllocal void ZE_APICALL zeGetCommandListExpProcAddrTableLegacy(); +__zedlllocal ze_result_t ZE_APICALL +zeGetCommandListExpProcAddrTableFromDriver(loader::driver_t *driver); __zedlllocal void ZE_APICALL zeGetEventProcAddrTableLegacy(); +__zedlllocal ze_result_t ZE_APICALL +zeGetEventProcAddrTableFromDriver(loader::driver_t *driver); __zedlllocal void ZE_APICALL zeGetEventExpProcAddrTableLegacy(); +__zedlllocal ze_result_t ZE_APICALL +zeGetEventExpProcAddrTableFromDriver(loader::driver_t *driver); __zedlllocal void ZE_APICALL zeGetEventPoolProcAddrTableLegacy(); +__zedlllocal ze_result_t ZE_APICALL +zeGetEventPoolProcAddrTableFromDriver(loader::driver_t *driver); __zedlllocal void ZE_APICALL zeGetFenceProcAddrTableLegacy(); +__zedlllocal ze_result_t ZE_APICALL +zeGetFenceProcAddrTableFromDriver(loader::driver_t *driver); __zedlllocal void ZE_APICALL zeGetImageProcAddrTableLegacy(); +__zedlllocal ze_result_t ZE_APICALL +zeGetImageProcAddrTableFromDriver(loader::driver_t *driver); __zedlllocal void ZE_APICALL zeGetImageExpProcAddrTableLegacy(); +__zedlllocal ze_result_t ZE_APICALL +zeGetImageExpProcAddrTableFromDriver(loader::driver_t *driver); __zedlllocal void ZE_APICALL zeGetKernelProcAddrTableLegacy(); +__zedlllocal ze_result_t ZE_APICALL +zeGetKernelProcAddrTableFromDriver(loader::driver_t *driver); __zedlllocal void ZE_APICALL zeGetKernelExpProcAddrTableLegacy(); +__zedlllocal ze_result_t ZE_APICALL +zeGetKernelExpProcAddrTableFromDriver(loader::driver_t *driver); __zedlllocal void ZE_APICALL zeGetMemProcAddrTableLegacy(); +__zedlllocal ze_result_t ZE_APICALL +zeGetMemProcAddrTableFromDriver(loader::driver_t *driver); __zedlllocal void ZE_APICALL zeGetMemExpProcAddrTableLegacy(); +__zedlllocal ze_result_t ZE_APICALL +zeGetMemExpProcAddrTableFromDriver(loader::driver_t *driver); __zedlllocal void ZE_APICALL zeGetModuleProcAddrTableLegacy(); +__zedlllocal ze_result_t ZE_APICALL +zeGetModuleProcAddrTableFromDriver(loader::driver_t *driver); __zedlllocal void ZE_APICALL zeGetModuleBuildLogProcAddrTableLegacy(); +__zedlllocal ze_result_t ZE_APICALL +zeGetModuleBuildLogProcAddrTableFromDriver(loader::driver_t *driver); __zedlllocal void ZE_APICALL zeGetPhysicalMemProcAddrTableLegacy(); +__zedlllocal ze_result_t ZE_APICALL +zeGetPhysicalMemProcAddrTableFromDriver(loader::driver_t *driver); __zedlllocal void ZE_APICALL zeGetSamplerProcAddrTableLegacy(); +__zedlllocal ze_result_t ZE_APICALL +zeGetSamplerProcAddrTableFromDriver(loader::driver_t *driver); __zedlllocal void ZE_APICALL zeGetVirtualMemProcAddrTableLegacy(); +__zedlllocal ze_result_t ZE_APICALL +zeGetVirtualMemProcAddrTableFromDriver(loader::driver_t *driver); __zedlllocal void ZE_APICALL zeGetFabricEdgeExpProcAddrTableLegacy(); +__zedlllocal ze_result_t ZE_APICALL +zeGetFabricEdgeExpProcAddrTableFromDriver(loader::driver_t *driver); __zedlllocal void ZE_APICALL zeGetFabricVertexExpProcAddrTableLegacy(); +__zedlllocal ze_result_t ZE_APICALL +zeGetFabricVertexExpProcAddrTableFromDriver(loader::driver_t *driver); #if defined(__cplusplus) }; diff --git a/source/loader/ze_loader.cpp b/source/loader/ze_loader.cpp index 099eb223..e9fbcb87 100644 --- a/source/loader/ze_loader.cpp +++ b/source/loader/ze_loader.cpp @@ -257,6 +257,7 @@ namespace loader for (auto &driver : *drivers) { uint32_t pCount = 0; std::vector driverHandles; + driver.pciOrderingRequested = loader::context->pciOrderingRequested; ze_result_t res = ZE_RESULT_SUCCESS; if (desc && driver.dditable.ze.Global.pfnInitDrivers) { if (driver.initDriversStatus != ZE_RESULT_SUCCESS) { @@ -479,173 +480,83 @@ namespace loader * @return `ZE_RESULT_SUCCESS` if at least one driver is successfully initialized, otherwise an appropriate error code. */ ze_result_t context_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) { - if (debugTraceEnabled) { - if (desc) { - std::string message = "check_drivers(" + std::string("desc->flags=") + loader::to_string(desc) + ")"; - debug_trace_message(message, ""); - } else { - std::string message = "check_drivers(" + std::string("flags=") + loader::to_string(flags) + ")"; - debug_trace_message(message, ""); - } - } - // If zeInitDrivers is not supported by this driver, but zeInitDrivers is called first, then return uninitialized. - if (desc && !loader::context->initDriversSupport) { - if (debugTraceEnabled) { - std::string message = "zeInitDrivers called first, but not supported by driver, returning uninitialized."; - debug_trace_message(message, ""); - } - return ZE_RESULT_ERROR_UNINITIALIZED; - } - - - bool return_first_driver_result=false; - std::string initName = "zeInit"; - driver_vector_t *drivers = &zeDrivers; - // If desc is set, then this is zeInitDrivers. - if (desc) { - initName = "zeInitDrivers"; - } - // If this is sysmanOnly check_drivers, then zesInit is being called and we need to use zesDrivers. - if (sysmanOnly) { - drivers = &zesDrivers; - initName = "zesInit"; - } - if(drivers->size()==1) { - return_first_driver_result=true; - } - bool pciOrderingRequested = getenv_tobool( "ZE_ENABLE_PCI_ID_DEVICE_ORDER" ); - loader::context->instrumentationEnabled = getenv_tobool( "ZET_ENABLE_PROGRAM_INSTRUMENTATION" ); - - for(auto it = drivers->begin(); it != drivers->end(); ) - { - it->pciOrderingRequested = pciOrderingRequested; - std::string freeLibraryErrorValue; - ze_result_t result = init_driver(*it, flags, desc, globalInitStored, sysmanGlobalInitStored, sysmanOnly); - if(result != ZE_RESULT_SUCCESS) { - // If the driver has already been init and handles are to be read, then this driver cannot be removed from the list. - // Also, if any driver supports zeInitDrivers, then no driver can be removed to allow for different sets of drivers. - if (!it->driverInuse && !loader::context->initDriversSupport) { - if (debugTraceEnabled) { - std::string errorMessage = "Check Drivers Failed on " + it->name + " , driver will be removed. " + initName + " failed with "; - debug_trace_message(errorMessage, loader::to_string(result)); - } - it = drivers->erase(it); - // If the number of drivers is now ==1, then we need to reinit the ddi tables to pass through. - // If ZE_ENABLE_LOADER_INTERCEPT is set to 1, then even if drivers were removed, don't reinit the ddi tables. - if (drivers->size() == 1 && !loader::context->forceIntercept) { - *requireDdiReinit = true; - } - } else { - it++; - } - if(return_first_driver_result) - return result; - } else { - // If this is a single driver system, then the first success for this driver needs to be set. - it->driverInuse = true; - it++; - } - } - - if(drivers->size() == 0) - return ZE_RESULT_ERROR_UNINITIALIZED; - - // Set default driver handle and DDI table to the first driver in the list before sorting. - loader::context->defaultZerDriverHandle = &loader::context->zeDrivers.front().zerDriverHandle; - loader::defaultZerDdiTable = &loader::context->zeDrivers.front().dditable.zer; return ZE_RESULT_SUCCESS; } ze_result_t context_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) { - if (sysmanOnly) { - auto getTable = reinterpret_cast( - GET_FUNCTION_PTR(driver.handle, "zesGetGlobalProcAddrTable")); - if(!getTable) { + bool loadDriver = false; + if ((!desc && (flags == 0 || flags & ZE_INIT_FLAG_GPU_ONLY)) || (desc && desc->flags & ZE_INIT_DRIVER_TYPE_FLAG_GPU)) { + if (driver.name.find("gpu") != std::string::npos) { if (debugTraceEnabled) { - std::string errorMessage = "init driver " + driver.name + " failed, zesGetGlobalProcAddrTable function pointer null. Returning "; - debug_trace_message(errorMessage, loader::to_string(ZE_RESULT_ERROR_UNINITIALIZED)); + std::string message = "init driver " + driver.name + " found GPU Supported Driver."; + debug_trace_message(message, ""); } - return ZE_RESULT_ERROR_UNINITIALIZED; } - - zes_global_dditable_t global; - auto getTableResult = getTable(this->configured_version, &global); - if(getTableResult != ZE_RESULT_SUCCESS) { + loadDriver = true; + } + if ((!desc && (flags == 0 || flags & ZE_INIT_FLAG_VPU_ONLY)) || (desc && desc->flags & ZE_INIT_DRIVER_TYPE_FLAG_NPU)) { + if (driver.name.find("vpu") != std::string::npos || driver.name.find("npu") != std::string::npos) { if (debugTraceEnabled) { - std::string errorMessage = "init driver " + driver.name + " failed, zesGetGlobalProcAddrTable() failed with "; - debug_trace_message(errorMessage, loader::to_string(getTableResult)); + std::string message = "init driver " + driver.name + " found VPU/NPU Supported Driver."; + debug_trace_message(message, ""); } - return ZE_RESULT_ERROR_UNINITIALIZED; } + loadDriver = true; + } - if(nullptr == global.pfnInit) { + if (loadDriver && !driver.handle) { + auto handle = LOAD_DRIVER_LIBRARY( driver.name.c_str() ); + if( NULL != handle ) + { + driver.handle = handle; + } else { + std::string loadLibraryErrorValue; + GET_LIBRARY_ERROR(loadLibraryErrorValue); if (debugTraceEnabled) { - std::string errorMessage = "init driver " + driver.name + " failed, zesInit function pointer null. Returning "; - debug_trace_message(errorMessage, loader::to_string(ZE_RESULT_ERROR_UNINITIALIZED)); + std::string errorMessage = "init driver " + driver.name + " failed, Load Library of " + driver.name + " failed with "; + debug_trace_message(errorMessage, loadLibraryErrorValue); } return ZE_RESULT_ERROR_UNINITIALIZED; } + } - // Use the previously init ddi table pointer to zesInit to allow for intercept of the zesInit calls - ze_result_t res = sysmanGlobalInitStored->pfnInit(flags); - // Verify that this driver successfully init in the call above. - if (driver.initSysManStatus != ZE_RESULT_SUCCESS) { - res = driver.initSysManStatus; - } - if (debugTraceEnabled) { - std::string message = "init driver " + driver.name + " zesInit(" + loader::to_string(flags) + ") returning "; - debug_trace_message(message, loader::to_string(res)); - } - return res; - } else { - if (!desc) { - auto pfnInit = driver.dditable.ze.Global.pfnInit; - if(nullptr == pfnInit || globalInitStored->pfnInit == nullptr) { - if (debugTraceEnabled) { - std::string errorMessage = "init driver " + driver.name + " failed, zeInit function pointer null. Returning "; - debug_trace_message(errorMessage, loader::to_string(ZE_RESULT_ERROR_UNINITIALIZED)); - } - return ZE_RESULT_ERROR_UNINITIALIZED; + if (driver.handle && !driver.ddiInitialized) { + auto res = loader::zeloaderInitDriverDDITables(&driver); + if (res != ZE_RESULT_SUCCESS) { + if (debugTraceEnabled) { + std::string message = "init driver " + driver.name + " failed, zeloaderInitDriverDDITables returned "; + debug_trace_message(message, loader::to_string(res)); } - - // Use the previously init ddi table pointer to zeInit to allow for intercept of the zeInit calls - ze_result_t res = globalInitStored->pfnInit(flags); - // Verify that this driver successfully init in the call above. - if (res != ZE_RESULT_SUCCESS || driver.initStatus != ZE_RESULT_SUCCESS) { - if (driver.initStatus != ZE_RESULT_SUCCESS) - res = driver.initStatus; - if (debugTraceEnabled) { - std::string message = "init driver (global ddi) " + driver.name + " zeInit(" + loader::to_string(flags) + ") returning "; - debug_trace_message(message, loader::to_string(res)); - } - return res; + return res; + } + res = loader::zesloaderInitDriverDDITables(&driver); + if (res != ZE_RESULT_SUCCESS) { + if (debugTraceEnabled) { + std::string message = "init driver " + driver.name + " failed, zesloaderInitDriverDDITables returned "; + debug_trace_message(message, loader::to_string(res)); } - } else { - auto pfnInitDrivers = driver.dditable.ze.Global.pfnInitDrivers; - if(nullptr == pfnInitDrivers || globalInitStored->pfnInitDrivers == nullptr) { - if (debugTraceEnabled) { - std::string errorMessage = "init driver " + driver.name + " failed, pfnInitDrivers function pointer null. Returning "; - debug_trace_message(errorMessage, loader::to_string(ZE_RESULT_ERROR_UNINITIALIZED)); - } - return ZE_RESULT_ERROR_UNINITIALIZED; + return res; + } + res = loader::zetloaderInitDriverDDITables(&driver); + if (res != ZE_RESULT_SUCCESS) { + if (debugTraceEnabled) { + std::string message = "init driver " + driver.name + " failed, zetloaderInitDriverDDITables returned "; + debug_trace_message(message, loader::to_string(res)); } - - uint32_t pCount = 0; - // Use the previously init ddi table pointer to zeInitDrivers to allow for intercept of the zeInitDrivers calls - ze_result_t res = globalInitStored->pfnInitDrivers(&pCount, nullptr, desc); - // Verify that this driver successfully init in the call above. - if (res != ZE_RESULT_SUCCESS || driver.initDriversStatus != ZE_RESULT_SUCCESS) { - if (driver.initDriversStatus != ZE_RESULT_SUCCESS) - res = driver.initDriversStatus; - if (debugTraceEnabled) { - std::string message = "init driver (global ddi) " + driver.name + " zeInitDrivers(" + loader::to_string(desc) + ") returning "; - debug_trace_message(message, loader::to_string(res)); - } - return res; + return res; + } + res = loader::zerloaderInitDriverDDITables(&driver); + if (res != ZE_RESULT_SUCCESS) { + if (debugTraceEnabled) { + std::string message = "init driver " + driver.name + " failed, zerloaderInitDriverDDITables returned "; + debug_trace_message(message, loader::to_string(res)); } + return res; } - return ZE_RESULT_SUCCESS; + driver.ddiInitialized = true; } + + return ZE_RESULT_SUCCESS; } /////////////////////////////////////////////////////////////////////////////// @@ -654,6 +565,8 @@ namespace loader if (driverEnvironmentQueried) { return ZE_RESULT_SUCCESS; } + loader::context->instrumentationEnabled = getenv_tobool( "ZET_ENABLE_PROGRAM_INSTRUMENTATION" ); + loader::context->pciOrderingRequested = getenv_tobool( "ZE_ENABLE_PCI_ID_DEVICE_ORDER" ); loader::loaderDispatch = new ze_handle_t(); loader::loaderDispatch->pCore = new ze_dditable_driver_t(); loader::loaderDispatch->pCore->version = ZE_API_VERSION_CURRENT; @@ -743,29 +656,32 @@ namespace loader for( auto name : discoveredDrivers ) { - auto handle = LOAD_DRIVER_LIBRARY( name.c_str() ); - if( NULL != handle ) - { - if (debugTraceEnabled) { - std::string message = "Loading Driver " + name + " succeeded"; -#if !defined(_WIN32) && !defined(ANDROID) - // TODO: implement same message for windows, move dlinfo to ze_util.h as a macro - struct link_map *dlinfo_map; - if (dlinfo(handle, RTLD_DI_LINKMAP, &dlinfo_map) == 0) { - message += " from: " + std::string(dlinfo_map->l_name); - } -#endif - debug_trace_message(message, ""); - } - allDrivers.emplace_back(); - allDrivers.rbegin()->handle = handle; - allDrivers.rbegin()->name = name; - } else if (debugTraceEnabled) { - GET_LIBRARY_ERROR(loadLibraryErrorValue); - std::string errorMessage = "Load Library of " + name + " failed with "; - debug_trace_message(errorMessage, loadLibraryErrorValue); - loadLibraryErrorValue.clear(); - } + allDrivers.emplace_back(); + allDrivers.rbegin()->handle = nullptr; + allDrivers.rbegin()->name = name; +// auto handle = LOAD_DRIVER_LIBRARY( name.c_str() ); +// if( NULL != handle ) +// { +// if (debugTraceEnabled) { +// std::string message = "Loading Driver " + name + " succeeded"; +// #if !defined(_WIN32) && !defined(ANDROID) +// // TODO: implement same message for windows, move dlinfo to ze_util.h as a macro +// struct link_map *dlinfo_map; +// if (dlinfo(handle, RTLD_DI_LINKMAP, &dlinfo_map) == 0) { +// message += " from: " + std::string(dlinfo_map->l_name); +// } +// #endif +// debug_trace_message(message, ""); +// } +// allDrivers.emplace_back(); +// allDrivers.rbegin()->handle = handle; +// allDrivers.rbegin()->name = name; +// } else if (debugTraceEnabled) { +// GET_LIBRARY_ERROR(loadLibraryErrorValue); +// std::string errorMessage = "Load Library of " + name + " failed with "; +// debug_trace_message(errorMessage, loadLibraryErrorValue); +// loadLibraryErrorValue.clear(); +// } } if(allDrivers.size()==0){ if (debugTraceEnabled) { @@ -843,6 +759,10 @@ namespace loader driverEnvironmentQueried = true; + // Set default driver handle and DDI table to the first driver in the list before sorting. + loader::context->defaultZerDriverHandle = &loader::context->zeDrivers.front().zerDriverHandle; + loader::defaultZerDdiTable = &loader::context->zeDrivers.front().dditable.zer; + zel_logger->log_info("zeInit succeeded"); return ZE_RESULT_SUCCESS; }; diff --git a/source/loader/ze_loader_internal.h b/source/loader/ze_loader_internal.h index a296757f..861e1918 100644 --- a/source/loader/ze_loader_internal.h +++ b/source/loader/ze_loader_internal.h @@ -60,6 +60,8 @@ namespace loader bool legacyInitAttempted = false; bool driverDDIHandleSupportQueried = false; ze_driver_handle_t zerDriverHandle = nullptr; + ze_api_version_t versionRequested = ZE_API_VERSION_CURRENT; + bool ddiInitialized = false; }; using driver_vector_t = std::vector< driver_t >; @@ -133,6 +135,7 @@ namespace loader std::unordered_map 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; @@ -165,6 +168,7 @@ namespace loader std::atomic sortingInProgress = {false}; std::mutex sortMutex; bool instrumentationEnabled = false; + bool pciOrderingRequested = false; dditable_t tracing_dditable = {}; std::shared_ptr zel_logger; ze_driver_handle_t* defaultZerDriverHandle = nullptr; diff --git a/source/loader/zer_ldrddi.cpp b/source/loader/zer_ldrddi.cpp index bc4f5fc3..9da80901 100644 --- a/source/loader/zer_ldrddi.cpp +++ b/source/loader/zer_ldrddi.cpp @@ -13,6 +13,15 @@ using namespace loader_driver_ddi; namespace loader { + __zedlllocal ze_result_t ZE_APICALL + zerloaderInitDriverDDITables(loader::driver_t *driver) { + ze_result_t result = ZE_RESULT_SUCCESS; + result = zerGetGlobalProcAddrTableFromDriver(driver); + if (result != ZE_RESULT_SUCCESS) { + return result; + } + return result; + } /////////////////////////////////////////////////////////////////////////////// /// @brief Intercept function for zerGetLastErrorDescription __zedlllocal ze_result_t ZE_APICALL @@ -114,6 +123,35 @@ zerGetGlobalProcAddrTableLegacy() } +/////////////////////////////////////////////////////////////////////////////// +/// @brief Exported function for filling application's Global table +/// with current process' addresses +/// +/// @returns +/// - ::ZE_RESULT_SUCCESS +/// - ::ZE_RESULT_ERROR_UNINITIALIZED +/// - ::ZE_RESULT_ERROR_INVALID_NULL_POINTER +/// - ::ZE_RESULT_ERROR_UNSUPPORTED_VERSION +__zedlllocal ze_result_t ZE_APICALL +zerGetGlobalProcAddrTableFromDriver(loader::driver_t *driver) +{ + ze_result_t result = ZE_RESULT_SUCCESS; + if(driver->initStatus != ZE_RESULT_SUCCESS) + return driver->initStatus; + auto getTable = reinterpret_cast( + GET_FUNCTION_PTR( driver->handle, "zerGetGlobalProcAddrTable") ); + if(!getTable) + return driver->initStatus; + auto getTableResult = getTable( loader::context->ddi_init_version, &driver->dditable.zer.Global); + if(getTableResult == ZE_RESULT_SUCCESS) { + loader::context->configured_version = loader::context->ddi_init_version; + } else + driver->initStatus = getTableResult; + if (driver->dditable.ze.Global.pfnInitDrivers) { + loader::context->initDriversSupport = true; + } + return result; +} /////////////////////////////////////////////////////////////////////////////// /// @brief Exported function for filling application's Global table /// with current process' addresses @@ -139,37 +177,13 @@ zerGetGlobalProcAddrTable( if( loader::context->version < version ) return ZE_RESULT_ERROR_UNSUPPORTED_VERSION; - ze_result_t result = ZE_RESULT_SUCCESS; + loader::context->ddi_init_version = version; - bool atLeastOneDriverValid = false; - // Load the device-driver DDI tables - for( auto& drv : loader::context->zeDrivers ) - { - if(drv.initStatus != ZE_RESULT_SUCCESS) - continue; - auto getTable = reinterpret_cast( - GET_FUNCTION_PTR( drv.handle, "zerGetGlobalProcAddrTable") ); - if(!getTable) - continue; - auto getTableResult = getTable( version, &drv.dditable.zer.Global); - if(getTableResult == ZE_RESULT_SUCCESS) { - atLeastOneDriverValid = true; - loader::context->configured_version = version; - } else - drv.initStatus = getTableResult; - if (drv.dditable.ze.Global.pfnInitDrivers) { - loader::context->initDriversSupport = true; - } - } - - if(!atLeastOneDriverValid) - result = ZE_RESULT_ERROR_UNINITIALIZED; - else - result = ZE_RESULT_SUCCESS; + ze_result_t result = ZE_RESULT_SUCCESS; if( ZE_RESULT_SUCCESS == result ) { - if( ( loader::context->zeDrivers.size() > 1 ) || loader::context->forceIntercept ) + if( true ) { // return pointers to loader's DDIs loader::loaderDispatch->pRuntime->Global = new zer_global_dditable_t; diff --git a/source/loader/zer_ldrddi.h b/source/loader/zer_ldrddi.h index 5e4ad2e4..c64eec07 100644 --- a/source/loader/zer_ldrddi.h +++ b/source/loader/zer_ldrddi.h @@ -12,6 +12,12 @@ 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; + /////////////////////////////////////////////////////////////////////////////// + __zedlllocal ze_result_t ZE_APICALL + zerloaderInitDriverDDITables(loader::driver_t *driver); } namespace loader_driver_ddi @@ -43,6 +49,8 @@ extern "C" { __zedlllocal void ZE_APICALL zerGetGlobalProcAddrTableLegacy(); +__zedlllocal ze_result_t ZE_APICALL +zerGetGlobalProcAddrTableFromDriver(loader::driver_t *driver); #if defined(__cplusplus) }; diff --git a/source/loader/zes_ldrddi.cpp b/source/loader/zes_ldrddi.cpp index f28e1a87..968fb0f9 100644 --- a/source/loader/zes_ldrddi.cpp +++ b/source/loader/zes_ldrddi.cpp @@ -13,6 +13,107 @@ using namespace loader_driver_ddi; namespace loader { + __zedlllocal ze_result_t ZE_APICALL + zesloaderInitDriverDDITables(loader::driver_t *driver) { + ze_result_t result = ZE_RESULT_SUCCESS; + result = zesGetGlobalProcAddrTableFromDriver(driver); + if (result != ZE_RESULT_SUCCESS) { + return result; + } + result = zesGetDeviceProcAddrTableFromDriver(driver); + if (result != ZE_RESULT_SUCCESS) { + return result; + } + result = zesGetDeviceExpProcAddrTableFromDriver(driver); + if (result != ZE_RESULT_SUCCESS) { + return result; + } + result = zesGetDriverProcAddrTableFromDriver(driver); + if (result != ZE_RESULT_SUCCESS) { + return result; + } + result = zesGetDriverExpProcAddrTableFromDriver(driver); + if (result != ZE_RESULT_SUCCESS) { + return result; + } + result = zesGetDiagnosticsProcAddrTableFromDriver(driver); + if (result != ZE_RESULT_SUCCESS) { + return result; + } + result = zesGetEngineProcAddrTableFromDriver(driver); + if (result != ZE_RESULT_SUCCESS) { + return result; + } + result = zesGetFabricPortProcAddrTableFromDriver(driver); + if (result != ZE_RESULT_SUCCESS) { + return result; + } + result = zesGetFanProcAddrTableFromDriver(driver); + if (result != ZE_RESULT_SUCCESS) { + return result; + } + result = zesGetFirmwareProcAddrTableFromDriver(driver); + if (result != ZE_RESULT_SUCCESS) { + return result; + } + result = zesGetFirmwareExpProcAddrTableFromDriver(driver); + if (result != ZE_RESULT_SUCCESS) { + return result; + } + result = zesGetFrequencyProcAddrTableFromDriver(driver); + if (result != ZE_RESULT_SUCCESS) { + return result; + } + result = zesGetLedProcAddrTableFromDriver(driver); + if (result != ZE_RESULT_SUCCESS) { + return result; + } + result = zesGetMemoryProcAddrTableFromDriver(driver); + if (result != ZE_RESULT_SUCCESS) { + return result; + } + result = zesGetOverclockProcAddrTableFromDriver(driver); + if (result != ZE_RESULT_SUCCESS) { + return result; + } + result = zesGetPerformanceFactorProcAddrTableFromDriver(driver); + if (result != ZE_RESULT_SUCCESS) { + return result; + } + result = zesGetPowerProcAddrTableFromDriver(driver); + if (result != ZE_RESULT_SUCCESS) { + return result; + } + result = zesGetPsuProcAddrTableFromDriver(driver); + if (result != ZE_RESULT_SUCCESS) { + return result; + } + result = zesGetRasProcAddrTableFromDriver(driver); + if (result != ZE_RESULT_SUCCESS) { + return result; + } + result = zesGetRasExpProcAddrTableFromDriver(driver); + if (result != ZE_RESULT_SUCCESS) { + return result; + } + result = zesGetSchedulerProcAddrTableFromDriver(driver); + if (result != ZE_RESULT_SUCCESS) { + return result; + } + result = zesGetStandbyProcAddrTableFromDriver(driver); + if (result != ZE_RESULT_SUCCESS) { + return result; + } + result = zesGetTemperatureProcAddrTableFromDriver(driver); + if (result != ZE_RESULT_SUCCESS) { + return result; + } + result = zesGetVFManagementExpProcAddrTableFromDriver(driver); + if (result != ZE_RESULT_SUCCESS) { + return result; + } + return result; + } /////////////////////////////////////////////////////////////////////////////// /// @brief Intercept function for zesInit __zedlllocal ze_result_t ZE_APICALL @@ -28,6 +129,13 @@ namespace loader { if(drv.initStatus != ZE_RESULT_SUCCESS || drv.initSysManStatus != ZE_RESULT_SUCCESS) continue; + if (!drv.handle || !drv.ddiInitialized) { + bool sysmanInit = true; + auto res = loader::context->init_driver( drv, flags, nullptr, nullptr, nullptr, sysmanInit ); + if (res != ZE_RESULT_SUCCESS) { + continue; + } + } if (!drv.dditable.zes.Global.pfnInit) { drv.initSysManStatus = ZE_RESULT_ERROR_UNINITIALIZED; continue; @@ -74,7 +182,7 @@ namespace loader for( auto& drv : *loader::context->sysmanInstanceDrivers ) { - 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; if( ( 0 < *pCount ) && ( *pCount == total_driver_handle_count)) @@ -4929,6 +5037,616 @@ zesGetVFManagementExpProcAddrTableLegacy() } +/////////////////////////////////////////////////////////////////////////////// +/// @brief Exported function for filling application's Global table +/// with current process' addresses +/// +/// @returns +/// - ::ZE_RESULT_SUCCESS +/// - ::ZE_RESULT_ERROR_UNINITIALIZED +/// - ::ZE_RESULT_ERROR_INVALID_NULL_POINTER +/// - ::ZE_RESULT_ERROR_UNSUPPORTED_VERSION +__zedlllocal ze_result_t ZE_APICALL +zesGetGlobalProcAddrTableFromDriver(loader::driver_t *driver) +{ + ze_result_t result = ZE_RESULT_SUCCESS; + if(driver->initStatus != ZE_RESULT_SUCCESS) + return driver->initStatus; + auto getTable = reinterpret_cast( + GET_FUNCTION_PTR( driver->handle, "zesGetGlobalProcAddrTable") ); + if(!getTable) + { + //It is valid to not have this proc addr table + return ZE_RESULT_SUCCESS; + } + auto getTableResult = getTable( loader::context->ddi_init_version, &driver->dditable.zes.Global); + if(getTableResult == ZE_RESULT_SUCCESS) { + loader::context->configured_version = loader::context->ddi_init_version; + } else + driver->initStatus = getTableResult; + return result; +} +/////////////////////////////////////////////////////////////////////////////// +/// @brief Exported function for filling application's Device table +/// with current process' addresses +/// +/// @returns +/// - ::ZE_RESULT_SUCCESS +/// - ::ZE_RESULT_ERROR_UNINITIALIZED +/// - ::ZE_RESULT_ERROR_INVALID_NULL_POINTER +/// - ::ZE_RESULT_ERROR_UNSUPPORTED_VERSION +__zedlllocal ze_result_t ZE_APICALL +zesGetDeviceProcAddrTableFromDriver(loader::driver_t *driver) +{ + ze_result_t result = ZE_RESULT_SUCCESS; + if(driver->initStatus != ZE_RESULT_SUCCESS) + return driver->initStatus; + auto getTable = reinterpret_cast( + GET_FUNCTION_PTR( driver->handle, "zesGetDeviceProcAddrTable") ); + if(!getTable) + return driver->initStatus; + auto getTableResult = getTable( loader::context->ddi_init_version, &driver->dditable.zes.Device); + if(getTableResult == ZE_RESULT_SUCCESS) { + loader::context->configured_version = loader::context->ddi_init_version; + } else + driver->initStatus = getTableResult; + return result; +} +/////////////////////////////////////////////////////////////////////////////// +/// @brief Exported function for filling application's DeviceExp table +/// with current process' addresses +/// +/// @returns +/// - ::ZE_RESULT_SUCCESS +/// - ::ZE_RESULT_ERROR_UNINITIALIZED +/// - ::ZE_RESULT_ERROR_INVALID_NULL_POINTER +/// - ::ZE_RESULT_ERROR_UNSUPPORTED_VERSION +__zedlllocal ze_result_t ZE_APICALL +zesGetDeviceExpProcAddrTableFromDriver(loader::driver_t *driver) +{ + ze_result_t result = ZE_RESULT_SUCCESS; + if(driver->initStatus != ZE_RESULT_SUCCESS) + return driver->initStatus; + auto getTable = reinterpret_cast( + GET_FUNCTION_PTR( driver->handle, "zesGetDeviceExpProcAddrTable") ); + if(!getTable) + return driver->initStatus; + result = getTable( loader::context->ddi_init_version, &driver->dditable.zes.DeviceExp); + return result; +} +/////////////////////////////////////////////////////////////////////////////// +/// @brief Exported function for filling application's Driver table +/// with current process' addresses +/// +/// @returns +/// - ::ZE_RESULT_SUCCESS +/// - ::ZE_RESULT_ERROR_UNINITIALIZED +/// - ::ZE_RESULT_ERROR_INVALID_NULL_POINTER +/// - ::ZE_RESULT_ERROR_UNSUPPORTED_VERSION +__zedlllocal ze_result_t ZE_APICALL +zesGetDriverProcAddrTableFromDriver(loader::driver_t *driver) +{ + ze_result_t result = ZE_RESULT_SUCCESS; + if(driver->initStatus != ZE_RESULT_SUCCESS) + return driver->initStatus; + auto getTable = reinterpret_cast( + GET_FUNCTION_PTR( driver->handle, "zesGetDriverProcAddrTable") ); + if(!getTable) + return driver->initStatus; + auto getTableResult = getTable( loader::context->ddi_init_version, &driver->dditable.zes.Driver); + if(getTableResult == ZE_RESULT_SUCCESS) { + loader::context->configured_version = loader::context->ddi_init_version; + } else + driver->initStatus = getTableResult; + return result; +} +/////////////////////////////////////////////////////////////////////////////// +/// @brief Exported function for filling application's DriverExp table +/// with current process' addresses +/// +/// @returns +/// - ::ZE_RESULT_SUCCESS +/// - ::ZE_RESULT_ERROR_UNINITIALIZED +/// - ::ZE_RESULT_ERROR_INVALID_NULL_POINTER +/// - ::ZE_RESULT_ERROR_UNSUPPORTED_VERSION +__zedlllocal ze_result_t ZE_APICALL +zesGetDriverExpProcAddrTableFromDriver(loader::driver_t *driver) +{ + ze_result_t result = ZE_RESULT_SUCCESS; + if(driver->initStatus != ZE_RESULT_SUCCESS) + return driver->initStatus; + auto getTable = reinterpret_cast( + GET_FUNCTION_PTR( driver->handle, "zesGetDriverExpProcAddrTable") ); + if(!getTable) + return driver->initStatus; + result = getTable( loader::context->ddi_init_version, &driver->dditable.zes.DriverExp); + return result; +} +/////////////////////////////////////////////////////////////////////////////// +/// @brief Exported function for filling application's Diagnostics table +/// with current process' addresses +/// +/// @returns +/// - ::ZE_RESULT_SUCCESS +/// - ::ZE_RESULT_ERROR_UNINITIALIZED +/// - ::ZE_RESULT_ERROR_INVALID_NULL_POINTER +/// - ::ZE_RESULT_ERROR_UNSUPPORTED_VERSION +__zedlllocal ze_result_t ZE_APICALL +zesGetDiagnosticsProcAddrTableFromDriver(loader::driver_t *driver) +{ + ze_result_t result = ZE_RESULT_SUCCESS; + if(driver->initStatus != ZE_RESULT_SUCCESS) + return driver->initStatus; + auto getTable = reinterpret_cast( + GET_FUNCTION_PTR( driver->handle, "zesGetDiagnosticsProcAddrTable") ); + if(!getTable) + return driver->initStatus; + auto getTableResult = getTable( loader::context->ddi_init_version, &driver->dditable.zes.Diagnostics); + if(getTableResult == ZE_RESULT_SUCCESS) { + loader::context->configured_version = loader::context->ddi_init_version; + } else + driver->initStatus = getTableResult; + return result; +} +/////////////////////////////////////////////////////////////////////////////// +/// @brief Exported function for filling application's Engine table +/// with current process' addresses +/// +/// @returns +/// - ::ZE_RESULT_SUCCESS +/// - ::ZE_RESULT_ERROR_UNINITIALIZED +/// - ::ZE_RESULT_ERROR_INVALID_NULL_POINTER +/// - ::ZE_RESULT_ERROR_UNSUPPORTED_VERSION +__zedlllocal ze_result_t ZE_APICALL +zesGetEngineProcAddrTableFromDriver(loader::driver_t *driver) +{ + ze_result_t result = ZE_RESULT_SUCCESS; + if(driver->initStatus != ZE_RESULT_SUCCESS) + return driver->initStatus; + auto getTable = reinterpret_cast( + GET_FUNCTION_PTR( driver->handle, "zesGetEngineProcAddrTable") ); + if(!getTable) + return driver->initStatus; + auto getTableResult = getTable( loader::context->ddi_init_version, &driver->dditable.zes.Engine); + if(getTableResult == ZE_RESULT_SUCCESS) { + loader::context->configured_version = loader::context->ddi_init_version; + } else + driver->initStatus = getTableResult; + return result; +} +/////////////////////////////////////////////////////////////////////////////// +/// @brief Exported function for filling application's FabricPort table +/// with current process' addresses +/// +/// @returns +/// - ::ZE_RESULT_SUCCESS +/// - ::ZE_RESULT_ERROR_UNINITIALIZED +/// - ::ZE_RESULT_ERROR_INVALID_NULL_POINTER +/// - ::ZE_RESULT_ERROR_UNSUPPORTED_VERSION +__zedlllocal ze_result_t ZE_APICALL +zesGetFabricPortProcAddrTableFromDriver(loader::driver_t *driver) +{ + ze_result_t result = ZE_RESULT_SUCCESS; + if(driver->initStatus != ZE_RESULT_SUCCESS) + return driver->initStatus; + auto getTable = reinterpret_cast( + GET_FUNCTION_PTR( driver->handle, "zesGetFabricPortProcAddrTable") ); + if(!getTable) + return driver->initStatus; + auto getTableResult = getTable( loader::context->ddi_init_version, &driver->dditable.zes.FabricPort); + if(getTableResult == ZE_RESULT_SUCCESS) { + loader::context->configured_version = loader::context->ddi_init_version; + } else + driver->initStatus = getTableResult; + return result; +} +/////////////////////////////////////////////////////////////////////////////// +/// @brief Exported function for filling application's Fan table +/// with current process' addresses +/// +/// @returns +/// - ::ZE_RESULT_SUCCESS +/// - ::ZE_RESULT_ERROR_UNINITIALIZED +/// - ::ZE_RESULT_ERROR_INVALID_NULL_POINTER +/// - ::ZE_RESULT_ERROR_UNSUPPORTED_VERSION +__zedlllocal ze_result_t ZE_APICALL +zesGetFanProcAddrTableFromDriver(loader::driver_t *driver) +{ + ze_result_t result = ZE_RESULT_SUCCESS; + if(driver->initStatus != ZE_RESULT_SUCCESS) + return driver->initStatus; + auto getTable = reinterpret_cast( + GET_FUNCTION_PTR( driver->handle, "zesGetFanProcAddrTable") ); + if(!getTable) + return driver->initStatus; + auto getTableResult = getTable( loader::context->ddi_init_version, &driver->dditable.zes.Fan); + if(getTableResult == ZE_RESULT_SUCCESS) { + loader::context->configured_version = loader::context->ddi_init_version; + } else + driver->initStatus = getTableResult; + return result; +} +/////////////////////////////////////////////////////////////////////////////// +/// @brief Exported function for filling application's Firmware table +/// with current process' addresses +/// +/// @returns +/// - ::ZE_RESULT_SUCCESS +/// - ::ZE_RESULT_ERROR_UNINITIALIZED +/// - ::ZE_RESULT_ERROR_INVALID_NULL_POINTER +/// - ::ZE_RESULT_ERROR_UNSUPPORTED_VERSION +__zedlllocal ze_result_t ZE_APICALL +zesGetFirmwareProcAddrTableFromDriver(loader::driver_t *driver) +{ + ze_result_t result = ZE_RESULT_SUCCESS; + if(driver->initStatus != ZE_RESULT_SUCCESS) + return driver->initStatus; + auto getTable = reinterpret_cast( + GET_FUNCTION_PTR( driver->handle, "zesGetFirmwareProcAddrTable") ); + if(!getTable) + return driver->initStatus; + auto getTableResult = getTable( loader::context->ddi_init_version, &driver->dditable.zes.Firmware); + if(getTableResult == ZE_RESULT_SUCCESS) { + loader::context->configured_version = loader::context->ddi_init_version; + } else + driver->initStatus = getTableResult; + return result; +} +/////////////////////////////////////////////////////////////////////////////// +/// @brief Exported function for filling application's FirmwareExp table +/// with current process' addresses +/// +/// @returns +/// - ::ZE_RESULT_SUCCESS +/// - ::ZE_RESULT_ERROR_UNINITIALIZED +/// - ::ZE_RESULT_ERROR_INVALID_NULL_POINTER +/// - ::ZE_RESULT_ERROR_UNSUPPORTED_VERSION +__zedlllocal ze_result_t ZE_APICALL +zesGetFirmwareExpProcAddrTableFromDriver(loader::driver_t *driver) +{ + ze_result_t result = ZE_RESULT_SUCCESS; + if(driver->initStatus != ZE_RESULT_SUCCESS) + return driver->initStatus; + auto getTable = reinterpret_cast( + GET_FUNCTION_PTR( driver->handle, "zesGetFirmwareExpProcAddrTable") ); + if(!getTable) + return driver->initStatus; + result = getTable( loader::context->ddi_init_version, &driver->dditable.zes.FirmwareExp); + return result; +} +/////////////////////////////////////////////////////////////////////////////// +/// @brief Exported function for filling application's Frequency table +/// with current process' addresses +/// +/// @returns +/// - ::ZE_RESULT_SUCCESS +/// - ::ZE_RESULT_ERROR_UNINITIALIZED +/// - ::ZE_RESULT_ERROR_INVALID_NULL_POINTER +/// - ::ZE_RESULT_ERROR_UNSUPPORTED_VERSION +__zedlllocal ze_result_t ZE_APICALL +zesGetFrequencyProcAddrTableFromDriver(loader::driver_t *driver) +{ + ze_result_t result = ZE_RESULT_SUCCESS; + if(driver->initStatus != ZE_RESULT_SUCCESS) + return driver->initStatus; + auto getTable = reinterpret_cast( + GET_FUNCTION_PTR( driver->handle, "zesGetFrequencyProcAddrTable") ); + if(!getTable) + return driver->initStatus; + auto getTableResult = getTable( loader::context->ddi_init_version, &driver->dditable.zes.Frequency); + if(getTableResult == ZE_RESULT_SUCCESS) { + loader::context->configured_version = loader::context->ddi_init_version; + } else + driver->initStatus = getTableResult; + return result; +} +/////////////////////////////////////////////////////////////////////////////// +/// @brief Exported function for filling application's Led table +/// with current process' addresses +/// +/// @returns +/// - ::ZE_RESULT_SUCCESS +/// - ::ZE_RESULT_ERROR_UNINITIALIZED +/// - ::ZE_RESULT_ERROR_INVALID_NULL_POINTER +/// - ::ZE_RESULT_ERROR_UNSUPPORTED_VERSION +__zedlllocal ze_result_t ZE_APICALL +zesGetLedProcAddrTableFromDriver(loader::driver_t *driver) +{ + ze_result_t result = ZE_RESULT_SUCCESS; + if(driver->initStatus != ZE_RESULT_SUCCESS) + return driver->initStatus; + auto getTable = reinterpret_cast( + GET_FUNCTION_PTR( driver->handle, "zesGetLedProcAddrTable") ); + if(!getTable) + return driver->initStatus; + auto getTableResult = getTable( loader::context->ddi_init_version, &driver->dditable.zes.Led); + if(getTableResult == ZE_RESULT_SUCCESS) { + loader::context->configured_version = loader::context->ddi_init_version; + } else + driver->initStatus = getTableResult; + return result; +} +/////////////////////////////////////////////////////////////////////////////// +/// @brief Exported function for filling application's Memory table +/// with current process' addresses +/// +/// @returns +/// - ::ZE_RESULT_SUCCESS +/// - ::ZE_RESULT_ERROR_UNINITIALIZED +/// - ::ZE_RESULT_ERROR_INVALID_NULL_POINTER +/// - ::ZE_RESULT_ERROR_UNSUPPORTED_VERSION +__zedlllocal ze_result_t ZE_APICALL +zesGetMemoryProcAddrTableFromDriver(loader::driver_t *driver) +{ + ze_result_t result = ZE_RESULT_SUCCESS; + if(driver->initStatus != ZE_RESULT_SUCCESS) + return driver->initStatus; + auto getTable = reinterpret_cast( + GET_FUNCTION_PTR( driver->handle, "zesGetMemoryProcAddrTable") ); + if(!getTable) + return driver->initStatus; + auto getTableResult = getTable( loader::context->ddi_init_version, &driver->dditable.zes.Memory); + if(getTableResult == ZE_RESULT_SUCCESS) { + loader::context->configured_version = loader::context->ddi_init_version; + } else + driver->initStatus = getTableResult; + return result; +} +/////////////////////////////////////////////////////////////////////////////// +/// @brief Exported function for filling application's Overclock table +/// with current process' addresses +/// +/// @returns +/// - ::ZE_RESULT_SUCCESS +/// - ::ZE_RESULT_ERROR_UNINITIALIZED +/// - ::ZE_RESULT_ERROR_INVALID_NULL_POINTER +/// - ::ZE_RESULT_ERROR_UNSUPPORTED_VERSION +__zedlllocal ze_result_t ZE_APICALL +zesGetOverclockProcAddrTableFromDriver(loader::driver_t *driver) +{ + ze_result_t result = ZE_RESULT_SUCCESS; + if(driver->initStatus != ZE_RESULT_SUCCESS) + return driver->initStatus; + auto getTable = reinterpret_cast( + GET_FUNCTION_PTR( driver->handle, "zesGetOverclockProcAddrTable") ); + if(!getTable) + { + //It is valid to not have this proc addr table + return ZE_RESULT_SUCCESS; + } + auto getTableResult = getTable( loader::context->ddi_init_version, &driver->dditable.zes.Overclock); + if(getTableResult == ZE_RESULT_SUCCESS) { + loader::context->configured_version = loader::context->ddi_init_version; + } else + driver->initStatus = getTableResult; + return result; +} +/////////////////////////////////////////////////////////////////////////////// +/// @brief Exported function for filling application's PerformanceFactor table +/// with current process' addresses +/// +/// @returns +/// - ::ZE_RESULT_SUCCESS +/// - ::ZE_RESULT_ERROR_UNINITIALIZED +/// - ::ZE_RESULT_ERROR_INVALID_NULL_POINTER +/// - ::ZE_RESULT_ERROR_UNSUPPORTED_VERSION +__zedlllocal ze_result_t ZE_APICALL +zesGetPerformanceFactorProcAddrTableFromDriver(loader::driver_t *driver) +{ + ze_result_t result = ZE_RESULT_SUCCESS; + if(driver->initStatus != ZE_RESULT_SUCCESS) + return driver->initStatus; + auto getTable = reinterpret_cast( + GET_FUNCTION_PTR( driver->handle, "zesGetPerformanceFactorProcAddrTable") ); + if(!getTable) + return driver->initStatus; + auto getTableResult = getTable( loader::context->ddi_init_version, &driver->dditable.zes.PerformanceFactor); + if(getTableResult == ZE_RESULT_SUCCESS) { + loader::context->configured_version = loader::context->ddi_init_version; + } else + driver->initStatus = getTableResult; + return result; +} +/////////////////////////////////////////////////////////////////////////////// +/// @brief Exported function for filling application's Power table +/// with current process' addresses +/// +/// @returns +/// - ::ZE_RESULT_SUCCESS +/// - ::ZE_RESULT_ERROR_UNINITIALIZED +/// - ::ZE_RESULT_ERROR_INVALID_NULL_POINTER +/// - ::ZE_RESULT_ERROR_UNSUPPORTED_VERSION +__zedlllocal ze_result_t ZE_APICALL +zesGetPowerProcAddrTableFromDriver(loader::driver_t *driver) +{ + ze_result_t result = ZE_RESULT_SUCCESS; + if(driver->initStatus != ZE_RESULT_SUCCESS) + return driver->initStatus; + auto getTable = reinterpret_cast( + GET_FUNCTION_PTR( driver->handle, "zesGetPowerProcAddrTable") ); + if(!getTable) + return driver->initStatus; + auto getTableResult = getTable( loader::context->ddi_init_version, &driver->dditable.zes.Power); + if(getTableResult == ZE_RESULT_SUCCESS) { + loader::context->configured_version = loader::context->ddi_init_version; + } else + driver->initStatus = getTableResult; + return result; +} +/////////////////////////////////////////////////////////////////////////////// +/// @brief Exported function for filling application's Psu table +/// with current process' addresses +/// +/// @returns +/// - ::ZE_RESULT_SUCCESS +/// - ::ZE_RESULT_ERROR_UNINITIALIZED +/// - ::ZE_RESULT_ERROR_INVALID_NULL_POINTER +/// - ::ZE_RESULT_ERROR_UNSUPPORTED_VERSION +__zedlllocal ze_result_t ZE_APICALL +zesGetPsuProcAddrTableFromDriver(loader::driver_t *driver) +{ + ze_result_t result = ZE_RESULT_SUCCESS; + if(driver->initStatus != ZE_RESULT_SUCCESS) + return driver->initStatus; + auto getTable = reinterpret_cast( + GET_FUNCTION_PTR( driver->handle, "zesGetPsuProcAddrTable") ); + if(!getTable) + return driver->initStatus; + auto getTableResult = getTable( loader::context->ddi_init_version, &driver->dditable.zes.Psu); + if(getTableResult == ZE_RESULT_SUCCESS) { + loader::context->configured_version = loader::context->ddi_init_version; + } else + driver->initStatus = getTableResult; + return result; +} +/////////////////////////////////////////////////////////////////////////////// +/// @brief Exported function for filling application's Ras table +/// with current process' addresses +/// +/// @returns +/// - ::ZE_RESULT_SUCCESS +/// - ::ZE_RESULT_ERROR_UNINITIALIZED +/// - ::ZE_RESULT_ERROR_INVALID_NULL_POINTER +/// - ::ZE_RESULT_ERROR_UNSUPPORTED_VERSION +__zedlllocal ze_result_t ZE_APICALL +zesGetRasProcAddrTableFromDriver(loader::driver_t *driver) +{ + ze_result_t result = ZE_RESULT_SUCCESS; + if(driver->initStatus != ZE_RESULT_SUCCESS) + return driver->initStatus; + auto getTable = reinterpret_cast( + GET_FUNCTION_PTR( driver->handle, "zesGetRasProcAddrTable") ); + if(!getTable) + return driver->initStatus; + auto getTableResult = getTable( loader::context->ddi_init_version, &driver->dditable.zes.Ras); + if(getTableResult == ZE_RESULT_SUCCESS) { + loader::context->configured_version = loader::context->ddi_init_version; + } else + driver->initStatus = getTableResult; + return result; +} +/////////////////////////////////////////////////////////////////////////////// +/// @brief Exported function for filling application's RasExp table +/// with current process' addresses +/// +/// @returns +/// - ::ZE_RESULT_SUCCESS +/// - ::ZE_RESULT_ERROR_UNINITIALIZED +/// - ::ZE_RESULT_ERROR_INVALID_NULL_POINTER +/// - ::ZE_RESULT_ERROR_UNSUPPORTED_VERSION +__zedlllocal ze_result_t ZE_APICALL +zesGetRasExpProcAddrTableFromDriver(loader::driver_t *driver) +{ + ze_result_t result = ZE_RESULT_SUCCESS; + if(driver->initStatus != ZE_RESULT_SUCCESS) + return driver->initStatus; + auto getTable = reinterpret_cast( + GET_FUNCTION_PTR( driver->handle, "zesGetRasExpProcAddrTable") ); + if(!getTable) + return driver->initStatus; + result = getTable( loader::context->ddi_init_version, &driver->dditable.zes.RasExp); + return result; +} +/////////////////////////////////////////////////////////////////////////////// +/// @brief Exported function for filling application's Scheduler table +/// with current process' addresses +/// +/// @returns +/// - ::ZE_RESULT_SUCCESS +/// - ::ZE_RESULT_ERROR_UNINITIALIZED +/// - ::ZE_RESULT_ERROR_INVALID_NULL_POINTER +/// - ::ZE_RESULT_ERROR_UNSUPPORTED_VERSION +__zedlllocal ze_result_t ZE_APICALL +zesGetSchedulerProcAddrTableFromDriver(loader::driver_t *driver) +{ + ze_result_t result = ZE_RESULT_SUCCESS; + if(driver->initStatus != ZE_RESULT_SUCCESS) + return driver->initStatus; + auto getTable = reinterpret_cast( + GET_FUNCTION_PTR( driver->handle, "zesGetSchedulerProcAddrTable") ); + if(!getTable) + return driver->initStatus; + auto getTableResult = getTable( loader::context->ddi_init_version, &driver->dditable.zes.Scheduler); + if(getTableResult == ZE_RESULT_SUCCESS) { + loader::context->configured_version = loader::context->ddi_init_version; + } else + driver->initStatus = getTableResult; + return result; +} +/////////////////////////////////////////////////////////////////////////////// +/// @brief Exported function for filling application's Standby table +/// with current process' addresses +/// +/// @returns +/// - ::ZE_RESULT_SUCCESS +/// - ::ZE_RESULT_ERROR_UNINITIALIZED +/// - ::ZE_RESULT_ERROR_INVALID_NULL_POINTER +/// - ::ZE_RESULT_ERROR_UNSUPPORTED_VERSION +__zedlllocal ze_result_t ZE_APICALL +zesGetStandbyProcAddrTableFromDriver(loader::driver_t *driver) +{ + ze_result_t result = ZE_RESULT_SUCCESS; + if(driver->initStatus != ZE_RESULT_SUCCESS) + return driver->initStatus; + auto getTable = reinterpret_cast( + GET_FUNCTION_PTR( driver->handle, "zesGetStandbyProcAddrTable") ); + if(!getTable) + return driver->initStatus; + auto getTableResult = getTable( loader::context->ddi_init_version, &driver->dditable.zes.Standby); + if(getTableResult == ZE_RESULT_SUCCESS) { + loader::context->configured_version = loader::context->ddi_init_version; + } else + driver->initStatus = getTableResult; + return result; +} +/////////////////////////////////////////////////////////////////////////////// +/// @brief Exported function for filling application's Temperature table +/// with current process' addresses +/// +/// @returns +/// - ::ZE_RESULT_SUCCESS +/// - ::ZE_RESULT_ERROR_UNINITIALIZED +/// - ::ZE_RESULT_ERROR_INVALID_NULL_POINTER +/// - ::ZE_RESULT_ERROR_UNSUPPORTED_VERSION +__zedlllocal ze_result_t ZE_APICALL +zesGetTemperatureProcAddrTableFromDriver(loader::driver_t *driver) +{ + ze_result_t result = ZE_RESULT_SUCCESS; + if(driver->initStatus != ZE_RESULT_SUCCESS) + return driver->initStatus; + auto getTable = reinterpret_cast( + GET_FUNCTION_PTR( driver->handle, "zesGetTemperatureProcAddrTable") ); + if(!getTable) + return driver->initStatus; + auto getTableResult = getTable( loader::context->ddi_init_version, &driver->dditable.zes.Temperature); + if(getTableResult == ZE_RESULT_SUCCESS) { + loader::context->configured_version = loader::context->ddi_init_version; + } else + driver->initStatus = getTableResult; + return result; +} +/////////////////////////////////////////////////////////////////////////////// +/// @brief Exported function for filling application's VFManagementExp table +/// with current process' addresses +/// +/// @returns +/// - ::ZE_RESULT_SUCCESS +/// - ::ZE_RESULT_ERROR_UNINITIALIZED +/// - ::ZE_RESULT_ERROR_INVALID_NULL_POINTER +/// - ::ZE_RESULT_ERROR_UNSUPPORTED_VERSION +__zedlllocal ze_result_t ZE_APICALL +zesGetVFManagementExpProcAddrTableFromDriver(loader::driver_t *driver) +{ + ze_result_t result = ZE_RESULT_SUCCESS; + if(driver->initStatus != ZE_RESULT_SUCCESS) + return driver->initStatus; + auto getTable = reinterpret_cast( + GET_FUNCTION_PTR( driver->handle, "zesGetVFManagementExpProcAddrTable") ); + if(!getTable) + return driver->initStatus; + result = getTable( loader::context->ddi_init_version, &driver->dditable.zes.VFManagementExp); + return result; +} /////////////////////////////////////////////////////////////////////////////// /// @brief Exported function for filling application's Global table /// with current process' addresses @@ -4954,38 +5672,13 @@ zesGetGlobalProcAddrTable( if( loader::context->version < version ) return ZE_RESULT_ERROR_UNSUPPORTED_VERSION; - ze_result_t result = ZE_RESULT_SUCCESS; + loader::context->ddi_init_version = version; - bool atLeastOneDriverValid = false; - // Load the device-driver DDI tables - for( auto& drv : *loader::context->sysmanInstanceDrivers ) - { - if(drv.initStatus != ZE_RESULT_SUCCESS) - continue; - auto getTable = reinterpret_cast( - GET_FUNCTION_PTR( drv.handle, "zesGetGlobalProcAddrTable") ); - if(!getTable) - { - atLeastOneDriverValid = true; - //It is valid to not have this proc addr table - continue; - } - auto getTableResult = getTable( version, &drv.dditable.zes.Global); - if(getTableResult == ZE_RESULT_SUCCESS) { - atLeastOneDriverValid = true; - loader::context->configured_version = version; - } else - drv.initStatus = getTableResult; - } - - if(!atLeastOneDriverValid) - result = ZE_RESULT_ERROR_UNINITIALIZED; - else - result = ZE_RESULT_SUCCESS; + ze_result_t result = ZE_RESULT_SUCCESS; if( ZE_RESULT_SUCCESS == result ) { - if( ( loader::context->sysmanInstanceDrivers->size() > 1 ) || loader::context->forceIntercept ) + if( true ) { // return pointers to loader's DDIs loader::loaderDispatch->pSysman->Global = new zes_global_dditable_t; @@ -5039,30 +5732,9 @@ zesGetDeviceProcAddrTable( if( loader::context->version < version ) return ZE_RESULT_ERROR_UNSUPPORTED_VERSION; - ze_result_t result = ZE_RESULT_SUCCESS; + loader::context->ddi_init_version = version; - bool atLeastOneDriverValid = false; - // Load the device-driver DDI tables - for( auto& drv : *loader::context->sysmanInstanceDrivers ) - { - if(drv.initStatus != ZE_RESULT_SUCCESS) - continue; - auto getTable = reinterpret_cast( - GET_FUNCTION_PTR( drv.handle, "zesGetDeviceProcAddrTable") ); - if(!getTable) - continue; - auto getTableResult = getTable( version, &drv.dditable.zes.Device); - if(getTableResult == ZE_RESULT_SUCCESS) { - atLeastOneDriverValid = true; - loader::context->configured_version = version; - } else - drv.initStatus = getTableResult; - } - - if(!atLeastOneDriverValid) - result = ZE_RESULT_ERROR_UNINITIALIZED; - else - result = ZE_RESULT_SUCCESS; + ze_result_t result = ZE_RESULT_SUCCESS; if( ZE_RESULT_SUCCESS == result ) { @@ -5376,20 +6048,9 @@ zesGetDeviceExpProcAddrTable( if( loader::context->version < version ) return ZE_RESULT_ERROR_UNSUPPORTED_VERSION; - ze_result_t result = ZE_RESULT_SUCCESS; - - // Load the device-driver DDI tables - for( auto& drv : *loader::context->sysmanInstanceDrivers ) - { - if(drv.initStatus != ZE_RESULT_SUCCESS) - continue; - auto getTable = reinterpret_cast( - GET_FUNCTION_PTR( drv.handle, "zesGetDeviceExpProcAddrTable") ); - if(!getTable) - continue; - result = getTable( version, &drv.dditable.zes.DeviceExp); - } + loader::context->ddi_init_version = version; + ze_result_t result = ZE_RESULT_SUCCESS; if( ZE_RESULT_SUCCESS == result ) { @@ -5465,30 +6126,9 @@ zesGetDriverProcAddrTable( if( loader::context->version < version ) return ZE_RESULT_ERROR_UNSUPPORTED_VERSION; - ze_result_t result = ZE_RESULT_SUCCESS; + loader::context->ddi_init_version = version; - bool atLeastOneDriverValid = false; - // Load the device-driver DDI tables - for( auto& drv : *loader::context->sysmanInstanceDrivers ) - { - if(drv.initStatus != ZE_RESULT_SUCCESS) - continue; - auto getTable = reinterpret_cast( - GET_FUNCTION_PTR( drv.handle, "zesGetDriverProcAddrTable") ); - if(!getTable) - continue; - auto getTableResult = getTable( version, &drv.dditable.zes.Driver); - if(getTableResult == ZE_RESULT_SUCCESS) { - atLeastOneDriverValid = true; - loader::context->configured_version = version; - } else - drv.initStatus = getTableResult; - } - - if(!atLeastOneDriverValid) - result = ZE_RESULT_ERROR_UNINITIALIZED; - else - result = ZE_RESULT_SUCCESS; + ze_result_t result = ZE_RESULT_SUCCESS; if( ZE_RESULT_SUCCESS == result ) { @@ -5574,20 +6214,9 @@ zesGetDriverExpProcAddrTable( if( loader::context->version < version ) return ZE_RESULT_ERROR_UNSUPPORTED_VERSION; - ze_result_t result = ZE_RESULT_SUCCESS; - - // Load the device-driver DDI tables - for( auto& drv : *loader::context->sysmanInstanceDrivers ) - { - if(drv.initStatus != ZE_RESULT_SUCCESS) - continue; - auto getTable = reinterpret_cast( - GET_FUNCTION_PTR( drv.handle, "zesGetDriverExpProcAddrTable") ); - if(!getTable) - continue; - result = getTable( version, &drv.dditable.zes.DriverExp); - } + loader::context->ddi_init_version = version; + ze_result_t result = ZE_RESULT_SUCCESS; if( ZE_RESULT_SUCCESS == result ) { @@ -5649,30 +6278,9 @@ zesGetDiagnosticsProcAddrTable( if( loader::context->version < version ) return ZE_RESULT_ERROR_UNSUPPORTED_VERSION; - ze_result_t result = ZE_RESULT_SUCCESS; + loader::context->ddi_init_version = version; - bool atLeastOneDriverValid = false; - // Load the device-driver DDI tables - for( auto& drv : *loader::context->sysmanInstanceDrivers ) - { - if(drv.initStatus != ZE_RESULT_SUCCESS) - continue; - auto getTable = reinterpret_cast( - GET_FUNCTION_PTR( drv.handle, "zesGetDiagnosticsProcAddrTable") ); - if(!getTable) - continue; - auto getTableResult = getTable( version, &drv.dditable.zes.Diagnostics); - if(getTableResult == ZE_RESULT_SUCCESS) { - atLeastOneDriverValid = true; - loader::context->configured_version = version; - } else - drv.initStatus = getTableResult; - } - - if(!atLeastOneDriverValid) - result = ZE_RESULT_ERROR_UNINITIALIZED; - else - result = ZE_RESULT_SUCCESS; + ze_result_t result = ZE_RESULT_SUCCESS; if( ZE_RESULT_SUCCESS == result ) { @@ -5748,30 +6356,9 @@ zesGetEngineProcAddrTable( if( loader::context->version < version ) return ZE_RESULT_ERROR_UNSUPPORTED_VERSION; - ze_result_t result = ZE_RESULT_SUCCESS; + loader::context->ddi_init_version = version; - bool atLeastOneDriverValid = false; - // Load the device-driver DDI tables - for( auto& drv : *loader::context->sysmanInstanceDrivers ) - { - if(drv.initStatus != ZE_RESULT_SUCCESS) - continue; - auto getTable = reinterpret_cast( - GET_FUNCTION_PTR( drv.handle, "zesGetEngineProcAddrTable") ); - if(!getTable) - continue; - auto getTableResult = getTable( version, &drv.dditable.zes.Engine); - if(getTableResult == ZE_RESULT_SUCCESS) { - atLeastOneDriverValid = true; - loader::context->configured_version = version; - } else - drv.initStatus = getTableResult; - } - - if(!atLeastOneDriverValid) - result = ZE_RESULT_ERROR_UNINITIALIZED; - else - result = ZE_RESULT_SUCCESS; + ze_result_t result = ZE_RESULT_SUCCESS; if( ZE_RESULT_SUCCESS == result ) { @@ -5847,30 +6434,9 @@ zesGetFabricPortProcAddrTable( if( loader::context->version < version ) return ZE_RESULT_ERROR_UNSUPPORTED_VERSION; - ze_result_t result = ZE_RESULT_SUCCESS; + loader::context->ddi_init_version = version; - bool atLeastOneDriverValid = false; - // Load the device-driver DDI tables - for( auto& drv : *loader::context->sysmanInstanceDrivers ) - { - if(drv.initStatus != ZE_RESULT_SUCCESS) - continue; - auto getTable = reinterpret_cast( - GET_FUNCTION_PTR( drv.handle, "zesGetFabricPortProcAddrTable") ); - if(!getTable) - continue; - auto getTableResult = getTable( version, &drv.dditable.zes.FabricPort); - if(getTableResult == ZE_RESULT_SUCCESS) { - atLeastOneDriverValid = true; - loader::context->configured_version = version; - } else - drv.initStatus = getTableResult; - } - - if(!atLeastOneDriverValid) - result = ZE_RESULT_ERROR_UNINITIALIZED; - else - result = ZE_RESULT_SUCCESS; + ze_result_t result = ZE_RESULT_SUCCESS; if( ZE_RESULT_SUCCESS == result ) { @@ -5981,30 +6547,9 @@ zesGetFanProcAddrTable( if( loader::context->version < version ) return ZE_RESULT_ERROR_UNSUPPORTED_VERSION; - ze_result_t result = ZE_RESULT_SUCCESS; + loader::context->ddi_init_version = version; - bool atLeastOneDriverValid = false; - // Load the device-driver DDI tables - for( auto& drv : *loader::context->sysmanInstanceDrivers ) - { - if(drv.initStatus != ZE_RESULT_SUCCESS) - continue; - auto getTable = reinterpret_cast( - GET_FUNCTION_PTR( drv.handle, "zesGetFanProcAddrTable") ); - if(!getTable) - continue; - auto getTableResult = getTable( version, &drv.dditable.zes.Fan); - if(getTableResult == ZE_RESULT_SUCCESS) { - atLeastOneDriverValid = true; - loader::context->configured_version = version; - } else - drv.initStatus = getTableResult; - } - - if(!atLeastOneDriverValid) - result = ZE_RESULT_ERROR_UNINITIALIZED; - else - result = ZE_RESULT_SUCCESS; + ze_result_t result = ZE_RESULT_SUCCESS; if( ZE_RESULT_SUCCESS == result ) { @@ -6101,30 +6646,9 @@ zesGetFirmwareProcAddrTable( if( loader::context->version < version ) return ZE_RESULT_ERROR_UNSUPPORTED_VERSION; - ze_result_t result = ZE_RESULT_SUCCESS; + loader::context->ddi_init_version = version; - bool atLeastOneDriverValid = false; - // Load the device-driver DDI tables - for( auto& drv : *loader::context->sysmanInstanceDrivers ) - { - if(drv.initStatus != ZE_RESULT_SUCCESS) - continue; - auto getTable = reinterpret_cast( - GET_FUNCTION_PTR( drv.handle, "zesGetFirmwareProcAddrTable") ); - if(!getTable) - continue; - auto getTableResult = getTable( version, &drv.dditable.zes.Firmware); - if(getTableResult == ZE_RESULT_SUCCESS) { - atLeastOneDriverValid = true; - loader::context->configured_version = version; - } else - drv.initStatus = getTableResult; - } - - if(!atLeastOneDriverValid) - result = ZE_RESULT_ERROR_UNINITIALIZED; - else - result = ZE_RESULT_SUCCESS; + ze_result_t result = ZE_RESULT_SUCCESS; if( ZE_RESULT_SUCCESS == result ) { @@ -6207,20 +6731,9 @@ zesGetFirmwareExpProcAddrTable( if( loader::context->version < version ) return ZE_RESULT_ERROR_UNSUPPORTED_VERSION; - ze_result_t result = ZE_RESULT_SUCCESS; - - // Load the device-driver DDI tables - for( auto& drv : *loader::context->sysmanInstanceDrivers ) - { - if(drv.initStatus != ZE_RESULT_SUCCESS) - continue; - auto getTable = reinterpret_cast( - GET_FUNCTION_PTR( drv.handle, "zesGetFirmwareExpProcAddrTable") ); - if(!getTable) - continue; - result = getTable( version, &drv.dditable.zes.FirmwareExp); - } + loader::context->ddi_init_version = version; + ze_result_t result = ZE_RESULT_SUCCESS; if( ZE_RESULT_SUCCESS == result ) { @@ -6289,30 +6802,9 @@ zesGetFrequencyProcAddrTable( if( loader::context->version < version ) return ZE_RESULT_ERROR_UNSUPPORTED_VERSION; - ze_result_t result = ZE_RESULT_SUCCESS; + loader::context->ddi_init_version = version; - bool atLeastOneDriverValid = false; - // Load the device-driver DDI tables - for( auto& drv : *loader::context->sysmanInstanceDrivers ) - { - if(drv.initStatus != ZE_RESULT_SUCCESS) - continue; - auto getTable = reinterpret_cast( - GET_FUNCTION_PTR( drv.handle, "zesGetFrequencyProcAddrTable") ); - if(!getTable) - continue; - auto getTableResult = getTable( version, &drv.dditable.zes.Frequency); - if(getTableResult == ZE_RESULT_SUCCESS) { - atLeastOneDriverValid = true; - loader::context->configured_version = version; - } else - drv.initStatus = getTableResult; - } - - if(!atLeastOneDriverValid) - result = ZE_RESULT_ERROR_UNINITIALIZED; - else - result = ZE_RESULT_SUCCESS; + ze_result_t result = ZE_RESULT_SUCCESS; if( ZE_RESULT_SUCCESS == result ) { @@ -6486,30 +6978,9 @@ zesGetLedProcAddrTable( if( loader::context->version < version ) return ZE_RESULT_ERROR_UNSUPPORTED_VERSION; - ze_result_t result = ZE_RESULT_SUCCESS; + loader::context->ddi_init_version = version; - bool atLeastOneDriverValid = false; - // Load the device-driver DDI tables - for( auto& drv : *loader::context->sysmanInstanceDrivers ) - { - if(drv.initStatus != ZE_RESULT_SUCCESS) - continue; - auto getTable = reinterpret_cast( - GET_FUNCTION_PTR( drv.handle, "zesGetLedProcAddrTable") ); - if(!getTable) - continue; - auto getTableResult = getTable( version, &drv.dditable.zes.Led); - if(getTableResult == ZE_RESULT_SUCCESS) { - atLeastOneDriverValid = true; - loader::context->configured_version = version; - } else - drv.initStatus = getTableResult; - } - - if(!atLeastOneDriverValid) - result = ZE_RESULT_ERROR_UNINITIALIZED; - else - result = ZE_RESULT_SUCCESS; + ze_result_t result = ZE_RESULT_SUCCESS; if( ZE_RESULT_SUCCESS == result ) { @@ -6592,30 +7063,9 @@ zesGetMemoryProcAddrTable( if( loader::context->version < version ) return ZE_RESULT_ERROR_UNSUPPORTED_VERSION; - ze_result_t result = ZE_RESULT_SUCCESS; + loader::context->ddi_init_version = version; - bool atLeastOneDriverValid = false; - // Load the device-driver DDI tables - for( auto& drv : *loader::context->sysmanInstanceDrivers ) - { - if(drv.initStatus != ZE_RESULT_SUCCESS) - continue; - auto getTable = reinterpret_cast( - GET_FUNCTION_PTR( drv.handle, "zesGetMemoryProcAddrTable") ); - if(!getTable) - continue; - auto getTableResult = getTable( version, &drv.dditable.zes.Memory); - if(getTableResult == ZE_RESULT_SUCCESS) { - atLeastOneDriverValid = true; - loader::context->configured_version = version; - } else - drv.initStatus = getTableResult; - } - - if(!atLeastOneDriverValid) - result = ZE_RESULT_ERROR_UNINITIALIZED; - else - result = ZE_RESULT_SUCCESS; + ze_result_t result = ZE_RESULT_SUCCESS; if( ZE_RESULT_SUCCESS == result ) { @@ -6691,34 +7141,9 @@ zesGetOverclockProcAddrTable( if( loader::context->version < version ) return ZE_RESULT_ERROR_UNSUPPORTED_VERSION; - ze_result_t result = ZE_RESULT_SUCCESS; - - bool atLeastOneDriverValid = false; - // Load the device-driver DDI tables - for( auto& drv : *loader::context->sysmanInstanceDrivers ) - { - if(drv.initStatus != ZE_RESULT_SUCCESS) - continue; - auto getTable = reinterpret_cast( - GET_FUNCTION_PTR( drv.handle, "zesGetOverclockProcAddrTable") ); - if(!getTable) - { - atLeastOneDriverValid = true; - //It is valid to not have this proc addr table - continue; - } - auto getTableResult = getTable( version, &drv.dditable.zes.Overclock); - if(getTableResult == ZE_RESULT_SUCCESS) { - atLeastOneDriverValid = true; - loader::context->configured_version = version; - } else - drv.initStatus = getTableResult; - } + loader::context->ddi_init_version = version; - if(!atLeastOneDriverValid) - result = ZE_RESULT_ERROR_UNINITIALIZED; - else - result = ZE_RESULT_SUCCESS; + ze_result_t result = ZE_RESULT_SUCCESS; if( ZE_RESULT_SUCCESS == result ) { @@ -6836,30 +7261,9 @@ zesGetPerformanceFactorProcAddrTable( if( loader::context->version < version ) return ZE_RESULT_ERROR_UNSUPPORTED_VERSION; - ze_result_t result = ZE_RESULT_SUCCESS; + loader::context->ddi_init_version = version; - bool atLeastOneDriverValid = false; - // Load the device-driver DDI tables - for( auto& drv : *loader::context->sysmanInstanceDrivers ) - { - if(drv.initStatus != ZE_RESULT_SUCCESS) - continue; - auto getTable = reinterpret_cast( - GET_FUNCTION_PTR( drv.handle, "zesGetPerformanceFactorProcAddrTable") ); - if(!getTable) - continue; - auto getTableResult = getTable( version, &drv.dditable.zes.PerformanceFactor); - if(getTableResult == ZE_RESULT_SUCCESS) { - atLeastOneDriverValid = true; - loader::context->configured_version = version; - } else - drv.initStatus = getTableResult; - } - - if(!atLeastOneDriverValid) - result = ZE_RESULT_ERROR_UNINITIALIZED; - else - result = ZE_RESULT_SUCCESS; + ze_result_t result = ZE_RESULT_SUCCESS; if( ZE_RESULT_SUCCESS == result ) { @@ -6935,30 +7339,9 @@ zesGetPowerProcAddrTable( if( loader::context->version < version ) return ZE_RESULT_ERROR_UNSUPPORTED_VERSION; - ze_result_t result = ZE_RESULT_SUCCESS; + loader::context->ddi_init_version = version; - bool atLeastOneDriverValid = false; - // Load the device-driver DDI tables - for( auto& drv : *loader::context->sysmanInstanceDrivers ) - { - if(drv.initStatus != ZE_RESULT_SUCCESS) - continue; - auto getTable = reinterpret_cast( - GET_FUNCTION_PTR( drv.handle, "zesGetPowerProcAddrTable") ); - if(!getTable) - continue; - auto getTableResult = getTable( version, &drv.dditable.zes.Power); - if(getTableResult == ZE_RESULT_SUCCESS) { - atLeastOneDriverValid = true; - loader::context->configured_version = version; - } else - drv.initStatus = getTableResult; - } - - if(!atLeastOneDriverValid) - result = ZE_RESULT_ERROR_UNINITIALIZED; - else - result = ZE_RESULT_SUCCESS; + ze_result_t result = ZE_RESULT_SUCCESS; if( ZE_RESULT_SUCCESS == result ) { @@ -7069,30 +7452,9 @@ zesGetPsuProcAddrTable( if( loader::context->version < version ) return ZE_RESULT_ERROR_UNSUPPORTED_VERSION; - ze_result_t result = ZE_RESULT_SUCCESS; + loader::context->ddi_init_version = version; - bool atLeastOneDriverValid = false; - // Load the device-driver DDI tables - for( auto& drv : *loader::context->sysmanInstanceDrivers ) - { - if(drv.initStatus != ZE_RESULT_SUCCESS) - continue; - auto getTable = reinterpret_cast( - GET_FUNCTION_PTR( drv.handle, "zesGetPsuProcAddrTable") ); - if(!getTable) - continue; - auto getTableResult = getTable( version, &drv.dditable.zes.Psu); - if(getTableResult == ZE_RESULT_SUCCESS) { - atLeastOneDriverValid = true; - loader::context->configured_version = version; - } else - drv.initStatus = getTableResult; - } - - if(!atLeastOneDriverValid) - result = ZE_RESULT_ERROR_UNINITIALIZED; - else - result = ZE_RESULT_SUCCESS; + ze_result_t result = ZE_RESULT_SUCCESS; if( ZE_RESULT_SUCCESS == result ) { @@ -7161,30 +7523,9 @@ zesGetRasProcAddrTable( if( loader::context->version < version ) return ZE_RESULT_ERROR_UNSUPPORTED_VERSION; - ze_result_t result = ZE_RESULT_SUCCESS; + loader::context->ddi_init_version = version; - bool atLeastOneDriverValid = false; - // Load the device-driver DDI tables - for( auto& drv : *loader::context->sysmanInstanceDrivers ) - { - if(drv.initStatus != ZE_RESULT_SUCCESS) - continue; - auto getTable = reinterpret_cast( - GET_FUNCTION_PTR( drv.handle, "zesGetRasProcAddrTable") ); - if(!getTable) - continue; - auto getTableResult = getTable( version, &drv.dditable.zes.Ras); - if(getTableResult == ZE_RESULT_SUCCESS) { - atLeastOneDriverValid = true; - loader::context->configured_version = version; - } else - drv.initStatus = getTableResult; - } - - if(!atLeastOneDriverValid) - result = ZE_RESULT_ERROR_UNINITIALIZED; - else - result = ZE_RESULT_SUCCESS; + ze_result_t result = ZE_RESULT_SUCCESS; if( ZE_RESULT_SUCCESS == result ) { @@ -7267,20 +7608,9 @@ zesGetRasExpProcAddrTable( if( loader::context->version < version ) return ZE_RESULT_ERROR_UNSUPPORTED_VERSION; - ze_result_t result = ZE_RESULT_SUCCESS; - - // Load the device-driver DDI tables - for( auto& drv : *loader::context->sysmanInstanceDrivers ) - { - if(drv.initStatus != ZE_RESULT_SUCCESS) - continue; - auto getTable = reinterpret_cast( - GET_FUNCTION_PTR( drv.handle, "zesGetRasExpProcAddrTable") ); - if(!getTable) - continue; - result = getTable( version, &drv.dditable.zes.RasExp); - } + loader::context->ddi_init_version = version; + ze_result_t result = ZE_RESULT_SUCCESS; if( ZE_RESULT_SUCCESS == result ) { @@ -7349,30 +7679,9 @@ zesGetSchedulerProcAddrTable( if( loader::context->version < version ) return ZE_RESULT_ERROR_UNSUPPORTED_VERSION; - ze_result_t result = ZE_RESULT_SUCCESS; + loader::context->ddi_init_version = version; - bool atLeastOneDriverValid = false; - // Load the device-driver DDI tables - for( auto& drv : *loader::context->sysmanInstanceDrivers ) - { - if(drv.initStatus != ZE_RESULT_SUCCESS) - continue; - auto getTable = reinterpret_cast( - GET_FUNCTION_PTR( drv.handle, "zesGetSchedulerProcAddrTable") ); - if(!getTable) - continue; - auto getTableResult = getTable( version, &drv.dditable.zes.Scheduler); - if(getTableResult == ZE_RESULT_SUCCESS) { - atLeastOneDriverValid = true; - loader::context->configured_version = version; - } else - drv.initStatus = getTableResult; - } - - if(!atLeastOneDriverValid) - result = ZE_RESULT_ERROR_UNINITIALIZED; - else - result = ZE_RESULT_SUCCESS; + ze_result_t result = ZE_RESULT_SUCCESS; if( ZE_RESULT_SUCCESS == result ) { @@ -7483,30 +7792,9 @@ zesGetStandbyProcAddrTable( if( loader::context->version < version ) return ZE_RESULT_ERROR_UNSUPPORTED_VERSION; - ze_result_t result = ZE_RESULT_SUCCESS; + loader::context->ddi_init_version = version; - bool atLeastOneDriverValid = false; - // Load the device-driver DDI tables - for( auto& drv : *loader::context->sysmanInstanceDrivers ) - { - if(drv.initStatus != ZE_RESULT_SUCCESS) - continue; - auto getTable = reinterpret_cast( - GET_FUNCTION_PTR( drv.handle, "zesGetStandbyProcAddrTable") ); - if(!getTable) - continue; - auto getTableResult = getTable( version, &drv.dditable.zes.Standby); - if(getTableResult == ZE_RESULT_SUCCESS) { - atLeastOneDriverValid = true; - loader::context->configured_version = version; - } else - drv.initStatus = getTableResult; - } - - if(!atLeastOneDriverValid) - result = ZE_RESULT_ERROR_UNINITIALIZED; - else - result = ZE_RESULT_SUCCESS; + ze_result_t result = ZE_RESULT_SUCCESS; if( ZE_RESULT_SUCCESS == result ) { @@ -7582,30 +7870,9 @@ zesGetTemperatureProcAddrTable( if( loader::context->version < version ) return ZE_RESULT_ERROR_UNSUPPORTED_VERSION; - ze_result_t result = ZE_RESULT_SUCCESS; + loader::context->ddi_init_version = version; - bool atLeastOneDriverValid = false; - // Load the device-driver DDI tables - for( auto& drv : *loader::context->sysmanInstanceDrivers ) - { - if(drv.initStatus != ZE_RESULT_SUCCESS) - continue; - auto getTable = reinterpret_cast( - GET_FUNCTION_PTR( drv.handle, "zesGetTemperatureProcAddrTable") ); - if(!getTable) - continue; - auto getTableResult = getTable( version, &drv.dditable.zes.Temperature); - if(getTableResult == ZE_RESULT_SUCCESS) { - atLeastOneDriverValid = true; - loader::context->configured_version = version; - } else - drv.initStatus = getTableResult; - } - - if(!atLeastOneDriverValid) - result = ZE_RESULT_ERROR_UNINITIALIZED; - else - result = ZE_RESULT_SUCCESS; + ze_result_t result = ZE_RESULT_SUCCESS; if( ZE_RESULT_SUCCESS == result ) { @@ -7688,20 +7955,9 @@ zesGetVFManagementExpProcAddrTable( if( loader::context->version < version ) return ZE_RESULT_ERROR_UNSUPPORTED_VERSION; - ze_result_t result = ZE_RESULT_SUCCESS; - - // Load the device-driver DDI tables - for( auto& drv : *loader::context->sysmanInstanceDrivers ) - { - if(drv.initStatus != ZE_RESULT_SUCCESS) - continue; - auto getTable = reinterpret_cast( - GET_FUNCTION_PTR( drv.handle, "zesGetVFManagementExpProcAddrTable") ); - if(!getTable) - continue; - result = getTable( version, &drv.dditable.zes.VFManagementExp); - } + loader::context->ddi_init_version = version; + ze_result_t result = ZE_RESULT_SUCCESS; if( ZE_RESULT_SUCCESS == result ) { diff --git a/source/loader/zes_ldrddi.h b/source/loader/zes_ldrddi.h index a9438284..0e852851 100644 --- a/source/loader/zes_ldrddi.h +++ b/source/loader/zes_ldrddi.h @@ -11,6 +11,10 @@ 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; /////////////////////////////////////////////////////////////////////////////// using zes_driver_object_t = object_t < zes_driver_handle_t >; using zes_driver_factory_t = singleton_factory_t < zes_driver_object_t, zes_driver_handle_t >; @@ -69,6 +73,8 @@ namespace loader using zes_vf_object_t = object_t < zes_vf_handle_t >; using zes_vf_factory_t = singleton_factory_t < zes_vf_object_t, zes_vf_handle_t >; + __zedlllocal ze_result_t ZE_APICALL + zesloaderInitDriverDDITables(loader::driver_t *driver); } namespace loader_driver_ddi @@ -1264,52 +1270,100 @@ extern "C" { __zedlllocal void ZE_APICALL zesGetGlobalProcAddrTableLegacy(); +__zedlllocal ze_result_t ZE_APICALL +zesGetGlobalProcAddrTableFromDriver(loader::driver_t *driver); __zedlllocal void ZE_APICALL zesGetDeviceProcAddrTableLegacy(); +__zedlllocal ze_result_t ZE_APICALL +zesGetDeviceProcAddrTableFromDriver(loader::driver_t *driver); __zedlllocal void ZE_APICALL zesGetDeviceExpProcAddrTableLegacy(); +__zedlllocal ze_result_t ZE_APICALL +zesGetDeviceExpProcAddrTableFromDriver(loader::driver_t *driver); __zedlllocal void ZE_APICALL zesGetDriverProcAddrTableLegacy(); +__zedlllocal ze_result_t ZE_APICALL +zesGetDriverProcAddrTableFromDriver(loader::driver_t *driver); __zedlllocal void ZE_APICALL zesGetDriverExpProcAddrTableLegacy(); +__zedlllocal ze_result_t ZE_APICALL +zesGetDriverExpProcAddrTableFromDriver(loader::driver_t *driver); __zedlllocal void ZE_APICALL zesGetDiagnosticsProcAddrTableLegacy(); +__zedlllocal ze_result_t ZE_APICALL +zesGetDiagnosticsProcAddrTableFromDriver(loader::driver_t *driver); __zedlllocal void ZE_APICALL zesGetEngineProcAddrTableLegacy(); +__zedlllocal ze_result_t ZE_APICALL +zesGetEngineProcAddrTableFromDriver(loader::driver_t *driver); __zedlllocal void ZE_APICALL zesGetFabricPortProcAddrTableLegacy(); +__zedlllocal ze_result_t ZE_APICALL +zesGetFabricPortProcAddrTableFromDriver(loader::driver_t *driver); __zedlllocal void ZE_APICALL zesGetFanProcAddrTableLegacy(); +__zedlllocal ze_result_t ZE_APICALL +zesGetFanProcAddrTableFromDriver(loader::driver_t *driver); __zedlllocal void ZE_APICALL zesGetFirmwareProcAddrTableLegacy(); +__zedlllocal ze_result_t ZE_APICALL +zesGetFirmwareProcAddrTableFromDriver(loader::driver_t *driver); __zedlllocal void ZE_APICALL zesGetFirmwareExpProcAddrTableLegacy(); +__zedlllocal ze_result_t ZE_APICALL +zesGetFirmwareExpProcAddrTableFromDriver(loader::driver_t *driver); __zedlllocal void ZE_APICALL zesGetFrequencyProcAddrTableLegacy(); +__zedlllocal ze_result_t ZE_APICALL +zesGetFrequencyProcAddrTableFromDriver(loader::driver_t *driver); __zedlllocal void ZE_APICALL zesGetLedProcAddrTableLegacy(); +__zedlllocal ze_result_t ZE_APICALL +zesGetLedProcAddrTableFromDriver(loader::driver_t *driver); __zedlllocal void ZE_APICALL zesGetMemoryProcAddrTableLegacy(); +__zedlllocal ze_result_t ZE_APICALL +zesGetMemoryProcAddrTableFromDriver(loader::driver_t *driver); __zedlllocal void ZE_APICALL zesGetOverclockProcAddrTableLegacy(); +__zedlllocal ze_result_t ZE_APICALL +zesGetOverclockProcAddrTableFromDriver(loader::driver_t *driver); __zedlllocal void ZE_APICALL zesGetPerformanceFactorProcAddrTableLegacy(); +__zedlllocal ze_result_t ZE_APICALL +zesGetPerformanceFactorProcAddrTableFromDriver(loader::driver_t *driver); __zedlllocal void ZE_APICALL zesGetPowerProcAddrTableLegacy(); +__zedlllocal ze_result_t ZE_APICALL +zesGetPowerProcAddrTableFromDriver(loader::driver_t *driver); __zedlllocal void ZE_APICALL zesGetPsuProcAddrTableLegacy(); +__zedlllocal ze_result_t ZE_APICALL +zesGetPsuProcAddrTableFromDriver(loader::driver_t *driver); __zedlllocal void ZE_APICALL zesGetRasProcAddrTableLegacy(); +__zedlllocal ze_result_t ZE_APICALL +zesGetRasProcAddrTableFromDriver(loader::driver_t *driver); __zedlllocal void ZE_APICALL zesGetRasExpProcAddrTableLegacy(); +__zedlllocal ze_result_t ZE_APICALL +zesGetRasExpProcAddrTableFromDriver(loader::driver_t *driver); __zedlllocal void ZE_APICALL zesGetSchedulerProcAddrTableLegacy(); +__zedlllocal ze_result_t ZE_APICALL +zesGetSchedulerProcAddrTableFromDriver(loader::driver_t *driver); __zedlllocal void ZE_APICALL zesGetStandbyProcAddrTableLegacy(); +__zedlllocal ze_result_t ZE_APICALL +zesGetStandbyProcAddrTableFromDriver(loader::driver_t *driver); __zedlllocal void ZE_APICALL zesGetTemperatureProcAddrTableLegacy(); +__zedlllocal ze_result_t ZE_APICALL +zesGetTemperatureProcAddrTableFromDriver(loader::driver_t *driver); __zedlllocal void ZE_APICALL zesGetVFManagementExpProcAddrTableLegacy(); +__zedlllocal ze_result_t ZE_APICALL +zesGetVFManagementExpProcAddrTableFromDriver(loader::driver_t *driver); #if defined(__cplusplus) }; diff --git a/source/loader/zet_ldrddi.cpp b/source/loader/zet_ldrddi.cpp index 01a9beef..df79b90c 100644 --- a/source/loader/zet_ldrddi.cpp +++ b/source/loader/zet_ldrddi.cpp @@ -13,6 +13,87 @@ using namespace loader_driver_ddi; namespace loader { + __zedlllocal ze_result_t ZE_APICALL + zetloaderInitDriverDDITables(loader::driver_t *driver) { + ze_result_t result = ZE_RESULT_SUCCESS; + result = zetGetMetricDecoderExpProcAddrTableFromDriver(driver); + if (result != ZE_RESULT_SUCCESS) { + return result; + } + result = zetGetMetricProgrammableExpProcAddrTableFromDriver(driver); + if (result != ZE_RESULT_SUCCESS) { + return result; + } + result = zetGetMetricTracerExpProcAddrTableFromDriver(driver); + if (result != ZE_RESULT_SUCCESS) { + return result; + } + result = zetGetDeviceProcAddrTableFromDriver(driver); + if (result != ZE_RESULT_SUCCESS) { + return result; + } + result = zetGetDeviceExpProcAddrTableFromDriver(driver); + if (result != ZE_RESULT_SUCCESS) { + return result; + } + result = zetGetContextProcAddrTableFromDriver(driver); + if (result != ZE_RESULT_SUCCESS) { + return result; + } + result = zetGetCommandListProcAddrTableFromDriver(driver); + if (result != ZE_RESULT_SUCCESS) { + return result; + } + result = zetGetCommandListExpProcAddrTableFromDriver(driver); + if (result != ZE_RESULT_SUCCESS) { + return result; + } + result = zetGetKernelProcAddrTableFromDriver(driver); + if (result != ZE_RESULT_SUCCESS) { + return result; + } + result = zetGetModuleProcAddrTableFromDriver(driver); + if (result != ZE_RESULT_SUCCESS) { + return result; + } + result = zetGetDebugProcAddrTableFromDriver(driver); + if (result != ZE_RESULT_SUCCESS) { + return result; + } + result = zetGetMetricProcAddrTableFromDriver(driver); + if (result != ZE_RESULT_SUCCESS) { + return result; + } + result = zetGetMetricExpProcAddrTableFromDriver(driver); + if (result != ZE_RESULT_SUCCESS) { + return result; + } + result = zetGetMetricGroupProcAddrTableFromDriver(driver); + if (result != ZE_RESULT_SUCCESS) { + return result; + } + result = zetGetMetricGroupExpProcAddrTableFromDriver(driver); + if (result != ZE_RESULT_SUCCESS) { + return result; + } + result = zetGetMetricQueryProcAddrTableFromDriver(driver); + if (result != ZE_RESULT_SUCCESS) { + return result; + } + result = zetGetMetricQueryPoolProcAddrTableFromDriver(driver); + if (result != ZE_RESULT_SUCCESS) { + return result; + } + result = zetGetMetricStreamerProcAddrTableFromDriver(driver); + if (result != ZE_RESULT_SUCCESS) { + return result; + } + result = zetGetTracerExpProcAddrTableFromDriver(driver); + if (result != ZE_RESULT_SUCCESS) { + return result; + } + return result; + } /////////////////////////////////////////////////////////////////////////////// /// @brief Intercept function for zetModuleGetDebugInfo __zedlllocal ze_result_t ZE_APICALL @@ -2601,6 +2682,472 @@ zetGetTracerExpProcAddrTableLegacy() } +/////////////////////////////////////////////////////////////////////////////// +/// @brief Exported function for filling application's MetricDecoderExp table +/// with current process' addresses +/// +/// @returns +/// - ::ZE_RESULT_SUCCESS +/// - ::ZE_RESULT_ERROR_UNINITIALIZED +/// - ::ZE_RESULT_ERROR_INVALID_NULL_POINTER +/// - ::ZE_RESULT_ERROR_UNSUPPORTED_VERSION +__zedlllocal ze_result_t ZE_APICALL +zetGetMetricDecoderExpProcAddrTableFromDriver(loader::driver_t *driver) +{ + ze_result_t result = ZE_RESULT_SUCCESS; + if(driver->initStatus != ZE_RESULT_SUCCESS) + return driver->initStatus; + auto getTable = reinterpret_cast( + GET_FUNCTION_PTR( driver->handle, "zetGetMetricDecoderExpProcAddrTable") ); + if(!getTable) + return driver->initStatus; + result = getTable( loader::context->ddi_init_version, &driver->dditable.zet.MetricDecoderExp); + return result; +} +/////////////////////////////////////////////////////////////////////////////// +/// @brief Exported function for filling application's MetricProgrammableExp table +/// with current process' addresses +/// +/// @returns +/// - ::ZE_RESULT_SUCCESS +/// - ::ZE_RESULT_ERROR_UNINITIALIZED +/// - ::ZE_RESULT_ERROR_INVALID_NULL_POINTER +/// - ::ZE_RESULT_ERROR_UNSUPPORTED_VERSION +__zedlllocal ze_result_t ZE_APICALL +zetGetMetricProgrammableExpProcAddrTableFromDriver(loader::driver_t *driver) +{ + ze_result_t result = ZE_RESULT_SUCCESS; + if(driver->initStatus != ZE_RESULT_SUCCESS) + return driver->initStatus; + auto getTable = reinterpret_cast( + GET_FUNCTION_PTR( driver->handle, "zetGetMetricProgrammableExpProcAddrTable") ); + if(!getTable) + return driver->initStatus; + result = getTable( loader::context->ddi_init_version, &driver->dditable.zet.MetricProgrammableExp); + return result; +} +/////////////////////////////////////////////////////////////////////////////// +/// @brief Exported function for filling application's MetricTracerExp table +/// with current process' addresses +/// +/// @returns +/// - ::ZE_RESULT_SUCCESS +/// - ::ZE_RESULT_ERROR_UNINITIALIZED +/// - ::ZE_RESULT_ERROR_INVALID_NULL_POINTER +/// - ::ZE_RESULT_ERROR_UNSUPPORTED_VERSION +__zedlllocal ze_result_t ZE_APICALL +zetGetMetricTracerExpProcAddrTableFromDriver(loader::driver_t *driver) +{ + ze_result_t result = ZE_RESULT_SUCCESS; + if(driver->initStatus != ZE_RESULT_SUCCESS) + return driver->initStatus; + auto getTable = reinterpret_cast( + GET_FUNCTION_PTR( driver->handle, "zetGetMetricTracerExpProcAddrTable") ); + if(!getTable) + return driver->initStatus; + result = getTable( loader::context->ddi_init_version, &driver->dditable.zet.MetricTracerExp); + return result; +} +/////////////////////////////////////////////////////////////////////////////// +/// @brief Exported function for filling application's Device table +/// with current process' addresses +/// +/// @returns +/// - ::ZE_RESULT_SUCCESS +/// - ::ZE_RESULT_ERROR_UNINITIALIZED +/// - ::ZE_RESULT_ERROR_INVALID_NULL_POINTER +/// - ::ZE_RESULT_ERROR_UNSUPPORTED_VERSION +__zedlllocal ze_result_t ZE_APICALL +zetGetDeviceProcAddrTableFromDriver(loader::driver_t *driver) +{ + ze_result_t result = ZE_RESULT_SUCCESS; + if(driver->initStatus != ZE_RESULT_SUCCESS) + return driver->initStatus; + auto getTable = reinterpret_cast( + GET_FUNCTION_PTR( driver->handle, "zetGetDeviceProcAddrTable") ); + if(!getTable) + return driver->initStatus; + auto getTableResult = getTable( loader::context->ddi_init_version, &driver->dditable.zet.Device); + if(getTableResult == ZE_RESULT_SUCCESS) { + loader::context->configured_version = loader::context->ddi_init_version; + } else + driver->initStatus = getTableResult; + return result; +} +/////////////////////////////////////////////////////////////////////////////// +/// @brief Exported function for filling application's DeviceExp table +/// with current process' addresses +/// +/// @returns +/// - ::ZE_RESULT_SUCCESS +/// - ::ZE_RESULT_ERROR_UNINITIALIZED +/// - ::ZE_RESULT_ERROR_INVALID_NULL_POINTER +/// - ::ZE_RESULT_ERROR_UNSUPPORTED_VERSION +__zedlllocal ze_result_t ZE_APICALL +zetGetDeviceExpProcAddrTableFromDriver(loader::driver_t *driver) +{ + ze_result_t result = ZE_RESULT_SUCCESS; + if(driver->initStatus != ZE_RESULT_SUCCESS) + return driver->initStatus; + auto getTable = reinterpret_cast( + GET_FUNCTION_PTR( driver->handle, "zetGetDeviceExpProcAddrTable") ); + if(!getTable) + return driver->initStatus; + result = getTable( loader::context->ddi_init_version, &driver->dditable.zet.DeviceExp); + return result; +} +/////////////////////////////////////////////////////////////////////////////// +/// @brief Exported function for filling application's Context table +/// with current process' addresses +/// +/// @returns +/// - ::ZE_RESULT_SUCCESS +/// - ::ZE_RESULT_ERROR_UNINITIALIZED +/// - ::ZE_RESULT_ERROR_INVALID_NULL_POINTER +/// - ::ZE_RESULT_ERROR_UNSUPPORTED_VERSION +__zedlllocal ze_result_t ZE_APICALL +zetGetContextProcAddrTableFromDriver(loader::driver_t *driver) +{ + ze_result_t result = ZE_RESULT_SUCCESS; + if(driver->initStatus != ZE_RESULT_SUCCESS) + return driver->initStatus; + auto getTable = reinterpret_cast( + GET_FUNCTION_PTR( driver->handle, "zetGetContextProcAddrTable") ); + if(!getTable) + return driver->initStatus; + auto getTableResult = getTable( loader::context->ddi_init_version, &driver->dditable.zet.Context); + if(getTableResult == ZE_RESULT_SUCCESS) { + loader::context->configured_version = loader::context->ddi_init_version; + } else + driver->initStatus = getTableResult; + return result; +} +/////////////////////////////////////////////////////////////////////////////// +/// @brief Exported function for filling application's CommandList table +/// with current process' addresses +/// +/// @returns +/// - ::ZE_RESULT_SUCCESS +/// - ::ZE_RESULT_ERROR_UNINITIALIZED +/// - ::ZE_RESULT_ERROR_INVALID_NULL_POINTER +/// - ::ZE_RESULT_ERROR_UNSUPPORTED_VERSION +__zedlllocal ze_result_t ZE_APICALL +zetGetCommandListProcAddrTableFromDriver(loader::driver_t *driver) +{ + ze_result_t result = ZE_RESULT_SUCCESS; + if(driver->initStatus != ZE_RESULT_SUCCESS) + return driver->initStatus; + auto getTable = reinterpret_cast( + GET_FUNCTION_PTR( driver->handle, "zetGetCommandListProcAddrTable") ); + if(!getTable) + return driver->initStatus; + auto getTableResult = getTable( loader::context->ddi_init_version, &driver->dditable.zet.CommandList); + if(getTableResult == ZE_RESULT_SUCCESS) { + loader::context->configured_version = loader::context->ddi_init_version; + } else + driver->initStatus = getTableResult; + return result; +} +/////////////////////////////////////////////////////////////////////////////// +/// @brief Exported function for filling application's CommandListExp table +/// with current process' addresses +/// +/// @returns +/// - ::ZE_RESULT_SUCCESS +/// - ::ZE_RESULT_ERROR_UNINITIALIZED +/// - ::ZE_RESULT_ERROR_INVALID_NULL_POINTER +/// - ::ZE_RESULT_ERROR_UNSUPPORTED_VERSION +__zedlllocal ze_result_t ZE_APICALL +zetGetCommandListExpProcAddrTableFromDriver(loader::driver_t *driver) +{ + ze_result_t result = ZE_RESULT_SUCCESS; + if(driver->initStatus != ZE_RESULT_SUCCESS) + return driver->initStatus; + auto getTable = reinterpret_cast( + GET_FUNCTION_PTR( driver->handle, "zetGetCommandListExpProcAddrTable") ); + if(!getTable) + return driver->initStatus; + result = getTable( loader::context->ddi_init_version, &driver->dditable.zet.CommandListExp); + return result; +} +/////////////////////////////////////////////////////////////////////////////// +/// @brief Exported function for filling application's Kernel table +/// with current process' addresses +/// +/// @returns +/// - ::ZE_RESULT_SUCCESS +/// - ::ZE_RESULT_ERROR_UNINITIALIZED +/// - ::ZE_RESULT_ERROR_INVALID_NULL_POINTER +/// - ::ZE_RESULT_ERROR_UNSUPPORTED_VERSION +__zedlllocal ze_result_t ZE_APICALL +zetGetKernelProcAddrTableFromDriver(loader::driver_t *driver) +{ + ze_result_t result = ZE_RESULT_SUCCESS; + if(driver->initStatus != ZE_RESULT_SUCCESS) + return driver->initStatus; + auto getTable = reinterpret_cast( + GET_FUNCTION_PTR( driver->handle, "zetGetKernelProcAddrTable") ); + if(!getTable) + return driver->initStatus; + auto getTableResult = getTable( loader::context->ddi_init_version, &driver->dditable.zet.Kernel); + if(getTableResult == ZE_RESULT_SUCCESS) { + loader::context->configured_version = loader::context->ddi_init_version; + } else + driver->initStatus = getTableResult; + return result; +} +/////////////////////////////////////////////////////////////////////////////// +/// @brief Exported function for filling application's Module table +/// with current process' addresses +/// +/// @returns +/// - ::ZE_RESULT_SUCCESS +/// - ::ZE_RESULT_ERROR_UNINITIALIZED +/// - ::ZE_RESULT_ERROR_INVALID_NULL_POINTER +/// - ::ZE_RESULT_ERROR_UNSUPPORTED_VERSION +__zedlllocal ze_result_t ZE_APICALL +zetGetModuleProcAddrTableFromDriver(loader::driver_t *driver) +{ + ze_result_t result = ZE_RESULT_SUCCESS; + if(driver->initStatus != ZE_RESULT_SUCCESS) + return driver->initStatus; + auto getTable = reinterpret_cast( + GET_FUNCTION_PTR( driver->handle, "zetGetModuleProcAddrTable") ); + if(!getTable) + return driver->initStatus; + auto getTableResult = getTable( loader::context->ddi_init_version, &driver->dditable.zet.Module); + if(getTableResult == ZE_RESULT_SUCCESS) { + loader::context->configured_version = loader::context->ddi_init_version; + } else + driver->initStatus = getTableResult; + return result; +} +/////////////////////////////////////////////////////////////////////////////// +/// @brief Exported function for filling application's Debug table +/// with current process' addresses +/// +/// @returns +/// - ::ZE_RESULT_SUCCESS +/// - ::ZE_RESULT_ERROR_UNINITIALIZED +/// - ::ZE_RESULT_ERROR_INVALID_NULL_POINTER +/// - ::ZE_RESULT_ERROR_UNSUPPORTED_VERSION +__zedlllocal ze_result_t ZE_APICALL +zetGetDebugProcAddrTableFromDriver(loader::driver_t *driver) +{ + ze_result_t result = ZE_RESULT_SUCCESS; + if(driver->initStatus != ZE_RESULT_SUCCESS) + return driver->initStatus; + auto getTable = reinterpret_cast( + GET_FUNCTION_PTR( driver->handle, "zetGetDebugProcAddrTable") ); + if(!getTable) + return driver->initStatus; + auto getTableResult = getTable( loader::context->ddi_init_version, &driver->dditable.zet.Debug); + if(getTableResult == ZE_RESULT_SUCCESS) { + loader::context->configured_version = loader::context->ddi_init_version; + } else + driver->initStatus = getTableResult; + return result; +} +/////////////////////////////////////////////////////////////////////////////// +/// @brief Exported function for filling application's Metric table +/// with current process' addresses +/// +/// @returns +/// - ::ZE_RESULT_SUCCESS +/// - ::ZE_RESULT_ERROR_UNINITIALIZED +/// - ::ZE_RESULT_ERROR_INVALID_NULL_POINTER +/// - ::ZE_RESULT_ERROR_UNSUPPORTED_VERSION +__zedlllocal ze_result_t ZE_APICALL +zetGetMetricProcAddrTableFromDriver(loader::driver_t *driver) +{ + ze_result_t result = ZE_RESULT_SUCCESS; + if(driver->initStatus != ZE_RESULT_SUCCESS) + return driver->initStatus; + auto getTable = reinterpret_cast( + GET_FUNCTION_PTR( driver->handle, "zetGetMetricProcAddrTable") ); + if(!getTable) + return driver->initStatus; + auto getTableResult = getTable( loader::context->ddi_init_version, &driver->dditable.zet.Metric); + if(getTableResult == ZE_RESULT_SUCCESS) { + loader::context->configured_version = loader::context->ddi_init_version; + } else + driver->initStatus = getTableResult; + return result; +} +/////////////////////////////////////////////////////////////////////////////// +/// @brief Exported function for filling application's MetricExp table +/// with current process' addresses +/// +/// @returns +/// - ::ZE_RESULT_SUCCESS +/// - ::ZE_RESULT_ERROR_UNINITIALIZED +/// - ::ZE_RESULT_ERROR_INVALID_NULL_POINTER +/// - ::ZE_RESULT_ERROR_UNSUPPORTED_VERSION +__zedlllocal ze_result_t ZE_APICALL +zetGetMetricExpProcAddrTableFromDriver(loader::driver_t *driver) +{ + ze_result_t result = ZE_RESULT_SUCCESS; + if(driver->initStatus != ZE_RESULT_SUCCESS) + return driver->initStatus; + auto getTable = reinterpret_cast( + GET_FUNCTION_PTR( driver->handle, "zetGetMetricExpProcAddrTable") ); + if(!getTable) + return driver->initStatus; + result = getTable( loader::context->ddi_init_version, &driver->dditable.zet.MetricExp); + return result; +} +/////////////////////////////////////////////////////////////////////////////// +/// @brief Exported function for filling application's MetricGroup table +/// with current process' addresses +/// +/// @returns +/// - ::ZE_RESULT_SUCCESS +/// - ::ZE_RESULT_ERROR_UNINITIALIZED +/// - ::ZE_RESULT_ERROR_INVALID_NULL_POINTER +/// - ::ZE_RESULT_ERROR_UNSUPPORTED_VERSION +__zedlllocal ze_result_t ZE_APICALL +zetGetMetricGroupProcAddrTableFromDriver(loader::driver_t *driver) +{ + ze_result_t result = ZE_RESULT_SUCCESS; + if(driver->initStatus != ZE_RESULT_SUCCESS) + return driver->initStatus; + auto getTable = reinterpret_cast( + GET_FUNCTION_PTR( driver->handle, "zetGetMetricGroupProcAddrTable") ); + if(!getTable) + return driver->initStatus; + auto getTableResult = getTable( loader::context->ddi_init_version, &driver->dditable.zet.MetricGroup); + if(getTableResult == ZE_RESULT_SUCCESS) { + loader::context->configured_version = loader::context->ddi_init_version; + } else + driver->initStatus = getTableResult; + return result; +} +/////////////////////////////////////////////////////////////////////////////// +/// @brief Exported function for filling application's MetricGroupExp table +/// with current process' addresses +/// +/// @returns +/// - ::ZE_RESULT_SUCCESS +/// - ::ZE_RESULT_ERROR_UNINITIALIZED +/// - ::ZE_RESULT_ERROR_INVALID_NULL_POINTER +/// - ::ZE_RESULT_ERROR_UNSUPPORTED_VERSION +__zedlllocal ze_result_t ZE_APICALL +zetGetMetricGroupExpProcAddrTableFromDriver(loader::driver_t *driver) +{ + ze_result_t result = ZE_RESULT_SUCCESS; + if(driver->initStatus != ZE_RESULT_SUCCESS) + return driver->initStatus; + auto getTable = reinterpret_cast( + GET_FUNCTION_PTR( driver->handle, "zetGetMetricGroupExpProcAddrTable") ); + if(!getTable) + return driver->initStatus; + result = getTable( loader::context->ddi_init_version, &driver->dditable.zet.MetricGroupExp); + return result; +} +/////////////////////////////////////////////////////////////////////////////// +/// @brief Exported function for filling application's MetricQuery table +/// with current process' addresses +/// +/// @returns +/// - ::ZE_RESULT_SUCCESS +/// - ::ZE_RESULT_ERROR_UNINITIALIZED +/// - ::ZE_RESULT_ERROR_INVALID_NULL_POINTER +/// - ::ZE_RESULT_ERROR_UNSUPPORTED_VERSION +__zedlllocal ze_result_t ZE_APICALL +zetGetMetricQueryProcAddrTableFromDriver(loader::driver_t *driver) +{ + ze_result_t result = ZE_RESULT_SUCCESS; + if(driver->initStatus != ZE_RESULT_SUCCESS) + return driver->initStatus; + auto getTable = reinterpret_cast( + GET_FUNCTION_PTR( driver->handle, "zetGetMetricQueryProcAddrTable") ); + if(!getTable) + return driver->initStatus; + auto getTableResult = getTable( loader::context->ddi_init_version, &driver->dditable.zet.MetricQuery); + if(getTableResult == ZE_RESULT_SUCCESS) { + loader::context->configured_version = loader::context->ddi_init_version; + } else + driver->initStatus = getTableResult; + return result; +} +/////////////////////////////////////////////////////////////////////////////// +/// @brief Exported function for filling application's MetricQueryPool table +/// with current process' addresses +/// +/// @returns +/// - ::ZE_RESULT_SUCCESS +/// - ::ZE_RESULT_ERROR_UNINITIALIZED +/// - ::ZE_RESULT_ERROR_INVALID_NULL_POINTER +/// - ::ZE_RESULT_ERROR_UNSUPPORTED_VERSION +__zedlllocal ze_result_t ZE_APICALL +zetGetMetricQueryPoolProcAddrTableFromDriver(loader::driver_t *driver) +{ + ze_result_t result = ZE_RESULT_SUCCESS; + if(driver->initStatus != ZE_RESULT_SUCCESS) + return driver->initStatus; + auto getTable = reinterpret_cast( + GET_FUNCTION_PTR( driver->handle, "zetGetMetricQueryPoolProcAddrTable") ); + if(!getTable) + return driver->initStatus; + auto getTableResult = getTable( loader::context->ddi_init_version, &driver->dditable.zet.MetricQueryPool); + if(getTableResult == ZE_RESULT_SUCCESS) { + loader::context->configured_version = loader::context->ddi_init_version; + } else + driver->initStatus = getTableResult; + return result; +} +/////////////////////////////////////////////////////////////////////////////// +/// @brief Exported function for filling application's MetricStreamer table +/// with current process' addresses +/// +/// @returns +/// - ::ZE_RESULT_SUCCESS +/// - ::ZE_RESULT_ERROR_UNINITIALIZED +/// - ::ZE_RESULT_ERROR_INVALID_NULL_POINTER +/// - ::ZE_RESULT_ERROR_UNSUPPORTED_VERSION +__zedlllocal ze_result_t ZE_APICALL +zetGetMetricStreamerProcAddrTableFromDriver(loader::driver_t *driver) +{ + ze_result_t result = ZE_RESULT_SUCCESS; + if(driver->initStatus != ZE_RESULT_SUCCESS) + return driver->initStatus; + auto getTable = reinterpret_cast( + GET_FUNCTION_PTR( driver->handle, "zetGetMetricStreamerProcAddrTable") ); + if(!getTable) + return driver->initStatus; + auto getTableResult = getTable( loader::context->ddi_init_version, &driver->dditable.zet.MetricStreamer); + if(getTableResult == ZE_RESULT_SUCCESS) { + loader::context->configured_version = loader::context->ddi_init_version; + } else + driver->initStatus = getTableResult; + return result; +} +/////////////////////////////////////////////////////////////////////////////// +/// @brief Exported function for filling application's TracerExp table +/// with current process' addresses +/// +/// @returns +/// - ::ZE_RESULT_SUCCESS +/// - ::ZE_RESULT_ERROR_UNINITIALIZED +/// - ::ZE_RESULT_ERROR_INVALID_NULL_POINTER +/// - ::ZE_RESULT_ERROR_UNSUPPORTED_VERSION +__zedlllocal ze_result_t ZE_APICALL +zetGetTracerExpProcAddrTableFromDriver(loader::driver_t *driver) +{ + ze_result_t result = ZE_RESULT_SUCCESS; + if(driver->initStatus != ZE_RESULT_SUCCESS) + return driver->initStatus; + auto getTable = reinterpret_cast( + GET_FUNCTION_PTR( driver->handle, "zetGetTracerExpProcAddrTable") ); + if(!getTable) + return driver->initStatus; + auto getTableResult = getTable( loader::context->ddi_init_version, &driver->dditable.zet.TracerExp); + if(getTableResult == ZE_RESULT_SUCCESS) { + loader::context->configured_version = loader::context->ddi_init_version; + } else + driver->initStatus = getTableResult; + return result; +} /////////////////////////////////////////////////////////////////////////////// /// @brief Exported function for filling application's MetricDecoderExp table /// with current process' addresses @@ -2626,20 +3173,9 @@ zetGetMetricDecoderExpProcAddrTable( if( loader::context->version < version ) return ZE_RESULT_ERROR_UNSUPPORTED_VERSION; - ze_result_t result = ZE_RESULT_SUCCESS; - - // Load the device-driver DDI tables - for( auto& drv : loader::context->zeDrivers ) - { - if(drv.initStatus != ZE_RESULT_SUCCESS) - continue; - auto getTable = reinterpret_cast( - GET_FUNCTION_PTR( drv.handle, "zetGetMetricDecoderExpProcAddrTable") ); - if(!getTable) - continue; - result = getTable( version, &drv.dditable.zet.MetricDecoderExp); - } + loader::context->ddi_init_version = version; + ze_result_t result = ZE_RESULT_SUCCESS; if( ZE_RESULT_SUCCESS == result ) { @@ -2715,20 +3251,9 @@ zetGetMetricProgrammableExpProcAddrTable( if( loader::context->version < version ) return ZE_RESULT_ERROR_UNSUPPORTED_VERSION; - ze_result_t result = ZE_RESULT_SUCCESS; - - // Load the device-driver DDI tables - for( auto& drv : loader::context->zeDrivers ) - { - if(drv.initStatus != ZE_RESULT_SUCCESS) - continue; - auto getTable = reinterpret_cast( - GET_FUNCTION_PTR( drv.handle, "zetGetMetricProgrammableExpProcAddrTable") ); - if(!getTable) - continue; - result = getTable( version, &drv.dditable.zet.MetricProgrammableExp); - } + loader::context->ddi_init_version = version; + ze_result_t result = ZE_RESULT_SUCCESS; if( ZE_RESULT_SUCCESS == result ) { @@ -2811,20 +3336,9 @@ zetGetMetricTracerExpProcAddrTable( if( loader::context->version < version ) return ZE_RESULT_ERROR_UNSUPPORTED_VERSION; - ze_result_t result = ZE_RESULT_SUCCESS; - - // Load the device-driver DDI tables - for( auto& drv : loader::context->zeDrivers ) - { - if(drv.initStatus != ZE_RESULT_SUCCESS) - continue; - auto getTable = reinterpret_cast( - GET_FUNCTION_PTR( drv.handle, "zetGetMetricTracerExpProcAddrTable") ); - if(!getTable) - continue; - result = getTable( version, &drv.dditable.zet.MetricTracerExp); - } + loader::context->ddi_init_version = version; + ze_result_t result = ZE_RESULT_SUCCESS; if( ZE_RESULT_SUCCESS == result ) { @@ -2921,30 +3435,9 @@ zetGetDeviceProcAddrTable( if( loader::context->version < version ) return ZE_RESULT_ERROR_UNSUPPORTED_VERSION; - ze_result_t result = ZE_RESULT_SUCCESS; + loader::context->ddi_init_version = version; - bool atLeastOneDriverValid = false; - // Load the device-driver DDI tables - for( auto& drv : loader::context->zeDrivers ) - { - if(drv.initStatus != ZE_RESULT_SUCCESS) - continue; - auto getTable = reinterpret_cast( - GET_FUNCTION_PTR( drv.handle, "zetGetDeviceProcAddrTable") ); - if(!getTable) - continue; - auto getTableResult = getTable( version, &drv.dditable.zet.Device); - if(getTableResult == ZE_RESULT_SUCCESS) { - atLeastOneDriverValid = true; - loader::context->configured_version = version; - } else - drv.initStatus = getTableResult; - } - - if(!atLeastOneDriverValid) - result = ZE_RESULT_ERROR_UNINITIALIZED; - else - result = ZE_RESULT_SUCCESS; + ze_result_t result = ZE_RESULT_SUCCESS; if( ZE_RESULT_SUCCESS == result ) { @@ -3006,20 +3499,9 @@ zetGetDeviceExpProcAddrTable( if( loader::context->version < version ) return ZE_RESULT_ERROR_UNSUPPORTED_VERSION; - ze_result_t result = ZE_RESULT_SUCCESS; - - // Load the device-driver DDI tables - for( auto& drv : loader::context->zeDrivers ) - { - if(drv.initStatus != ZE_RESULT_SUCCESS) - continue; - auto getTable = reinterpret_cast( - GET_FUNCTION_PTR( drv.handle, "zetGetDeviceExpProcAddrTable") ); - if(!getTable) - continue; - result = getTable( version, &drv.dditable.zet.DeviceExp); - } + loader::context->ddi_init_version = version; + ze_result_t result = ZE_RESULT_SUCCESS; if( ZE_RESULT_SUCCESS == result ) { @@ -3102,30 +3584,9 @@ zetGetContextProcAddrTable( if( loader::context->version < version ) return ZE_RESULT_ERROR_UNSUPPORTED_VERSION; - ze_result_t result = ZE_RESULT_SUCCESS; - - bool atLeastOneDriverValid = false; - // Load the device-driver DDI tables - for( auto& drv : loader::context->zeDrivers ) - { - if(drv.initStatus != ZE_RESULT_SUCCESS) - continue; - auto getTable = reinterpret_cast( - GET_FUNCTION_PTR( drv.handle, "zetGetContextProcAddrTable") ); - if(!getTable) - continue; - auto getTableResult = getTable( version, &drv.dditable.zet.Context); - if(getTableResult == ZE_RESULT_SUCCESS) { - atLeastOneDriverValid = true; - loader::context->configured_version = version; - } else - drv.initStatus = getTableResult; - } + loader::context->ddi_init_version = version; - if(!atLeastOneDriverValid) - result = ZE_RESULT_ERROR_UNINITIALIZED; - else - result = ZE_RESULT_SUCCESS; + ze_result_t result = ZE_RESULT_SUCCESS; if( ZE_RESULT_SUCCESS == result ) { @@ -3187,30 +3648,9 @@ zetGetCommandListProcAddrTable( if( loader::context->version < version ) return ZE_RESULT_ERROR_UNSUPPORTED_VERSION; - ze_result_t result = ZE_RESULT_SUCCESS; - - bool atLeastOneDriverValid = false; - // Load the device-driver DDI tables - for( auto& drv : loader::context->zeDrivers ) - { - if(drv.initStatus != ZE_RESULT_SUCCESS) - continue; - auto getTable = reinterpret_cast( - GET_FUNCTION_PTR( drv.handle, "zetGetCommandListProcAddrTable") ); - if(!getTable) - continue; - auto getTableResult = getTable( version, &drv.dditable.zet.CommandList); - if(getTableResult == ZE_RESULT_SUCCESS) { - atLeastOneDriverValid = true; - loader::context->configured_version = version; - } else - drv.initStatus = getTableResult; - } + loader::context->ddi_init_version = version; - if(!atLeastOneDriverValid) - result = ZE_RESULT_ERROR_UNINITIALIZED; - else - result = ZE_RESULT_SUCCESS; + ze_result_t result = ZE_RESULT_SUCCESS; if( ZE_RESULT_SUCCESS == result ) { @@ -3293,20 +3733,9 @@ zetGetCommandListExpProcAddrTable( if( loader::context->version < version ) return ZE_RESULT_ERROR_UNSUPPORTED_VERSION; - ze_result_t result = ZE_RESULT_SUCCESS; - - // Load the device-driver DDI tables - for( auto& drv : loader::context->zeDrivers ) - { - if(drv.initStatus != ZE_RESULT_SUCCESS) - continue; - auto getTable = reinterpret_cast( - GET_FUNCTION_PTR( drv.handle, "zetGetCommandListExpProcAddrTable") ); - if(!getTable) - continue; - result = getTable( version, &drv.dditable.zet.CommandListExp); - } + loader::context->ddi_init_version = version; + ze_result_t result = ZE_RESULT_SUCCESS; if( ZE_RESULT_SUCCESS == result ) { @@ -3368,30 +3797,9 @@ zetGetKernelProcAddrTable( if( loader::context->version < version ) return ZE_RESULT_ERROR_UNSUPPORTED_VERSION; - ze_result_t result = ZE_RESULT_SUCCESS; + loader::context->ddi_init_version = version; - bool atLeastOneDriverValid = false; - // Load the device-driver DDI tables - for( auto& drv : loader::context->zeDrivers ) - { - if(drv.initStatus != ZE_RESULT_SUCCESS) - continue; - auto getTable = reinterpret_cast( - GET_FUNCTION_PTR( drv.handle, "zetGetKernelProcAddrTable") ); - if(!getTable) - continue; - auto getTableResult = getTable( version, &drv.dditable.zet.Kernel); - if(getTableResult == ZE_RESULT_SUCCESS) { - atLeastOneDriverValid = true; - loader::context->configured_version = version; - } else - drv.initStatus = getTableResult; - } - - if(!atLeastOneDriverValid) - result = ZE_RESULT_ERROR_UNINITIALIZED; - else - result = ZE_RESULT_SUCCESS; + ze_result_t result = ZE_RESULT_SUCCESS; if( ZE_RESULT_SUCCESS == result ) { @@ -3453,30 +3861,9 @@ zetGetModuleProcAddrTable( if( loader::context->version < version ) return ZE_RESULT_ERROR_UNSUPPORTED_VERSION; - ze_result_t result = ZE_RESULT_SUCCESS; - - bool atLeastOneDriverValid = false; - // Load the device-driver DDI tables - for( auto& drv : loader::context->zeDrivers ) - { - if(drv.initStatus != ZE_RESULT_SUCCESS) - continue; - auto getTable = reinterpret_cast( - GET_FUNCTION_PTR( drv.handle, "zetGetModuleProcAddrTable") ); - if(!getTable) - continue; - auto getTableResult = getTable( version, &drv.dditable.zet.Module); - if(getTableResult == ZE_RESULT_SUCCESS) { - atLeastOneDriverValid = true; - loader::context->configured_version = version; - } else - drv.initStatus = getTableResult; - } + loader::context->ddi_init_version = version; - if(!atLeastOneDriverValid) - result = ZE_RESULT_ERROR_UNINITIALIZED; - else - result = ZE_RESULT_SUCCESS; + ze_result_t result = ZE_RESULT_SUCCESS; if( ZE_RESULT_SUCCESS == result ) { @@ -3538,30 +3925,9 @@ zetGetDebugProcAddrTable( if( loader::context->version < version ) return ZE_RESULT_ERROR_UNSUPPORTED_VERSION; - ze_result_t result = ZE_RESULT_SUCCESS; - - bool atLeastOneDriverValid = false; - // Load the device-driver DDI tables - for( auto& drv : loader::context->zeDrivers ) - { - if(drv.initStatus != ZE_RESULT_SUCCESS) - continue; - auto getTable = reinterpret_cast( - GET_FUNCTION_PTR( drv.handle, "zetGetDebugProcAddrTable") ); - if(!getTable) - continue; - auto getTableResult = getTable( version, &drv.dditable.zet.Debug); - if(getTableResult == ZE_RESULT_SUCCESS) { - atLeastOneDriverValid = true; - loader::context->configured_version = version; - } else - drv.initStatus = getTableResult; - } + loader::context->ddi_init_version = version; - if(!atLeastOneDriverValid) - result = ZE_RESULT_ERROR_UNINITIALIZED; - else - result = ZE_RESULT_SUCCESS; + ze_result_t result = ZE_RESULT_SUCCESS; if( ZE_RESULT_SUCCESS == result ) { @@ -3700,30 +4066,9 @@ zetGetMetricProcAddrTable( if( loader::context->version < version ) return ZE_RESULT_ERROR_UNSUPPORTED_VERSION; - ze_result_t result = ZE_RESULT_SUCCESS; - - bool atLeastOneDriverValid = false; - // Load the device-driver DDI tables - for( auto& drv : loader::context->zeDrivers ) - { - if(drv.initStatus != ZE_RESULT_SUCCESS) - continue; - auto getTable = reinterpret_cast( - GET_FUNCTION_PTR( drv.handle, "zetGetMetricProcAddrTable") ); - if(!getTable) - continue; - auto getTableResult = getTable( version, &drv.dditable.zet.Metric); - if(getTableResult == ZE_RESULT_SUCCESS) { - atLeastOneDriverValid = true; - loader::context->configured_version = version; - } else - drv.initStatus = getTableResult; - } + loader::context->ddi_init_version = version; - if(!atLeastOneDriverValid) - result = ZE_RESULT_ERROR_UNINITIALIZED; - else - result = ZE_RESULT_SUCCESS; + ze_result_t result = ZE_RESULT_SUCCESS; if( ZE_RESULT_SUCCESS == result ) { @@ -3792,20 +4137,9 @@ zetGetMetricExpProcAddrTable( if( loader::context->version < version ) return ZE_RESULT_ERROR_UNSUPPORTED_VERSION; - ze_result_t result = ZE_RESULT_SUCCESS; - - // Load the device-driver DDI tables - for( auto& drv : loader::context->zeDrivers ) - { - if(drv.initStatus != ZE_RESULT_SUCCESS) - continue; - auto getTable = reinterpret_cast( - GET_FUNCTION_PTR( drv.handle, "zetGetMetricExpProcAddrTable") ); - if(!getTable) - continue; - result = getTable( version, &drv.dditable.zet.MetricExp); - } + loader::context->ddi_init_version = version; + ze_result_t result = ZE_RESULT_SUCCESS; if( ZE_RESULT_SUCCESS == result ) { @@ -3881,30 +4215,9 @@ zetGetMetricGroupProcAddrTable( if( loader::context->version < version ) return ZE_RESULT_ERROR_UNSUPPORTED_VERSION; - ze_result_t result = ZE_RESULT_SUCCESS; - - bool atLeastOneDriverValid = false; - // Load the device-driver DDI tables - for( auto& drv : loader::context->zeDrivers ) - { - if(drv.initStatus != ZE_RESULT_SUCCESS) - continue; - auto getTable = reinterpret_cast( - GET_FUNCTION_PTR( drv.handle, "zetGetMetricGroupProcAddrTable") ); - if(!getTable) - continue; - auto getTableResult = getTable( version, &drv.dditable.zet.MetricGroup); - if(getTableResult == ZE_RESULT_SUCCESS) { - atLeastOneDriverValid = true; - loader::context->configured_version = version; - } else - drv.initStatus = getTableResult; - } + loader::context->ddi_init_version = version; - if(!atLeastOneDriverValid) - result = ZE_RESULT_ERROR_UNINITIALIZED; - else - result = ZE_RESULT_SUCCESS; + ze_result_t result = ZE_RESULT_SUCCESS; if( ZE_RESULT_SUCCESS == result ) { @@ -3980,20 +4293,9 @@ zetGetMetricGroupExpProcAddrTable( if( loader::context->version < version ) return ZE_RESULT_ERROR_UNSUPPORTED_VERSION; - ze_result_t result = ZE_RESULT_SUCCESS; - - // Load the device-driver DDI tables - for( auto& drv : loader::context->zeDrivers ) - { - if(drv.initStatus != ZE_RESULT_SUCCESS) - continue; - auto getTable = reinterpret_cast( - GET_FUNCTION_PTR( drv.handle, "zetGetMetricGroupExpProcAddrTable") ); - if(!getTable) - continue; - result = getTable( version, &drv.dditable.zet.MetricGroupExp); - } + loader::context->ddi_init_version = version; + ze_result_t result = ZE_RESULT_SUCCESS; if( ZE_RESULT_SUCCESS == result ) { @@ -4111,30 +4413,9 @@ zetGetMetricQueryProcAddrTable( if( loader::context->version < version ) return ZE_RESULT_ERROR_UNSUPPORTED_VERSION; - ze_result_t result = ZE_RESULT_SUCCESS; + loader::context->ddi_init_version = version; - bool atLeastOneDriverValid = false; - // Load the device-driver DDI tables - for( auto& drv : loader::context->zeDrivers ) - { - if(drv.initStatus != ZE_RESULT_SUCCESS) - continue; - auto getTable = reinterpret_cast( - GET_FUNCTION_PTR( drv.handle, "zetGetMetricQueryProcAddrTable") ); - if(!getTable) - continue; - auto getTableResult = getTable( version, &drv.dditable.zet.MetricQuery); - if(getTableResult == ZE_RESULT_SUCCESS) { - atLeastOneDriverValid = true; - loader::context->configured_version = version; - } else - drv.initStatus = getTableResult; - } - - if(!atLeastOneDriverValid) - result = ZE_RESULT_ERROR_UNINITIALIZED; - else - result = ZE_RESULT_SUCCESS; + ze_result_t result = ZE_RESULT_SUCCESS; if( ZE_RESULT_SUCCESS == result ) { @@ -4217,30 +4498,9 @@ zetGetMetricQueryPoolProcAddrTable( if( loader::context->version < version ) return ZE_RESULT_ERROR_UNSUPPORTED_VERSION; - ze_result_t result = ZE_RESULT_SUCCESS; - - bool atLeastOneDriverValid = false; - // Load the device-driver DDI tables - for( auto& drv : loader::context->zeDrivers ) - { - if(drv.initStatus != ZE_RESULT_SUCCESS) - continue; - auto getTable = reinterpret_cast( - GET_FUNCTION_PTR( drv.handle, "zetGetMetricQueryPoolProcAddrTable") ); - if(!getTable) - continue; - auto getTableResult = getTable( version, &drv.dditable.zet.MetricQueryPool); - if(getTableResult == ZE_RESULT_SUCCESS) { - atLeastOneDriverValid = true; - loader::context->configured_version = version; - } else - drv.initStatus = getTableResult; - } + loader::context->ddi_init_version = version; - if(!atLeastOneDriverValid) - result = ZE_RESULT_ERROR_UNINITIALIZED; - else - result = ZE_RESULT_SUCCESS; + ze_result_t result = ZE_RESULT_SUCCESS; if( ZE_RESULT_SUCCESS == result ) { @@ -4309,30 +4569,9 @@ zetGetMetricStreamerProcAddrTable( if( loader::context->version < version ) return ZE_RESULT_ERROR_UNSUPPORTED_VERSION; - ze_result_t result = ZE_RESULT_SUCCESS; - - bool atLeastOneDriverValid = false; - // Load the device-driver DDI tables - for( auto& drv : loader::context->zeDrivers ) - { - if(drv.initStatus != ZE_RESULT_SUCCESS) - continue; - auto getTable = reinterpret_cast( - GET_FUNCTION_PTR( drv.handle, "zetGetMetricStreamerProcAddrTable") ); - if(!getTable) - continue; - auto getTableResult = getTable( version, &drv.dditable.zet.MetricStreamer); - if(getTableResult == ZE_RESULT_SUCCESS) { - atLeastOneDriverValid = true; - loader::context->configured_version = version; - } else - drv.initStatus = getTableResult; - } + loader::context->ddi_init_version = version; - if(!atLeastOneDriverValid) - result = ZE_RESULT_ERROR_UNINITIALIZED; - else - result = ZE_RESULT_SUCCESS; + ze_result_t result = ZE_RESULT_SUCCESS; if( ZE_RESULT_SUCCESS == result ) { @@ -4408,30 +4647,9 @@ zetGetTracerExpProcAddrTable( if( loader::context->version < version ) return ZE_RESULT_ERROR_UNSUPPORTED_VERSION; - ze_result_t result = ZE_RESULT_SUCCESS; - - bool atLeastOneDriverValid = false; - // Load the device-driver DDI tables - for( auto& drv : loader::context->zeDrivers ) - { - if(drv.initStatus != ZE_RESULT_SUCCESS) - continue; - auto getTable = reinterpret_cast( - GET_FUNCTION_PTR( drv.handle, "zetGetTracerExpProcAddrTable") ); - if(!getTable) - continue; - auto getTableResult = getTable( version, &drv.dditable.zet.TracerExp); - if(getTableResult == ZE_RESULT_SUCCESS) { - atLeastOneDriverValid = true; - loader::context->configured_version = version; - } else - drv.initStatus = getTableResult; - } + loader::context->ddi_init_version = version; - if(!atLeastOneDriverValid) - result = ZE_RESULT_ERROR_UNINITIALIZED; - else - result = ZE_RESULT_SUCCESS; + ze_result_t result = ZE_RESULT_SUCCESS; if( ZE_RESULT_SUCCESS == result ) { diff --git a/source/loader/zet_ldrddi.h b/source/loader/zet_ldrddi.h index c65bc97f..1916aeff 100644 --- a/source/loader/zet_ldrddi.h +++ b/source/loader/zet_ldrddi.h @@ -11,6 +11,10 @@ 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; /////////////////////////////////////////////////////////////////////////////// using zet_driver_object_t = object_t < zet_driver_handle_t >; using zet_driver_factory_t = singleton_factory_t < zet_driver_object_t, zet_driver_handle_t >; @@ -60,6 +64,8 @@ namespace loader using zet_metric_programmable_exp_object_t = object_t < zet_metric_programmable_exp_handle_t >; using zet_metric_programmable_exp_factory_t = singleton_factory_t < zet_metric_programmable_exp_object_t, zet_metric_programmable_exp_handle_t >; + __zedlllocal ze_result_t ZE_APICALL + zetloaderInitDriverDDITables(loader::driver_t *driver); } namespace loader_driver_ddi @@ -738,42 +744,80 @@ extern "C" { __zedlllocal void ZE_APICALL zetGetMetricDecoderExpProcAddrTableLegacy(); +__zedlllocal ze_result_t ZE_APICALL +zetGetMetricDecoderExpProcAddrTableFromDriver(loader::driver_t *driver); __zedlllocal void ZE_APICALL zetGetMetricProgrammableExpProcAddrTableLegacy(); +__zedlllocal ze_result_t ZE_APICALL +zetGetMetricProgrammableExpProcAddrTableFromDriver(loader::driver_t *driver); __zedlllocal void ZE_APICALL zetGetMetricTracerExpProcAddrTableLegacy(); +__zedlllocal ze_result_t ZE_APICALL +zetGetMetricTracerExpProcAddrTableFromDriver(loader::driver_t *driver); __zedlllocal void ZE_APICALL zetGetDeviceProcAddrTableLegacy(); +__zedlllocal ze_result_t ZE_APICALL +zetGetDeviceProcAddrTableFromDriver(loader::driver_t *driver); __zedlllocal void ZE_APICALL zetGetDeviceExpProcAddrTableLegacy(); +__zedlllocal ze_result_t ZE_APICALL +zetGetDeviceExpProcAddrTableFromDriver(loader::driver_t *driver); __zedlllocal void ZE_APICALL zetGetContextProcAddrTableLegacy(); +__zedlllocal ze_result_t ZE_APICALL +zetGetContextProcAddrTableFromDriver(loader::driver_t *driver); __zedlllocal void ZE_APICALL zetGetCommandListProcAddrTableLegacy(); +__zedlllocal ze_result_t ZE_APICALL +zetGetCommandListProcAddrTableFromDriver(loader::driver_t *driver); __zedlllocal void ZE_APICALL zetGetCommandListExpProcAddrTableLegacy(); +__zedlllocal ze_result_t ZE_APICALL +zetGetCommandListExpProcAddrTableFromDriver(loader::driver_t *driver); __zedlllocal void ZE_APICALL zetGetKernelProcAddrTableLegacy(); +__zedlllocal ze_result_t ZE_APICALL +zetGetKernelProcAddrTableFromDriver(loader::driver_t *driver); __zedlllocal void ZE_APICALL zetGetModuleProcAddrTableLegacy(); +__zedlllocal ze_result_t ZE_APICALL +zetGetModuleProcAddrTableFromDriver(loader::driver_t *driver); __zedlllocal void ZE_APICALL zetGetDebugProcAddrTableLegacy(); +__zedlllocal ze_result_t ZE_APICALL +zetGetDebugProcAddrTableFromDriver(loader::driver_t *driver); __zedlllocal void ZE_APICALL zetGetMetricProcAddrTableLegacy(); +__zedlllocal ze_result_t ZE_APICALL +zetGetMetricProcAddrTableFromDriver(loader::driver_t *driver); __zedlllocal void ZE_APICALL zetGetMetricExpProcAddrTableLegacy(); +__zedlllocal ze_result_t ZE_APICALL +zetGetMetricExpProcAddrTableFromDriver(loader::driver_t *driver); __zedlllocal void ZE_APICALL zetGetMetricGroupProcAddrTableLegacy(); +__zedlllocal ze_result_t ZE_APICALL +zetGetMetricGroupProcAddrTableFromDriver(loader::driver_t *driver); __zedlllocal void ZE_APICALL zetGetMetricGroupExpProcAddrTableLegacy(); +__zedlllocal ze_result_t ZE_APICALL +zetGetMetricGroupExpProcAddrTableFromDriver(loader::driver_t *driver); __zedlllocal void ZE_APICALL zetGetMetricQueryProcAddrTableLegacy(); +__zedlllocal ze_result_t ZE_APICALL +zetGetMetricQueryProcAddrTableFromDriver(loader::driver_t *driver); __zedlllocal void ZE_APICALL zetGetMetricQueryPoolProcAddrTableLegacy(); +__zedlllocal ze_result_t ZE_APICALL +zetGetMetricQueryPoolProcAddrTableFromDriver(loader::driver_t *driver); __zedlllocal void ZE_APICALL zetGetMetricStreamerProcAddrTableLegacy(); +__zedlllocal ze_result_t ZE_APICALL +zetGetMetricStreamerProcAddrTableFromDriver(loader::driver_t *driver); __zedlllocal void ZE_APICALL zetGetTracerExpProcAddrTableLegacy(); +__zedlllocal ze_result_t ZE_APICALL +zetGetTracerExpProcAddrTableFromDriver(loader::driver_t *driver); #if defined(__cplusplus) };