Add support for getting device LUID on windows (#19349)

Adds a new aspect to get device LUID. This feature is only available on
Windows and allows for device matching when performing SYCL/DirectX
interop

Author: DBDuncan

include/ur_api.h

@@ -464,6 +464,10 @@ etors:
       desc: "[$x_bool_t] support for native bfloat16 conversions"
     - name: KERNEL_LAUNCH_CAPABILITIES
       desc: "[$x_kernel_launch_properties_flags_t] Bitfield of supported kernel launch properties."
+    - name: LUID
+      desc: "[uint8_t[]][optional-query] return device Windows LUID"
+    - name: NODE_MASK
+      desc: "[uint32_t][optional-query] return device Windows node mask"
 --- #--------------------------------------------------------------------------
 type: function
 desc: "Retrieves various information about device"

include/ur_print.hpp

@@ -1186,6 +1186,44 @@ UR_APIEXPORT ur_result_t UR_APICALL urDeviceGetInfo(ur_device_handle_t hDevice,
 
     return ReturnValue(0);
   }
+  case UR_DEVICE_INFO_LUID: {
+    // LUID is only available on Windows.
+    // Intel extension for device LUID. This returns the LUID as
+    // std::array<std::byte, 8>. For details about this extension,
+    // see sycl/doc/extensions/supported/sycl_ext_intel_device_info.md.
+    std::array<char, 8> LUID{};
+    cuDeviceGetLuid(LUID.data(), nullptr, hDevice->get());
+
+    bool isAllZeros = true;
+    for (char num : LUID) {
+      if (num != 0) {
+        isAllZeros = false;
+      }
+    }
+
+    if (isAllZeros) {
+      return UR_RESULT_ERROR_UNSUPPORTED_FEATURE;
+    }
+
+    std::array<unsigned char, 8> Name{};
+    std::copy(LUID.begin(), LUID.end(), Name.begin());
+    return ReturnValue(Name.data(), 8);
+  }
+  case UR_DEVICE_INFO_NODE_MASK: {
+    // Device node mask is only available on Windows.
+    // Intel extension for device node mask. This returns the node mask as
+    // uint32_t. For details about this extension,
+    // see sycl/doc/extensions/supported/sycl_ext_intel_device_info.md.
+    uint32_t nodeMask = 0;
+    cuDeviceGetLuid(nullptr, &nodeMask, hDevice->get());
+
+    // If nodeMask has not changed, return unsupported.
+    if (nodeMask == 0) {
+      return UR_RESULT_ERROR_UNSUPPORTED_FEATURE;
+    }
+
+    return ReturnValue(nodeMask);
+  }
   default:
     break;
   }

scripts/core/device.yml

@@ -1381,6 +1381,48 @@ ur_result_t urDeviceGetInfo(
   }
   case UR_DEVICE_INFO_KERNEL_LAUNCH_CAPABILITIES:
     return ReturnValue(UR_KERNEL_LAUNCH_PROPERTIES_FLAG_COOPERATIVE);
+  case UR_DEVICE_INFO_LUID: {
+    // LUID is only available on Windows.
+    // Intel extension for device LUID. This returns the LUID as
+    // std::array<std::byte, 8>. For details about this extension,
+    // see sycl/doc/extensions/supported/sycl_ext_intel_device_info.md.
+    if (Device->Platform->ZeLUIDSupported) {
+      ze_device_properties_t DeviceProp = {};
+      DeviceProp.stype = ZE_STRUCTURE_TYPE_DEVICE_PROPERTIES;
+      ze_device_luid_ext_properties_t LuidDesc = {};
+      LuidDesc.stype = ZE_STRUCTURE_TYPE_DEVICE_LUID_EXT_PROPERTIES;
+      DeviceProp.pNext = (void *)&LuidDesc;
+
+      ZE2UR_CALL(zeDeviceGetProperties, (ZeDevice, &DeviceProp));
+
+      const auto &LUID = LuidDesc.luid.id;
+      return ReturnValue(LUID, sizeof(LUID));
+    } else {
+      return UR_RESULT_ERROR_UNSUPPORTED_FEATURE;
+    }
+  }
+  case UR_DEVICE_INFO_NODE_MASK: {
+    // Device node mask is only available on Windows.
+    // Intel extension for device node mask. This returns the node mask as
+    // uint32_t. For details about this extension,
+    // see sycl/doc/extensions/supported/sycl_ext_intel_device_info.md.
+
+    // Node mask is provided through the L0 LUID extension so support for this
+    // extension must be checked.
+    if (Device->Platform->ZeLUIDSupported) {
+      ze_device_properties_t DeviceProp = {};
+      DeviceProp.stype = ZE_STRUCTURE_TYPE_DEVICE_PROPERTIES;
+      ze_device_luid_ext_properties_t LuidDesc = {};
+      LuidDesc.stype = ZE_STRUCTURE_TYPE_DEVICE_LUID_EXT_PROPERTIES;
+      DeviceProp.pNext = (void *)&LuidDesc;
+
+      ZE2UR_CALL(zeDeviceGetProperties, (ZeDevice, &DeviceProp));
+
+      return ReturnValue(LuidDesc.nodeMask);
+    } else {
+      return UR_RESULT_ERROR_UNSUPPORTED_FEATURE;
+    }
+  }
   default:
     UR_LOG(ERR, "Unsupported ParamName in urGetDeviceInfo");
     UR_LOG(ERR, "ParamNameParamName={}(0x{})", ParamName,

source/adapters/cuda/device.cpp

@@ -295,6 +295,12 @@ ur_result_t ur_platform_handle_t_::initialize() {
         ZeBindlessImagesExtensionSupported = true;
       }
     }
