Skip adapters with no platforms in urAdapterGet

igchor · igchor · commit ba4263431403 · 2025-07-11T22:25:40.000Z
diff --git a/unified-runtime/scripts/templates/ldrddi.cpp.mako b/unified-runtime/scripts/templates/ldrddi.cpp.mako
@@ -51,24 +51,21 @@ namespace ur_loader
         %if func_basename == "AdapterGet":
         auto context = getContext();
 
-        size_t adapterIndex = 0;
-        if( nullptr != ${obj['params'][1]['name']} && ${obj['params'][0]['name']} !=0)
-        {
-            for( auto& platform : context->platforms )
-            {
-                if(platform.initStatus != ${X}_RESULT_SUCCESS)
-                    continue;
-                platform.dditable.${th.get_table_name(n, tags, obj)}.${th.make_pfn_name(n, tags, obj)}( 1, &${obj['params'][1]['name']}[adapterIndex], nullptr );
-                adapterIndex++;
-                if (adapterIndex == NumEntries) {
-                    break;
-                }
-            }
+        uint32_t numAdapters = 0;
+        for (auto &platform : context->platforms) {
+            if (platform.initStatus != ${X}_RESULT_SUCCESS)
+                continue;
+
+            uint32_t adapter;
+            ur_adapter_handle_t *adapterHandle = numAdapters < NumEntries ? &${obj['params'][1]['name']}[numAdapters] : nullptr;
+            platform.dditable.${th.get_table_name(n, tags, obj)}.${th.make_pfn_name(n, tags, obj)}( 1, adapterHandle, &adapter );
+
+            numAdapters += adapter;
         }
 
         if( ${obj['params'][2]['name']} != nullptr )
         {
-            *${obj['params'][2]['name']} = static_cast<uint32_t>(context->platforms.size());
+            *${obj['params'][2]['name']} = numAdapters;
         }
 
         return ${X}_RESULT_SUCCESS;
diff --git a/unified-runtime/source/adapters/level_zero/adapter.cpp b/unified-runtime/source/adapters/level_zero/adapter.cpp
@@ -54,21 +54,21 @@ class ur_legacy_sink : public logger::Sink {
 };
 
 // Find the corresponding ZesDevice Handle for a given ZeDevice
-ur_result_t getZesDeviceHandle(zes_uuid_t coreDeviceUuid,
+ur_result_t getZesDeviceHandle(ur_adapter_handle_t_ *adapter,
+                               zes_uuid_t coreDeviceUuid,
                                zes_device_handle_t *ZesDevice,
                                uint32_t *SubDeviceId, ze_bool_t *SubDevice) {
   uint32_t ZesDriverCount = 0;
   std::vector<zes_driver_handle_t> ZesDrivers;
   std::vector<zes_device_handle_t> ZesDevices;
   ze_result_t ZesResult = ZE_RESULT_ERROR_INVALID_ARGUMENT;
-  ZE2UR_CALL(GlobalAdapter->getSysManDriversFunctionPtr,
-             (&ZesDriverCount, nullptr));
+  ZE2UR_CALL(adapter->getSysManDriversFunctionPtr, (&ZesDriverCount, nullptr));
   ZesDrivers.resize(ZesDriverCount);
-  ZE2UR_CALL(GlobalAdapter->getSysManDriversFunctionPtr,
+  ZE2UR_CALL(adapter->getSysManDriversFunctionPtr,
              (&ZesDriverCount, ZesDrivers.data()));
   for (uint32_t I = 0; I < ZesDriverCount; ++I) {
     ZesResult = ZE_CALL_NOCHECK(
-        GlobalAdapter->getDeviceByUUIdFunctionPtr,
+        adapter->getDeviceByUUIdFunctionPtr,
         (ZesDrivers[I], coreDeviceUuid, ZesDevice, SubDevice, SubDeviceId));
     if (ZesResult == ZE_RESULT_SUCCESS) {
       return UR_RESULT_SUCCESS;
@@ -147,7 +147,7 @@ ur_result_t checkDeviceIntelGPUIpVersionOrNewer(uint32_t ipVersion) {
  *    for the devices into the platform.
  * 10. The function handles exceptions and returns the appropriate result.
  */
-ur_result_t initPlatforms(PlatformVec &platforms,
+ur_result_t initPlatforms(ur_adapter_handle_t_ *adapter, PlatformVec &platforms,
                           ze_result_t ZesResult) noexcept try {
   std::vector<ze_driver_handle_t> ZeDrivers;
   std::vector<ze_driver_handle_t> ZeDriverGetHandles;
@@ -162,20 +162,20 @@ ur_result_t initPlatforms(PlatformVec &platforms,
     ZeDriverGetHandles.resize(ZeDriverGetCount);
     ZE2UR_CALL(zeDriverGet, (&ZeDriverGetCount, ZeDriverGetHandles.data()));
   }
-  if (ZeDriverGetCount == 0 && GlobalAdapter->ZeInitDriversCount == 0) {
+  if (ZeDriverGetCount == 0 && adapter->ZeInitDriversCount == 0) {
     UR_LOG(ERR, "\nNo Valid L0 Drivers found.\n");
     return UR_RESULT_SUCCESS;
   }
 
-  if (GlobalAdapter->InitDriversSupported) {
-    ZeInitDriversHandles.resize(GlobalAdapter->ZeInitDriversCount);
-    ZeDrivers.resize(GlobalAdapter->ZeInitDriversCount);
-    ZE2UR_CALL(GlobalAdapter->initDriversFunctionPtr,
-               (&GlobalAdapter->ZeInitDriversCount, ZeInitDriversHandles.data(),
-                &GlobalAdapter->InitDriversDesc));
+  if (adapter->InitDriversSupported) {
+    ZeInitDriversHandles.resize(adapter->ZeInitDriversCount);
+    ZeDrivers.resize(adapter->ZeInitDriversCount);
+    ZE2UR_CALL(adapter->initDriversFunctionPtr,
+               (&adapter->ZeInitDriversCount, ZeInitDriversHandles.data(),
+                &adapter->InitDriversDesc));
     ZeDrivers.assign(ZeInitDriversHandles.begin(), ZeInitDriversHandles.end());
-    if (ZeDriverGetCount > 0 && GlobalAdapter->ZeInitDriversCount > 0) {
-      for (uint32_t X = 0; X < GlobalAdapter->ZeInitDriversCount; ++X) {
+    if (ZeDriverGetCount > 0 && adapter->ZeInitDriversCount > 0) {
+      for (uint32_t X = 0; X < adapter->ZeInitDriversCount; ++X) {
         for (uint32_t Y = 0; Y < ZeDriverGetCount; ++Y) {
           ZeStruct<ze_driver_properties_t> ZeDriverGetProperties;
           ZeStruct<ze_driver_properties_t> ZeInitDriverProperties;
@@ -234,9 +234,10 @@ ur_result_t initPlatforms(PlatformVec &platforms,
           ur_zes_device_handle_data_t ZesDeviceData;
           zes_uuid_t ZesUUID;
           std::memcpy(&ZesUUID, &device_properties.uuid, sizeof(zes_uuid_t));
-          if (getZesDeviceHandle(
-                  ZesUUID, &ZesDeviceData.ZesDevice, &ZesDeviceData.SubDeviceId,
-                  &ZesDeviceData.SubDevice) == UR_RESULT_SUCCESS) {
+          if (getZesDeviceHandle(adapter, ZesUUID, &ZesDeviceData.ZesDevice,
+                                 &ZesDeviceData.SubDeviceId,
+                                 &ZesDeviceData.SubDevice) ==
+              UR_RESULT_SUCCESS) {
             platforms.back()->ZedeviceToZesDeviceMap.insert(
                 std::make_pair(ZeDevices[D], std::move(ZesDeviceData)));
           }
@@ -342,9 +343,9 @@ Behavior Summary:
 */
 ur_adapter_handle_t_::ur_adapter_handle_t_()
     : handle_base(), logger(logger::get_logger("level_zero")), RefCount(0) {
-  ZeInitDriversResult = ZE_RESULT_ERROR_UNINITIALIZED;
-  ZeInitResult = ZE_RESULT_ERROR_UNINITIALIZED;
-  ZesResult = ZE_RESULT_ERROR_UNINITIALIZED;
+  auto ZeInitDriversResult = ZE_RESULT_ERROR_UNINITIALIZED;
+  auto ZeInitResult = ZE_RESULT_ERROR_UNINITIALIZED;
+  auto ZesResult = ZE_RESULT_ERROR_UNINITIALIZED;
 
 #ifdef UR_STATIC_LEVEL_ZERO
   // Given static linking of the L0 Loader, we must delay the loader's
@@ -370,7 +371,6 @@ ur_adapter_handle_t_::ur_adapter_handle_t_()
     setEnvVar("ZEL_ENABLE_BASIC_LEAK_CHECKER", "1");
   }
 
-  PlatformCache.Compute = [](Result<PlatformVec> &result) {
     uint32_t UserForcedSysManInit = 0;
     // Check if the user has disabled the default L0 Env initialization.
     const int UrSysManEnvInitEnabled = [&UserForcedSysManInit] {
@@ -386,14 +386,12 @@ ur_adapter_handle_t_::ur_adapter_handle_t_()
     // not exist in older loader runtimes.
 #ifndef UR_STATIC_LEVEL_ZERO
 #ifdef _WIN32
-    GlobalAdapter->processHandle = GetModuleHandle(NULL);
+    processHandle = GetModuleHandle(NULL);
 #else
-    GlobalAdapter->processHandle = nullptr;
+    processHandle = nullptr;
 #endif
 #endif
 
-    // initialize level zero only once.
-    if (GlobalAdapter->ZeResult == std::nullopt) {
       // Setting these environment variables before running zeInit will enable
       // the validation layer in the Level Zero loader.
       if (UrL0Debug & UR_L0_DEBUG_VALIDATION) {
@@ -427,10 +425,10 @@ ur_adapter_handle_t_::ur_adapter_handle_t_()
       }
       UR_LOG(DEBUG, "\nzeInit with flags value of {}\n",
              static_cast<int>(L0InitFlags));
-      GlobalAdapter->ZeInitResult = ZE_CALL_NOCHECK(zeInit, (L0InitFlags));
-      if (GlobalAdapter->ZeInitResult != ZE_RESULT_SUCCESS) {
+      ZeInitResult = ZE_CALL_NOCHECK(zeInit, (L0InitFlags));
+      if (ZeInitResult != ZE_RESULT_SUCCESS) {
         const char *ErrorString = "Unknown";
-        zeParseError(GlobalAdapter->ZeInitResult, ErrorString);
+        zeParseError(ZeInitResult, ErrorString);
         UR_LOG(ERR, "\nzeInit failed with {}\n", ErrorString);
       }
 
@@ -474,65 +472,47 @@ ur_adapter_handle_t_::ur_adapter_handle_t_()
 
       if (useInitDrivers) {
 #ifdef UR_STATIC_LEVEL_ZERO
-        GlobalAdapter->initDriversFunctionPtr = zeInitDrivers;
+        initDriversFunctionPtr = zeInitDrivers;
 #else
-        GlobalAdapter->initDriversFunctionPtr =
+        initDriversFunctionPtr =
             (ze_pfnInitDrivers_t)ur_loader::LibLoader::getFunctionPtr(
-                GlobalAdapter->processHandle, "zeInitDrivers");
+                processHandle, "zeInitDrivers");
 #endif
-        if (GlobalAdapter->initDriversFunctionPtr) {
+        if (initDriversFunctionPtr) {
           UR_LOG(DEBUG, "\nzeInitDrivers with flags value of {}\n",
-                 static_cast<int>(GlobalAdapter->InitDriversDesc.flags));
-          GlobalAdapter->ZeInitDriversResult =
-              ZE_CALL_NOCHECK(GlobalAdapter->initDriversFunctionPtr,
-                              (&GlobalAdapter->ZeInitDriversCount, nullptr,
-                               &GlobalAdapter->InitDriversDesc));
-          if (GlobalAdapter->ZeInitDriversResult == ZE_RESULT_SUCCESS) {
-            GlobalAdapter->InitDriversSupported = true;
+                 static_cast<int>(InitDriversDesc.flags));
+          ZeInitDriversResult =
+              ZE_CALL_NOCHECK(initDriversFunctionPtr,
+                              (&ZeInitDriversCount, nullptr, &InitDriversDesc));
+          if (ZeInitDriversResult == ZE_RESULT_SUCCESS) {
+            InitDriversSupported = true;
           } else {
             const char *ErrorString = "Unknown";
-            zeParseError(GlobalAdapter->ZeInitDriversResult, ErrorString);
+            zeParseError(ZeInitDriversResult, ErrorString);
             UR_LOG(ERR, "\nzeInitDrivers failed with {}\n", ErrorString);
           }
         }
       }
 
-      if (GlobalAdapter->ZeInitResult == ZE_RESULT_SUCCESS ||
-          GlobalAdapter->ZeInitDriversResult == ZE_RESULT_SUCCESS) {
-        GlobalAdapter->ZeResult = ZE_RESULT_SUCCESS;
-      } else {
-        GlobalAdapter->ZeResult = ZE_RESULT_ERROR_UNINITIALIZED;
+      if (ZeInitResult != ZE_RESULT_SUCCESS &&
+          ZeInitDriversResult != ZE_RESULT_SUCCESS) {
+        // Absorb the ZE_RESULT_ERROR_UNINITIALIZED and just return 0 Platforms.
+        UR_LOG(ERR, "Level Zero Uninitialized\n");
+        return;
       }
-    }
-    assert(GlobalAdapter->ZeResult !=
-           std::nullopt); // verify that level-zero is initialized
-    PlatformVec platforms;
-
-    // Absorb the ZE_RESULT_ERROR_UNINITIALIZED and just return 0 Platforms.
-    if (*GlobalAdapter->ZeResult == ZE_RESULT_ERROR_UNINITIALIZED) {
-      UR_LOG(ERR, "Level Zero Uninitialized\n");
-      result = std::move(platforms);
-      return;
-    }
-    if (*GlobalAdapter->ZeResult != ZE_RESULT_SUCCESS) {
-      UR_LOG(ERR, "Level Zero initialization failure\n");
-      result = ze2urResult(*GlobalAdapter->ZeResult);
 
-      return;
-    }
+      PlatformVec platforms;
 
 #ifdef UR_ADAPTER_LEVEL_ZERO_V2
     auto [useV2, reason] = shouldUseV2Adapter();
     if (!useV2) {
       UR_LOG(INFO, "Skipping L0 V2 adapter: {}", reason);
-      result = std::move(platforms);
       return;
     }
 #else
     auto [useV1, reason] = shouldUseV1Adapter();
     if (!useV1) {
       UR_LOG(INFO, "Skipping L0 V1 adapter: {}", reason);
-      result = std::move(platforms);
       return;
     }
 #endif
@@ -558,41 +538,37 @@ ur_adapter_handle_t_::ur_adapter_handle_t_()
     }
     if (ZesInitNeeded) {
 #ifdef UR_STATIC_LEVEL_ZERO
-      GlobalAdapter->getDeviceByUUIdFunctionPtr = zesDriverGetDeviceByUuidExp;
-      GlobalAdapter->getSysManDriversFunctionPtr = zesDriverGet;
-      GlobalAdapter->sysManInitFunctionPtr = zesInit;
+      getDeviceByUUIdFunctionPtr = zesDriverGetDeviceByUuidExp;
+      getSysManDriversFunctionPtr = zesDriverGet;
+      sysManInitFunctionPtr = zesInit;
 #else
-      GlobalAdapter->getDeviceByUUIdFunctionPtr =
-          (zes_pfnDriverGetDeviceByUuidExp_t)
-              ur_loader::LibLoader::getFunctionPtr(
-                  GlobalAdapter->processHandle, "zesDriverGetDeviceByUuidExp");
-      GlobalAdapter->getSysManDriversFunctionPtr =
+      getDeviceByUUIdFunctionPtr = (zes_pfnDriverGetDeviceByUuidExp_t)
+          ur_loader::LibLoader::getFunctionPtr(processHandle,
+                                               "zesDriverGetDeviceByUuidExp");
+      getSysManDriversFunctionPtr =
           (zes_pfnDriverGet_t)ur_loader::LibLoader::getFunctionPtr(
-              GlobalAdapter->processHandle, "zesDriverGet");
-      GlobalAdapter->sysManInitFunctionPtr =
-          (zes_pfnInit_t)ur_loader::LibLoader::getFunctionPtr(
-              GlobalAdapter->processHandle, "zesInit");
+              processHandle, "zesDriverGet");
+      sysManInitFunctionPtr =
+          (zes_pfnInit_t)ur_loader::LibLoader::getFunctionPtr(processHandle,
+                                                              "zesInit");
 #endif
     }
-    if (GlobalAdapter->getDeviceByUUIdFunctionPtr &&
-        GlobalAdapter->getSysManDriversFunctionPtr &&
-        GlobalAdapter->sysManInitFunctionPtr) {
+    if (getDeviceByUUIdFunctionPtr && getSysManDriversFunctionPtr &&
+        sysManInitFunctionPtr) {
       ze_init_flags_t L0ZesInitFlags = 0;
       UR_LOG(DEBUG, "\nzesInit with flags value of {}\n",
              static_cast<int>(L0ZesInitFlags));
-      GlobalAdapter->ZesResult = ZE_CALL_NOCHECK(
-          GlobalAdapter->sysManInitFunctionPtr, (L0ZesInitFlags));
+      ZesResult = ZE_CALL_NOCHECK(sysManInitFunctionPtr, (L0ZesInitFlags));
     } else {
-      GlobalAdapter->ZesResult = ZE_RESULT_ERROR_UNINITIALIZED;
+      ZesResult = ZE_RESULT_ERROR_UNINITIALIZED;
     }
 
-    ur_result_t err = initPlatforms(platforms, GlobalAdapter->ZesResult);
+    ur_result_t err = initPlatforms(this, platforms, ZesResult);
     if (err == UR_RESULT_SUCCESS) {
-      result = std::move(platforms);
+      Platforms = std::move(platforms);
     } else {
-      result = err;
+      throw err;
     }
-  };
 }
 
 void globalAdapterOnDemandCleanup() {
@@ -623,15 +599,25 @@ ur_result_t urAdapterGet(
     /// ::urAdapterGet shall only retrieve that number of platforms.
     ur_adapter_handle_t *Adapters,
     /// [out][optional] returns the total number of adapters available.
-    uint32_t *NumAdapters) {
+    uint32_t *NumAdapters) try {
   static std::mutex AdapterConstructionMutex{};
 
-  if (NumEntries > 0 && Adapters) {
-    std::lock_guard<std::mutex> Lock{AdapterConstructionMutex};
+  // We need to initialize the adapter even if user only queries
+  // the number of adapters to decided whether to use V1 or V2.
+  std::lock_guard<std::mutex> Lock{AdapterConstructionMutex};
 
-    if (!GlobalAdapter) {
-      GlobalAdapter = new ur_adapter_handle_t_();
+  if (!GlobalAdapter) {
+    GlobalAdapter = new ur_adapter_handle_t_();
+  }
+
+  if (GlobalAdapter->Platforms.size() == 0) {
+    if (NumAdapters) {
+      *NumAdapters = 0;
     }
+    return UR_RESULT_ERROR_UNSUPPORTED_VERSION;
+  }
+
+  if (NumEntries && Adapters) {
     *Adapters = GlobalAdapter;
 
     if (GlobalAdapter->RefCount.retain() == 0) {
@@ -644,6 +630,10 @@ ur_result_t urAdapterGet(
   }
 
   return UR_RESULT_SUCCESS;
+} catch (ur_result_t result) {
+  return result;
+} catch (...) {
+  return UR_RESULT_ERROR_UNKNOWN;
 }
 
 ur_result_t urAdapterRelease([[maybe_unused]] ur_adapter_handle_t Adapter) {
diff --git a/unified-runtime/source/adapters/level_zero/adapter.hpp b/unified-runtime/source/adapters/level_zero/adapter.hpp
@@ -37,11 +37,7 @@ struct ur_adapter_handle_t_ : ur::handle_base<ur::level_zero::ddi_getter> {
   uint32_t ZeInitDriversCount = 0;
   bool InitDriversSupported = false;
 
-  ze_result_t ZeInitDriversResult;
-  ze_result_t ZeInitResult;
-  ze_result_t ZesResult;
-  std::optional<ze_result_t> ZeResult;
-  ZeCache<Result<PlatformVec>> PlatformCache;
+  PlatformVec Platforms;
   logger::Logger &logger;
   HMODULE processHandle = nullptr;
 
diff --git a/unified-runtime/source/adapters/level_zero/device.cpp b/unified-runtime/source/adapters/level_zero/device.cpp
@@ -1583,12 +1583,8 @@ ur_result_t urDeviceCreateWithNativeHandle(
   // a valid Level Zero device.
 
   ur_device_handle_t Dev = nullptr;
-  if (const auto *platforms = GlobalAdapter->PlatformCache->get_value()) {
-    for (const auto &p : *platforms) {
-      Dev = p->getDeviceFromNativeHandle(ZeDevice);
-    }
-  } else {
-    return GlobalAdapter->PlatformCache->get_error();
+  for (const auto &p : GlobalAdapter->Platforms) {
+    Dev = p->getDeviceFromNativeHandle(ZeDevice);
   }
 
   if (Dev == nullptr)
diff --git a/unified-runtime/source/adapters/level_zero/platform.cpp b/unified-runtime/source/adapters/level_zero/platform.cpp
diff --git a/unified-runtime/source/loader/ur_ldrddi.cpp b/unified-runtime/source/loader/ur_ldrddi.cpp
