Fix issue with pointer being passed to API without any underlying memory and fix char to unsigned char conversion issue

Author: DBDuncan

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

@@ -27,14 +27,18 @@ int main() {
 
   CUdevice cudaDevice = sycl::get_native<sycl::backend::ext_oneapi_cuda>(dev);
 
-  char *luidCuda = nullptr;
+  std::array<char, 8> luidCuda{};
 
-  cuDeviceGetLuid(luidCuda, nullptr, cudaDevice);
+  cuDeviceGetLuid(luidCuda.data(), nullptr, cudaDevice);
+
+  // Cuda returns luid as char, not unsigned char so convert that here.
+  std::array<unsigned char, 8> luidCudaConverted{};
+  std::copy(luidCuda.begin(), luidCuda.end(), luidCudaConverted.begin());
 
   std::stringstream luidCudaHex;
   for (int i = 0; i < 8; ++i)
     luidCudaHex << std::hex << std::setw(2) << std::setfill('0')
-                << int(luidCuda[i]);
+                << int(luidCudaConverted[i]);
   std::cout << "CUDA  : " << luidCudaHex.str() << std::endl;
 
   if (luidSYCLHex.str() != luidCudaHex.str()) {

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

@@ -25,10 +25,10 @@ int main() {
 
   auto openclDevice = sycl::get_native<sycl::backend::opencl>(dev);
 
-  char *luidOpencl = nullptr;
+  std::array<unsigned char, CL_LUID_SIZE_KHR> luidOpencl{};
 
   clGetDeviceInfo(openclDevice, CL_DEVICE_LUID_KHR,
-                  sizeof(char) * CL_LUID_SIZE_KHR, luidOpencl, nullptr);
+                  sizeof(char) * CL_LUID_SIZE_KHR, luidOpencl.data(), nullptr);
 
   std::stringstream luidOpenclHex;
   for (int i = 0; i < 8; ++i)

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

@@ -16,19 +16,20 @@
 
 int main() {
   sycl::device dev;
-  auto nodeMaskSYCL = dev.get_info<sycl::ext::intel::info::device::node_mask>();
+  uint32_t nodeMaskSYCL =
+      dev.get_info<sycl::ext::intel::info::device::node_mask>();
 
   std::cout << "SYCL: " << nodeMaskSYCL << std::endl;
 
   CUdevice cudaDevice = sycl::get_native<sycl::backend::ext_oneapi_cuda>(dev);
 
-  uint32_t *nodeMaskCuda = nullptr;
+  uint32_t nodeMaskCuda = 0;
 
-  cuDeviceGetLuid(nullptr, nodeMaskCuda, cudaDevice);
+  cuDeviceGetLuid(nullptr, &nodeMaskCuda, cudaDevice);
 
-  std::cout << "CUDA  : " << *nodeMaskCuda << std::endl;
+  std::cout << "CUDA  : " << nodeMaskCuda << std::endl;
 
-  if (nodeMaskSYCL != *nodeMaskCuda) {
+  if (nodeMaskSYCL != nodeMaskCuda) {
     std::cout << "FAILED" << std::endl;
     return -1;
   }

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

@@ -20,14 +20,14 @@ int main() {
 
   auto openclDevice = sycl::get_native<sycl::backend::opencl>(dev);
 
-  uint32_t *nodeMaskOpencl = nullptr;
+  uint32_t nodeMaskOpencl = 0;
 
   clGetDeviceInfo(openclDevice, CL_DEVICE_NODE_MASK_KHR, sizeof(uint32_t),
-                  nodeMaskOpencl, nullptr);
+                  &nodeMaskOpencl, nullptr);
 
-  std::cout << "OpenCL  : " << *nodeMaskOpencl << std::endl;
+  std::cout << "OpenCL  : " << nodeMaskOpencl << std::endl;
 
-  if (nodeMaskSYCL != *nodeMaskOpencl) {
+  if (nodeMaskSYCL != nodeMaskOpencl) {
     std::cout << "FAILED" << std::endl;
     return -1;
   }

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

@@ -1191,31 +1191,38 @@ UR_APIEXPORT ur_result_t UR_APICALL urDeviceGetInfo(ur_device_handle_t hDevice,
     // 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.
-    char *LUID = nullptr;
-    cuDeviceGetLuid(LUID, nullptr, hDevice->get());
+    std::array<char, 8> LUID{};
+    cuDeviceGetLuid(LUID.data(), nullptr, hDevice->get());
 
-    std::array<unsigned char, 8> Name = {};
+    bool isAllZeros = true;
+    for (char num : LUID) {
+      if (num != 0) {
+        isAllZeros = false;
+      }
+    }
 
-    if (LUID == nullptr) {
+    if (isAllZeros) {
       return UR_RESULT_ERROR_UNSUPPORTED_FEATURE;
     }
 
-    std::copy(LUID, LUID + 8, Name.begin());
+    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 = nullptr;
-    cuDeviceGetLuid(nullptr, nodeMask, hDevice->get());
+    uint32_t nodeMask = 0;
+    cuDeviceGetLuid(nullptr, &nodeMask, hDevice->get());
 
-    if (nodeMask == nullptr) {
+    // If nodeMask has not changed, return unsupported.
+    if (nodeMask == 0) {
       return UR_RESULT_ERROR_UNSUPPORTED_FEATURE;
     }
 
-    return ReturnValue(*nodeMask);
+    return ReturnValue(nodeMask);
   }
   default:
     break;

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

@@ -1463,17 +1463,13 @@ UR_APIEXPORT ur_result_t UR_APICALL urDeviceGetInfo(ur_device_handle_t hDevice,
       return UR_RESULT_ERROR_UNSUPPORTED_ENUMERATION;
     }
 
-    cl_int *nodeMask = nullptr;
+    cl_int nodeMask = 0;
 
     CL_RETURN_ON_FAILURE(clGetDeviceInfo(hDevice->CLDevice,
                                          CL_DEVICE_NODE_MASK_KHR,
-                                         sizeof(cl_int), nodeMask, nullptr));
+                                         sizeof(cl_int), &nodeMask, nullptr));
 
-    if (nodeMask == nullptr) {
-      return UR_RESULT_ERROR_UNSUPPORTED_FEATURE;
-    }
-
-    return ReturnValue(*nodeMask);
+    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.