[SYCL][UR] Update Unified Runtime tag to support UR_DEVICE_INFO_IP_VERSION

This should have been an obvious update of Unified Runtime sources to support
UR_DEVICE_INFO_IP_VERSION, required in
#9843, but this update brought
many API breaks mostly caused by this patch:
oneapi-src/unified-runtime#536

Author: dm-vodopyanov

sycl/plugins/unified_runtime/CMakeLists.txt

@@ -4,7 +4,7 @@ if (NOT DEFINED UNIFIED_RUNTIME_LIBRARY OR NOT DEFINED UNIFIED_RUNTIME_INCLUDE_D
   include(FetchContent)
 
   set(UNIFIED_RUNTIME_REPO "https://github.com/oneapi-src/unified-runtime.git")
-  set(UNIFIED_RUNTIME_TAG 4a9e53b0d7b15d9b0239864d13999f32e6c73bac)
+  set(UNIFIED_RUNTIME_TAG 9a9c05762ac672ecaf2c1bca815c54444a6ae457)
 
   message(STATUS "Will fetch Unified Runtime from ${UNIFIED_RUNTIME_REPO}")
   FetchContent_Declare(unified-runtime

sycl/plugins/unified_runtime/pi2ur.hpp

@@ -285,35 +285,37 @@ inline pi_result ur2piDeviceInfoValue(ur_device_info_t ParamName,
     return Value.convertBitSet<ur_device_affinity_domain_flag_t,
                                pi_device_affinity_domain>(ConvertFunc);
   } else if (ParamName == UR_DEVICE_INFO_PARTITION_TYPE) {
-    auto ConvertFunc = [](ur_device_partition_property_t UrValue) {
+    auto ConvertFunc = [](ur_device_partition_t UrValue) {
       switch (UrValue) {
       case UR_DEVICE_PARTITION_BY_AFFINITY_DOMAIN:
         return PI_DEVICE_PARTITION_BY_AFFINITY_DOMAIN;
       case UR_DEVICE_PARTITION_BY_CSLICE:
         return PI_EXT_INTEL_DEVICE_PARTITION_BY_CSLICE;
-      case (ur_device_partition_property_t)
+      case (ur_device_partition_t)
           UR_DEVICE_AFFINITY_DOMAIN_FLAG_NEXT_PARTITIONABLE:
         return (pi_device_partition_property)
             PI_DEVICE_AFFINITY_DOMAIN_NEXT_PARTITIONABLE;
       default:
         die("UR_DEVICE_INFO_PARTITION_TYPE: unhandled value");
       }
     };
-    return Value.convertArray<ur_device_partition_property_t,
-                              pi_device_partition_property>(ConvertFunc);
-  } else if (ParamName == UR_DEVICE_INFO_PARTITION_PROPERTIES) {
-    auto ConvertFunc = [](ur_device_partition_property_t UrValue) {
+    return Value
+        .convertArray<ur_device_partition_t, pi_device_partition_property>(
+            ConvertFunc);
+  } else if (ParamName == UR_DEVICE_INFO_SUPPORTED_PARTITIONS) {
+    auto ConvertFunc = [](ur_device_partition_t UrValue) {
       switch (UrValue) {
       case UR_DEVICE_PARTITION_BY_AFFINITY_DOMAIN:
         return PI_DEVICE_PARTITION_BY_AFFINITY_DOMAIN;
       case UR_DEVICE_PARTITION_BY_CSLICE:
         return PI_EXT_INTEL_DEVICE_PARTITION_BY_CSLICE;
       default:
-        die("UR_DEVICE_INFO_PARTITION_PROPERTIES: unhandled value");
+        die("UR_DEVICE_INFO_SUPPORTED_PARTITIONS: unhandled value");
       }
     };
-    return Value.convertArray<ur_device_partition_property_t,
-                              pi_device_partition_property>(ConvertFunc);
+    return Value
+        .convertArray<ur_device_partition_t, pi_device_partition_property>(
+            ConvertFunc);
   } else if (ParamName == UR_DEVICE_INFO_LOCAL_MEM_TYPE) {
     auto ConvertFunc = [](ur_device_local_mem_type_t UrValue) {
       switch (UrValue) {
@@ -777,7 +779,7 @@ inline pi_result piDeviceGetInfo(pi_device Device, pi_device_info ParamName,
     InfoType = UR_DEVICE_INFO_REFERENCE_COUNT;
     break;
   case PI_DEVICE_INFO_PARTITION_PROPERTIES:
-    InfoType = UR_DEVICE_INFO_PARTITION_PROPERTIES;
+    InfoType = UR_DEVICE_INFO_SUPPORTED_PARTITIONS;
     break;
   case PI_DEVICE_INFO_PARTITION_AFFINITY_DOMAIN:
     InfoType = UR_DEVICE_INFO_PARTITION_AFFINITY_DOMAIN;
@@ -1080,7 +1082,7 @@ inline pi_result piDevicePartition(
   if (!Properties || !Properties[0])
     return PI_ERROR_INVALID_VALUE;
 
-  ur_device_partition_property_t Property;
+  ur_device_partition_t Property;
   switch (Properties[0]) {
   case PI_DEVICE_PARTITION_EQUALLY:
     Property = UR_DEVICE_PARTITION_EQUALLY;
@@ -1120,12 +1122,20 @@ inline pi_result piDevicePartition(
   // TODO: correctly terminate the UR properties, see:
   // https://github.com/oneapi-src/unified-runtime/issues/183
   //
-  ur_device_partition_property_t UrProperties[] = {
-      ur_device_partition_property_t(Property), Value, 0};
+  ur_device_partition_property_t UrProperty;
+  UrProperty.type = Property;
+  UrProperty.value.equally = Value;
+
+  ur_device_partition_properties_t UrProperties{
+      UR_STRUCTURE_TYPE_DEVICE_PARTITION_PROPERTIES,
+      nullptr,
+      &UrProperty,
+      1,
+  };
 
   auto UrDevice = reinterpret_cast<ur_device_handle_t>(Device);
   auto UrSubDevices = reinterpret_cast<ur_device_handle_t *>(SubDevices);
-  HANDLE_ERRORS(urDevicePartition(UrDevice, UrProperties, NumEntries,
+  HANDLE_ERRORS(urDevicePartition(UrDevice, &UrProperties, NumEntries,
                                   UrSubDevices, NumSubDevices));
   return PI_SUCCESS;
 }

sycl/plugins/unified_runtime/ur/adapters/level_zero/ur_level_zero_device.cpp

@@ -281,7 +281,7 @@ UR_APIEXPORT ur_result_t UR_APICALL urDeviceGetInfo(
   }
   case UR_DEVICE_INFO_REFERENCE_COUNT:
     return ReturnValue(uint32_t{Device->RefCount.load()});
-  case UR_DEVICE_INFO_PARTITION_PROPERTIES: {
+  case UR_DEVICE_INFO_SUPPORTED_PARTITIONS: {
     // SYCL spec says: if this SYCL device cannot be partitioned into at least
     // two sub devices then the returned vector must be empty.
     auto Res = Device->Platform->populateDeviceCacheIfNeeded();
@@ -291,15 +291,15 @@ UR_APIEXPORT ur_result_t UR_APICALL urDeviceGetInfo(
 
     uint32_t ZeSubDeviceCount = Device->SubDevices.size();
     if (ZeSubDeviceCount < 2) {
-      return ReturnValue((ur_device_partition_property_t)0);
+      return ReturnValue((ur_device_partition_t)0);
     }
     bool PartitionedByCSlice = Device->SubDevices[0]->isCCS();
 
     auto ReturnHelper = [&](auto... Partitions) {
       struct {
         ur_device_partition_property_t Arr[sizeof...(Partitions) + 1];
       } PartitionProperties = {
-          {Partitions..., ur_device_partition_property_t(0)}};
+          {Partitions..., ur_device_partition_t(0)}};
       return ReturnValue(PartitionProperties);
     };
 
@@ -324,23 +324,23 @@ UR_APIEXPORT ur_result_t UR_APICALL urDeviceGetInfo(
   case UR_DEVICE_INFO_PARTITION_TYPE: {
     // For root-device there is no partitioning to report.
     if (!Device->isSubDevice())
-      return ReturnValue(ur_device_partition_property_t(0));
+      return ReturnValue(ur_device_partition_t(0));
 
     if (Device->isCCS()) {
       struct {
         ur_device_partition_property_t Arr[2];
       } PartitionProperties = {
-          {UR_DEVICE_PARTITION_BY_CSLICE, ur_device_partition_property_t(0)}};
+          {UR_DEVICE_PARTITION_BY_CSLICE, ur_device_partition_t(0)}};
       return ReturnValue(PartitionProperties);
     }
 
     struct {
       ur_device_partition_property_t Arr[3];
     } PartitionProperties = {
         {UR_DEVICE_PARTITION_BY_AFFINITY_DOMAIN,
-         (ur_device_partition_property_t)
+         (ur_device_partition_t)
              UR_DEVICE_AFFINITY_DOMAIN_FLAG_NEXT_PARTITIONABLE,
-         ur_device_partition_property_t(0)}};
+         ur_device_partition_t(0)}};
     return ReturnValue(PartitionProperties);
   }
 
@@ -1088,9 +1088,8 @@ void ZeUSMImportExtension::doZeUSMRelease(ze_driver_handle_t DriverHandle,
 
 UR_APIEXPORT ur_result_t UR_APICALL urDevicePartition(
     ur_device_handle_t Device, ///< [in] handle of the device to partition.
-    const ur_device_partition_property_t
-        *Properties, ///< [in] null-terminated array of <$_device_partition_t
-                     ///< enum, value> pairs.
+    const ur_device_partition_properties_t
+        *Properties,     ///< [in] Device partition properties.
     uint32_t NumDevices, ///< [in] the number of sub-devices.
     ur_device_handle_t
         *OutDevices, ///< [out][optional][range(0, NumDevices)] array of handle
@@ -1102,13 +1101,15 @@ UR_APIEXPORT ur_result_t UR_APICALL urDevicePartition(
                             ///< according to the partitioning property.
 ) {
   // Other partitioning ways are not supported by Level Zero
-  if (Properties[0] == UR_DEVICE_PARTITION_BY_AFFINITY_DOMAIN) {
-    if ((Properties[1] != UR_DEVICE_AFFINITY_DOMAIN_FLAG_NEXT_PARTITIONABLE &&
-         Properties[1] != UR_DEVICE_AFFINITY_DOMAIN_FLAG_NUMA)) {
+  if (Properties->pProperties->type == UR_DEVICE_PARTITION_BY_AFFINITY_DOMAIN) {
+    if ((Properties->pProperties->value.affinity_domain !=
+             UR_DEVICE_AFFINITY_DOMAIN_FLAG_NEXT_PARTITIONABLE &&
+         Properties->pProperties->value.affinity_domain !=
+             UR_DEVICE_AFFINITY_DOMAIN_FLAG_NUMA)) {
       return UR_RESULT_ERROR_INVALID_VALUE;
     }
-  } else if (Properties[0] == UR_DEVICE_PARTITION_BY_CSLICE) {
-    if (Properties[1] != 0) {
+  } else if (Properties->pProperties->type == UR_DEVICE_PARTITION_BY_CSLICE) {
+    if (Properties->pProperties->value.affinity_domain != 0) {
       return UR_RESULT_ERROR_INVALID_VALUE;
     }
   } else {
@@ -1132,13 +1133,14 @@ UR_APIEXPORT ur_result_t UR_APICALL urDevicePartition(
     // UR_L0_EXPOSE_CSLICE_IN_AFFINITY_PARTITIONING overrides that
     // still expose CSlices in partitioning by affinity domain for compatibility
     // reasons.
-    if (Properties[0] == UR_DEVICE_PARTITION_BY_AFFINITY_DOMAIN &&
+    if (Properties->pProperties->type ==
+            UR_DEVICE_PARTITION_BY_AFFINITY_DOMAIN &&
         !ExposeCSliceInAffinityPartitioning) {
       if (Device->isSubDevice()) {
         return 0;
       }
     }
-    if (Properties[0] == UR_DEVICE_PARTITION_BY_CSLICE) {
+    if (Properties->pProperties->type == UR_DEVICE_PARTITION_BY_CSLICE) {
       // Not a CSlice-based partitioning.
       if (!Device->SubDevices[0]->isCCS()) {
         return 0;