Add support for luid and node mask in opencl backend and tests

Author: DBDuncan

sycl/test-e2e/Adapters/luid-opencl.cpp

@@ -0,0 +1,46 @@
+// REQUIRES: aspect-ext_intel_device_info_luid
+// REQUIRES: gpu, opencl, windows
+
+// RUN: %{build} -o %t.out %opencl_lib
+// RUN: %{run} %t.out
+
+// Test that the LUID is read correctly from OpenCL.
+
+#include <iomanip>
+#include <iostream>
+#include <sstream>
+#include <sycl/backend.hpp>
+#include <sycl/detail/core.hpp>
+
+int main() {
+  sycl::device dev;
+  auto luid = dev.get_info<sycl::ext::intel::info::device::luid>();
+
+  std::stringstream luidSYCLHex;
+  for (int i = 0; i < luid.size(); ++i) {
+    luidSYCLHex << std::hex << std::setw(2) << std::setfill('0')
+                << int(luid[i]);
+  }
+  std::cout << "SYCL: " << luidSYCLHex.str() << std::endl;
+
+  auto openclDevice = sycl::get_native<sycl::backend::opencl>(dev);
+
+  char *luidOpencl = nullptr;
+
+  clGetDeviceInfo(openclDevice, CL_DEVICE_LUID_KHR,
+    sizeof(char) * CL_LUID_SIZE_KHR, luidOpencl, nullptr);
+
+  std::stringstream luidOpenclHex;
+  for (int i = 0; i < 8; ++i)
+  luidOpenclHex << std::hex << std::setw(2) << std::setfill('0')
+                << int(luidOpencl[i]);
+  std::cout << "OpenCL  : " << luidOpenclHex.str() << std::endl;
+
+  if (luidSYCLHex.str() != luidOpenclHex.str()) {
+    std::cout << "FAILED" << std::endl;
+    return -1;
+  }
+
+  std::cout << "PASSED" << std::endl;
+  return 0;
+}

sycl/test-e2e/Adapters/node_mask-opencl.cpp

@@ -0,0 +1,37 @@
+// REQUIRES: aspect-ext_intel_device_info_node_mask
+// REQUIRES: gpu, opencl, windows
+
+// RUN: %{build} -o %t.out %opencl_lib
+// RUN: %{run} %t.out
+
+// Test that the node mask is read correctly from OpenCL.
+
+#include <iomanip>
+#include <iostream>
+#include <sstream>
+#include <sycl/backend.hpp>
+#include <sycl/detail/core.hpp>
+
+int main() {
+  sycl::device dev;
+  auto nodeMaskSYCL = dev.get_info<sycl::ext::intel::info::device::node_mask>();
+
+  std::cout << "SYCL: " << nodeMaskSYCL << std::endl;
+
+  auto openclDevice = sycl::get_native<sycl::backend::opencl>(dev);
+
+  uint32_t *nodeMaskOpencl = nullptr;
+
+  clGetDeviceInfo(openclDevice, CL_DEVICE_NODE_MASK_KHR,
+    sizeof(uint32_t), nodeMaskOpencl, nullptr);
+
+  std::cout << "OpenCL  : " << *nodeMaskOpencl << std::endl;
+
+  if (nodeMaskSYCL != *nodeMaskOpencl) {
+    std::cout << "FAILED" << std::endl;
+    return -1;
+  }
+
+  std::cout << "PASSED" << std::endl;
+  return 0;
+}

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

@@ -1418,6 +1418,63 @@ 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_FEATURE;
+    }
+
+    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 = nullptr;
+
+    CL_RETURN_ON_FAILURE(clGetDeviceInfo(hDevice->CLDevice,
+                                         CL_DEVICE_NODE_MASK_KHR,
+                                         sizeof(cl_int), nodeMask, nullptr));
+
+    if (nodeMask == nullptr) {
+      return UR_RESULT_ERROR_UNSUPPORTED_FEATURE;
+    }
+
+    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: