[sycl-rel] Cherry-pick UR patches (#18884)

Cherry-pick commits that reached the internal branch between intel/llvm
cutoff and release branch pulldown.

Patches included:

---

[Coverity][UR] Remove noexcept keywords from pool_manager methods (#17678)

This should fix coverity issues in `ur_pool_manager.hpp`, `ur_util.hpp`
and `ur_adapter_registry.hpp` files reported in:
https://coverity.devtools.intel.com/prod6/#/project-view/26752/10020

Patch-by: Krzysztof Święcicki <[email protected]>

---

[UR][L0] Enable support for using L0 spec External Semaphores (#17671)

- Implements the spec version of the L0 Extension External Semaphores
- Implements handling the translation of handles if the driver only
supports the EXP functions.

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

---

[UR][L0] Memory interop support given external buffer (#17458)

Enable L0 to directly import the memory allocated for NPU/iGPU and let
SYCL kernel running on iGPU be able to directly access the data it will
reduce the overhead of data movement between NPU/iGPU and iGPU.

Patch-by: Zhang, Winston <[email protected]>
Co-authored-by: Peter Žužek <[email protected]>

---

[UR] Fix Loader Negative Prefilters (#17528)

This commit fixes #17086.

Patch-by: Isaac Ault <[email protected]>

---

[UR] Remove unnecessary null pointer check in OpenCL command buffer code, and update declaration of filter lamba to avoid copies (#17615)

Patch-by: Martin Grant <[email protected]>

Author: KornevNikita

unified-runtime/scripts/core/manifests.yml

@@ -1,3 +1,14 @@
+#
+# Copyright (C) 2025 Intel Corporation
+#
+# Part of the Unified-Runtime Project, under the Apache License v2.0 with LLVM Exceptions.
+# See LICENSE.TXT
+# SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+#
+# See YaML.md for syntax definition
+#
+# NOTE: device_types must be explictly listed. Refrain from using 
+#       $X_DEVICE_TYPE_ALL. See https://github.com/intel/llvm/issues/17527.
 --- #--------------------------------------------------------------------------
 type: header
 desc: "Intel $OneApi Unified Runtime adapter manifests"
@@ -7,7 +18,11 @@ type: manifest
 name: opencl
 backend: $X_ADAPTER_BACKEND_OPENCL
 device_types:
-    - $X_DEVICE_TYPE_ALL
+    - $X_DEVICE_TYPE_CPU
+    - $X_DEVICE_TYPE_GPU
+    - $X_DEVICE_TYPE_FPGA
+    - $X_DEVICE_TYPE_MCA
+    - $X_DEVICE_TYPE_VPU
 --- #--------------------------------------------------------------------------
 type: manifest
 name: cuda
@@ -25,13 +40,21 @@ type: manifest
 name: level_zero
 backend: $X_ADAPTER_BACKEND_LEVEL_ZERO
 device_types:
-    - $X_DEVICE_TYPE_ALL
+    - $X_DEVICE_TYPE_CPU
+    - $X_DEVICE_TYPE_GPU
+    - $X_DEVICE_TYPE_FPGA
+    - $X_DEVICE_TYPE_MCA
+    - $X_DEVICE_TYPE_VPU
 --- #--------------------------------------------------------------------------
 type: manifest
 name: level_zero_v2
 backend: $X_ADAPTER_BACKEND_LEVEL_ZERO
 device_types:
-    - $X_DEVICE_TYPE_ALL
+    - $X_DEVICE_TYPE_CPU
+    - $X_DEVICE_TYPE_GPU
+    - $X_DEVICE_TYPE_FPGA
+    - $X_DEVICE_TYPE_MCA
+    - $X_DEVICE_TYPE_VPU
 --- #--------------------------------------------------------------------------
 type: manifest
 name: native_cpu

unified-runtime/source/adapters/level_zero/device.cpp

@@ -1119,8 +1119,8 @@ ur_result_t urDeviceGetInfo(
     return ReturnValue(false);
   }
   case UR_DEVICE_INFO_EXTERNAL_MEMORY_IMPORT_SUPPORT_EXP: {
-    // L0 does not support importing external memory.
-    return ReturnValue(false);
+    // L0 supports importing external memory.
+    return ReturnValue(true);
   }
   case UR_DEVICE_INFO_EXTERNAL_SEMAPHORE_IMPORT_SUPPORT_EXP: {
     return ReturnValue(Device->Platform->ZeExternalSemaphoreExt.Supported);

unified-runtime/source/adapters/level_zero/image.cpp

@@ -227,6 +227,7 @@ ur_result_t ur_platform_handle_t_::initialize() {
 
   bool MutableCommandListSpecExtensionSupported = false;
   bool ZeIntelExternalSemaphoreExtensionSupported = false;
+  bool ZeExternalSemaphoreExtensionSupported = false;
   bool ZeImmediateCommandListAppendExtensionFound = false;
   for (auto &extension : ZeExtensions) {
     // Check if global offset extension is available
@@ -267,13 +268,20 @@ ur_result_t ur_platform_handle_t_::initialize() {
         MutableCommandListSpecExtensionSupported = true;
       }
     }
-    // Check if extension is available for External Sempahores
+    // Check if extension is available for Exp External Sempahores
     if (strncmp(extension.name, ZE_INTEL_EXTERNAL_SEMAPHORE_EXP_NAME,
                 strlen(ZE_INTEL_EXTERNAL_SEMAPHORE_EXP_NAME) + 1) == 0) {
       if (extension.version == ZE_EXTERNAL_SEMAPHORE_EXP_VERSION_1_0) {
         ZeIntelExternalSemaphoreExtensionSupported = true;
       }
     }
+    // Check if extension is available for Spec External Sempahores
+    if (strncmp(extension.name, ZE_EXTERNAL_SEMAPHORES_EXTENSION_NAME,
+                strlen(ZE_EXTERNAL_SEMAPHORES_EXTENSION_NAME) + 1) == 0) {
+      if (extension.version == ZE_EXTERNAL_SEMAPHORE_EXT_VERSION_1_0) {
+        ZeExternalSemaphoreExtensionSupported = true;
+      }
+    }
     if (strncmp(extension.name, ZE_EU_COUNT_EXT_NAME,
                 strlen(ZE_EU_COUNT_EXT_NAME) + 1) == 0) {
       if (extension.version == ZE_EU_COUNT_EXT_VERSION_1_0) {
@@ -323,36 +331,83 @@ ur_result_t ur_platform_handle_t_::initialize() {
   // If yes, then set up L0 API pointers if the platform supports it.
   ZeUSMImport.setZeUSMImport(this);
 
-  if (ZeIntelExternalSemaphoreExtensionSupported) {
+  if (ZeExternalSemaphoreExtensionSupported) {
+#ifdef UR_STATIC_LEVEL_ZERO
+    ZeExternalSemaphoreExt.zexImportExternalSemaphoreExp =
+        zeDeviceImportExternalSemaphoreExt;
+    ZeExternalSemaphoreExt.zexCommandListAppendWaitExternalSemaphoresExp =
+        zeCommandListAppendWaitExternalSemaphoreExt;
+    ZeExternalSemaphoreExt.zexCommandListAppendSignalExternalSemaphoresExp =
+        zeCommandListAppendSignalExternalSemaphoreExt;
+    ZeExternalSemaphoreExt.zexDeviceReleaseExternalSemaphoreExp =
+        zeDeviceReleaseExternalSemaphoreExt;
+#else
+    ZeExternalSemaphoreExt.zexImportExternalSemaphoreExp =
+        (ze_pfnDeviceImportExternalSemaphoreExt_t)
+            ur_loader::LibLoader::getFunctionPtr(
+                GlobalAdapter->processHandle,
+                "zeDeviceImportExternalSemaphoreExt");
+
+    ZeExternalSemaphoreExt.zexCommandListAppendWaitExternalSemaphoresExp =
+        (ze_pfnCommandListAppendWaitExternalSemaphoreExt_t)
+            ur_loader::LibLoader::getFunctionPtr(
+                GlobalAdapter->processHandle,
+                "zeCommandListAppendWaitExternalSemaphoreExt");
+
+    ZeExternalSemaphoreExt.zexCommandListAppendSignalExternalSemaphoresExp =
+        (ze_pfnCommandListAppendSignalExternalSemaphoreExt_t)
+            ur_loader::LibLoader::getFunctionPtr(
+                GlobalAdapter->processHandle,
+                "zeCommandListAppendSignalExternalSemaphoreExt");
+
+    ZeExternalSemaphoreExt.zexDeviceReleaseExternalSemaphoreExp =
+        (ze_pfnDeviceReleaseExternalSemaphoreExt_t)
+            ur_loader::LibLoader::getFunctionPtr(
+                GlobalAdapter->processHandle,
+                "zeDeviceReleaseExternalSemaphoreExt");
+#endif
+    ZeExternalSemaphoreExt.Supported |=
+        ZeExternalSemaphoreExt.zexImportExternalSemaphoreExp != nullptr;
+    ZeExternalSemaphoreExt.Supported |=
+        ZeExternalSemaphoreExt.zexCommandListAppendWaitExternalSemaphoresExp !=
+        nullptr;
+    ZeExternalSemaphoreExt.Supported |=
+        ZeExternalSemaphoreExt
+            .zexCommandListAppendSignalExternalSemaphoresExp != nullptr;
+    ZeExternalSemaphoreExt.Supported |=
+        ZeExternalSemaphoreExt.zexDeviceReleaseExternalSemaphoreExp != nullptr;
+    ZeExternalSemaphoreExt.LoaderExtension = true;
+  } else if (ZeIntelExternalSemaphoreExtensionSupported) {
     ZeExternalSemaphoreExt.Supported |=
         (ZE_CALL_NOCHECK(
              zeDriverGetExtensionFunctionAddress,
              (ZeDriver, "zeIntelDeviceImportExternalSemaphoreExp",
               reinterpret_cast<void **>(
-                  &ZeExternalSemaphoreExt.zexImportExternalSemaphoreExp))) ==
+                  &ZeExternalSemaphoreExt.zexExpImportExternalSemaphoreExp))) ==
          0);
     ZeExternalSemaphoreExt.Supported |=
         (ZE_CALL_NOCHECK(
              zeDriverGetExtensionFunctionAddress,
              (ZeDriver, "zeIntelCommandListAppendWaitExternalSemaphoresExp",
               reinterpret_cast<void **>(
                   &ZeExternalSemaphoreExt
-                       .zexCommandListAppendWaitExternalSemaphoresExp))) == 0);
+                       .zexExpCommandListAppendWaitExternalSemaphoresExp))) ==
+         0);
     ZeExternalSemaphoreExt.Supported |=
         (ZE_CALL_NOCHECK(
              zeDriverGetExtensionFunctionAddress,
              (ZeDriver, "zeIntelCommandListAppendSignalExternalSemaphoresExp",
               reinterpret_cast<void **>(
                   &ZeExternalSemaphoreExt
-                       .zexCommandListAppendSignalExternalSemaphoresExp))) ==
+                       .zexExpCommandListAppendSignalExternalSemaphoresExp))) ==
          0);
     ZeExternalSemaphoreExt.Supported |=
-        (ZE_CALL_NOCHECK(zeDriverGetExtensionFunctionAddress,
-                         (ZeDriver, "zeIntelDeviceReleaseExternalSemaphoreExp",
-                          reinterpret_cast<void **>(
-                              &ZeExternalSemaphoreExt
-                                   .zexDeviceReleaseExternalSemaphoreExp))) ==
-         0);
+        (ZE_CALL_NOCHECK(
+             zeDriverGetExtensionFunctionAddress,
+             (ZeDriver, "zeIntelDeviceReleaseExternalSemaphoreExp",
+              reinterpret_cast<void **>(
+                  &ZeExternalSemaphoreExt
+                       .zexExpDeviceReleaseExternalSemaphoreExp))) == 0);
   }
 
   // Check if mutable command list extension is supported and initialize

unified-runtime/source/adapters/level_zero/platform.cpp

@@ -126,20 +126,36 @@ struct ur_platform_handle_t_ : public _ur_platform {
   // Structure with function pointers for External Semaphore Extension.
   struct ZeExternalSemaphoreExtension {
     bool Supported = false;
-    ze_result_t (*zexImportExternalSemaphoreExp)(
+    // If LoaderExtension is true, the L0 loader is aware of the External
+    // Semaphore Extension. If it is false, the extension has to be loaded
+    // directly from the driver using zeDriverGetExtensionFunctionAddress. If it
+    // is loaded directly from the driver, any handles passed to it must be
+    // translated using zelLoaderTranslateHandle.
+    bool LoaderExtension = false;
+    // Spec Functions
+    ze_pfnDeviceImportExternalSemaphoreExt_t zexImportExternalSemaphoreExp =
+        nullptr;
+    ze_pfnCommandListAppendWaitExternalSemaphoreExt_t
+        zexCommandListAppendWaitExternalSemaphoresExp = nullptr;
+    ze_pfnCommandListAppendSignalExternalSemaphoreExt_t
+        zexCommandListAppendSignalExternalSemaphoresExp = nullptr;
+    ze_pfnDeviceReleaseExternalSemaphoreExt_t
+        zexDeviceReleaseExternalSemaphoreExp = nullptr;
+    // Driver EXP Functions
+    ze_result_t (*zexExpImportExternalSemaphoreExp)(
         ze_device_handle_t, const ze_intel_external_semaphore_exp_desc_t *,
         ze_intel_external_semaphore_exp_handle_t *);
-    ze_result_t (*zexCommandListAppendWaitExternalSemaphoresExp)(
+    ze_result_t (*zexExpCommandListAppendWaitExternalSemaphoresExp)(
         ze_command_list_handle_t, unsigned int,
         const ze_intel_external_semaphore_exp_handle_t *,
         const ze_intel_external_semaphore_wait_params_exp_t *,
         ze_event_handle_t, uint32_t, ze_event_handle_t *);
-    ze_result_t (*zexCommandListAppendSignalExternalSemaphoresExp)(
+    ze_result_t (*zexExpCommandListAppendSignalExternalSemaphoresExp)(
         ze_command_list_handle_t, size_t,
         const ze_intel_external_semaphore_exp_handle_t *,
         const ze_intel_external_semaphore_signal_params_exp_t *,
         ze_event_handle_t, uint32_t, ze_event_handle_t *);
-    ze_result_t (*zexDeviceReleaseExternalSemaphoreExp)(
+    ze_result_t (*zexExpDeviceReleaseExternalSemaphoreExp)(
         ze_intel_external_semaphore_exp_handle_t);
   } ZeExternalSemaphoreExt;
 

unified-runtime/source/adapters/level_zero/platform.hpp

@@ -36,8 +36,7 @@ UR_APIEXPORT ur_result_t UR_APICALL urCommandBufferCreateExp(
   ur_queue_handle_t Queue = nullptr;
   ur_queue_properties_t QueueProperties = {UR_STRUCTURE_TYPE_QUEUE_PROPERTIES,
                                            nullptr, 0};
-  const bool IsInOrder =
-      pCommandBufferDesc ? pCommandBufferDesc->isInOrder : false;
+  const bool IsInOrder = pCommandBufferDesc->isInOrder;
   if (!IsInOrder) {
     QueueProperties.flags = UR_QUEUE_FLAG_OUT_OF_ORDER_EXEC_MODE_ENABLE;
   }

unified-runtime/source/adapters/opencl/command_buffer.cpp

@@ -174,7 +174,7 @@ template <typename D, typename H> struct pool_manager {
     return {UR_RESULT_SUCCESS, std::move(manager)};
   }
 
-  ur_result_t addPool(const D &desc, unique_pool_handle_t &&hPool) noexcept {
+  ur_result_t addPool(const D &desc, unique_pool_handle_t &&hPool) {
     if (!descToPoolMap.try_emplace(desc, std::move(hPool)).second) {
       logger::error("Pool for pool descriptor: {}, already exists", desc);
       return UR_RESULT_ERROR_INVALID_ARGUMENT;
@@ -183,7 +183,7 @@ template <typename D, typename H> struct pool_manager {
     return UR_RESULT_SUCCESS;
   }
 
-  std::optional<pool_handle_t> getPool(const D &desc) noexcept {
+  std::optional<pool_handle_t> getPool(const D &desc) {
     auto it = descToPoolMap.find(desc);
     if (it == descToPoolMap.end()) {
       logger::error("Pool descriptor doesn't match any existing pool: {}",
@@ -193,7 +193,7 @@ template <typename D, typename H> struct pool_manager {
 
     return it->second.get();
   }
-  template <typename Func> void forEachPool(Func func) noexcept {
+  template <typename Func> void forEachPool(Func func) {
     for (const auto &[desc, pool] : descToPoolMap) {
       if (!func(pool.get()))
         break;

unified-runtime/source/common/ur_pool_manager.hpp

@@ -278,7 +278,7 @@ inline std::optional<EnvVarMap> getenv_to_map(const char *env_var_name,
     if (map.find(key) != map.end()) {
       map[key].insert(map[key].end(), values_vec.begin(), values_vec.end());
     } else {
-      map[key] = values_vec;
+      map[key] = std::move(values_vec);
     }
   }
   return map;

unified-runtime/source/common/ur_util.hpp

@@ -24,6 +24,11 @@ namespace fs = filesystem;
 
 namespace ur_loader {
 
+struct ur_device_tuple {
+  ur_adapter_backend_t backend;
+  ur_device_type_t device;
+};
+
 // Helper struct representing a ONEAPI_DEVICE_SELECTOR filter term.
 struct FilterTerm {
   std::string backend;
@@ -37,7 +42,7 @@ struct FilterTerm {
       {"native_cpu", UR_ADAPTER_BACKEND_NATIVE_CPU},
   };
 
-  bool matchesBackend(const ur_adapter_manifest &manifest) const {
+  bool matchesBackend(const ur_adapter_backend_t &match_backend) const {
     if (backend.front() == '*') {
       return true;
     }
@@ -49,7 +54,7 @@ struct FilterTerm {
           backend);
       return false;
     }
-    if (backendIter->second == manifest.backend) {
+    if (backendIter->second == match_backend) {
       return true;
     }
     return false;
@@ -60,12 +65,7 @@ struct FilterTerm {
       {"gpu", UR_DEVICE_TYPE_GPU},
       {"fpga", UR_DEVICE_TYPE_FPGA}};
 
-  bool matchesDevices(const ur_adapter_manifest &manifest) const {
-    // If the adapter can report all device types then it matches.
-    if (std::find(manifest.device_types.begin(), manifest.device_types.end(),
-                  UR_DEVICE_TYPE_ALL) != manifest.device_types.end()) {
-      return true;
-    }
+  bool matchesDevices(const ur_device_type_t &match_device) const {
     for (auto deviceString : devices) {
       // We don't have a way to determine anything about device indices or
       // sub-devices at this stage so just match any numeric value we get.
@@ -79,20 +79,19 @@ struct FilterTerm {
             deviceString);
         continue;
       }
-      if (std::find(manifest.device_types.begin(), manifest.device_types.end(),
-                    deviceIter->second) != manifest.device_types.end()) {
+      if (deviceIter->second == match_device) {
         return true;
       }
     }
     return false;
   }
 
-  bool matches(const ur_adapter_manifest &manifest) const {
-    if (!matchesBackend(manifest)) {
+  bool matches(const ur_device_tuple &device_tuple) const {
+    if (!matchesBackend(device_tuple.backend)) {
       return false;
     }
 
-    return matchesDevices(manifest);
+    return matchesDevices(device_tuple.device);
   }
 };
 
@@ -278,24 +277,34 @@ class AdapterRegistry {
                      [](unsigned char c) { return std::tolower(c); });
 
       if (PositiveFilter) {
-        positiveFilters.push_back({backend, termPair.second});
+        positiveFilters.push_back({std::move(backend), termPair.second});
       } else {
-        // To preserve the behaviour of the original pre-filter implementation,
-        // we interpret all negative filters as backend only. This isn't
-        // correct, see https://github.com/intel/llvm/issues/17086
-        negativeFilters.push_back({backend, {"*"}});
+        negativeFilters.push_back({std::move(backend), termPair.second});
       }
     }
 
+    // If ONEAPI_DEVICE_SELECTOR only specified negative filters then we
+    // implicitly add a positive filter accepting all backends and devices.
+    if (positiveFilters.empty()) {
+      positiveFilters.push_back({"*", {"*"}});
+    }
+
     for (const auto &manifest : ur_adapter_manifests) {
-      auto matchesFilter = [manifest](const FilterTerm &f) -> bool {
-        return f.matches(manifest);
-      };
-      if (std::any_of(positiveFilters.begin(), positiveFilters.end(),
-                      matchesFilter) &&
-          std::none_of(negativeFilters.begin(), negativeFilters.end(),
-                       matchesFilter)) {
-        adapterNames.insert(manifest.library);
+      // Check each device in the manifest.
+      for (const auto &device : manifest.device_types) {
+        ur_device_tuple single_device = {manifest.backend, device};
+
+        const auto matchesFilter =
+            [single_device](const FilterTerm &f) -> bool {
+          return f.matches(single_device);
+        };
+
+        if (std::any_of(positiveFilters.begin(), positiveFilters.end(),
+                        matchesFilter) &&
+            std::none_of(negativeFilters.begin(), negativeFilters.end(),
+                         matchesFilter)) {
+          adapterNames.insert(manifest.library);
+        }
       }
     }