+    if (strncmp(extension.name, ZE_DEVICE_LUID_EXT_NAME,
+                strlen(ZE_DEVICE_LUID_EXT_NAME) + 1) == 0) {
+      if (extension.version == ZE_DEVICE_LUID_EXT_VERSION_1_0) {
+        ZeLUIDSupported = true;
+      }
+    }
     zeDriverExtensionMap[extension.name] = extension.version;
   }
 

source/adapters/level_zero/device.cpp

@@ -69,6 +69,7 @@ struct ur_platform_handle_t_ : ur::handle_base<ur::level_zero::ddi_getter>,
   bool ZeDriverEuCountExtensionFound{false};
   bool ZeCopyOffloadExtensionSupported{false};
   bool ZeBindlessImagesExtensionSupported{false};
+  bool ZeLUIDSupported{false};
 
   // Cache UR devices for reuse
   std::vector<std::unique_ptr<ur_device_handle_t_>> URDevicesCache;

source/adapters/level_zero/platform.cpp

@@ -1418,6 +1418,59 @@ UR_APIEXPORT ur_result_t UR_APICALL urDeviceGetInfo(ur_device_handle_t hDevice,
     return ReturnValue(true);
   case UR_DEVICE_INFO_KERNEL_LAUNCH_CAPABILITIES:
     return ReturnValue(0);
+  case UR_DEVICE_INFO_LUID: {
+    // LUID is only available on Windows.
+    // Intel extension for device LUID. This returns the LUID as
+    // std::array<std::byte, 8>. For details about this extension,
+    // see sycl/doc/extensions/supported/sycl_ext_intel_device_info.md.
+
+    // Use the cl_khr_device_uuid extension, if available.
+    bool isKhrDeviceLuidSupported = false;
+    if (hDevice->checkDeviceExtensions({"cl_khr_device_uuid"},
+                                       isKhrDeviceLuidSupported) !=
+            UR_RESULT_SUCCESS ||
+        !isKhrDeviceLuidSupported) {
+      return UR_RESULT_ERROR_UNSUPPORTED_ENUMERATION;
+    }
+
+    cl_bool isLuidValid;
+    CL_RETURN_ON_FAILURE(
+        clGetDeviceInfo(hDevice->CLDevice, CL_DEVICE_LUID_VALID_KHR,
+                        sizeof(cl_bool), &isLuidValid, nullptr));
+
+    if (!isLuidValid) {
+      return UR_RESULT_ERROR_UNSUPPORTED_ENUMERATION;
+    }
+
+    static_assert(CL_LUID_SIZE_KHR == 8);
+    std::array<unsigned char, CL_LUID_SIZE_KHR> UUID{};
+    CL_RETURN_ON_FAILURE(clGetDeviceInfo(hDevice->CLDevice, CL_DEVICE_LUID_KHR,
+                                         UUID.size(), UUID.data(), nullptr));
+    return ReturnValue(UUID);
+  }
+  case UR_DEVICE_INFO_NODE_MASK: {
+    // Device node mask is only available on Windows.
+    // Intel extension for device node mask. This returns the node mask as
+    // uint32_t. For details about this extension,
+    // see sycl/doc/extensions/supported/sycl_ext_intel_device_info.md.
+
+    // Use the cl_khr_device_uuid extension, if available.
+    bool isKhrDeviceLuidSupported = false;
+    if (hDevice->checkDeviceExtensions({"cl_khr_device_uuid"},
+                                       isKhrDeviceLuidSupported) !=
+            UR_RESULT_SUCCESS ||
+        !isKhrDeviceLuidSupported) {
+      return UR_RESULT_ERROR_UNSUPPORTED_ENUMERATION;
+    }
+
+    cl_int nodeMask = 0;
+
+    CL_RETURN_ON_FAILURE(clGetDeviceInfo(hDevice->CLDevice,
+                                         CL_DEVICE_NODE_MASK_KHR,
+                                         sizeof(cl_int), &nodeMask, nullptr));
+
+    return ReturnValue(nodeMask);
+  }
   // TODO: We can't query to check if these are supported, they will need to be
   // manually updated if support is ever implemented.
   case UR_DEVICE_INFO_KERNEL_SET_SPECIALIZATION_CONSTANTS: