addition of num_compute_units query for device info

Author: dyniols

include/ur_api.h

@@ -1719,6 +1719,7 @@ typedef enum ur_device_info_t {
     UR_DEVICE_INFO_LOW_POWER_EVENTS_EXP = 0x2021,                    ///< [::ur_bool_t] returns true if the device supports low-power events.
     UR_DEVICE_INFO_2D_BLOCK_ARRAY_CAPABILITIES_EXP = 0x2022,         ///< [::ur_exp_device_2d_block_array_capability_flags_t] return a bit-field
                                                                      ///< of Intel GPU 2D block array capabilities
+    UR_DEVICE_INFO_NUM_COMPUTE_UNITS = 0x2023,                       ///< [uint32_t] the number of compute units for specific backend
     /// @cond
     UR_DEVICE_INFO_FORCE_UINT32 = 0x7fffffff
     /// @endcond

include/ur_print.hpp

@@ -2291,6 +2291,9 @@ inline std::ostream &operator<<(std::ostream &os, enum ur_device_info_t value) {
     case UR_DEVICE_INFO_MAX_COMPUTE_UNITS:
         os << "UR_DEVICE_INFO_MAX_COMPUTE_UNITS";
         break;
+    case UR_DEVICE_INFO_NUM_COMPUTE_UNITS:
+        os << "UR_DEVICE_INFO_NUM_COMPUTE_UNITS";
+        break;
     case UR_DEVICE_INFO_MAX_WORK_ITEM_DIMENSIONS:
         os << "UR_DEVICE_INFO_MAX_WORK_ITEM_DIMENSIONS";
         break;
@@ -2802,6 +2805,18 @@ inline ur_result_t printTagged(std::ostream &os, const void *ptr, ur_device_info
 
         os << ")";
     } break;
+        case UR_DEVICE_INFO_NUM_COMPUTE_UNITS: {
+        const uint32_t *tptr = (const uint32_t *)ptr;
+        if (sizeof(uint32_t) > size) {
+            os << "invalid size (is: " << size << ", expected: >=" << sizeof(uint32_t) << ")";
+            return UR_RESULT_ERROR_INVALID_SIZE;
+        }
+        os << (const void *)(tptr) << " (";
+
+        os << *tptr;
+
+        os << ")";
+    } break;
     case UR_DEVICE_INFO_MAX_WORK_ITEM_DIMENSIONS: {
         const uint32_t *tptr = (const uint32_t *)ptr;
         if (sizeof(uint32_t) > size) {

source/adapters/cuda/device.cpp

@@ -56,6 +56,7 @@ UR_APIEXPORT ur_result_t UR_APICALL urDeviceGetInfo(ur_device_handle_t hDevice,
   case UR_DEVICE_INFO_VENDOR_ID: {
     return ReturnValue(4318u);
   }
+  case UR_DEVICE_INFO_NUM_COMPUTE_UNITS:
   case UR_DEVICE_INFO_MAX_COMPUTE_UNITS: {
     return ReturnValue(hDevice->getNumComputeUnits());
   }

source/adapters/hip/device.cpp

@@ -57,6 +57,7 @@ UR_APIEXPORT ur_result_t UR_APICALL urDeviceGetInfo(ur_device_handle_t hDevice,
 #endif
     return ReturnValue(VendorId);
   }
+  case UR_DEVICE_INFO_NUM_COMPUTE_UNITS:
   case UR_DEVICE_INFO_MAX_COMPUTE_UNITS: {
     int ComputeUnits = 0;
     UR_CHECK_ERROR(hipDeviceGetAttribute(

source/adapters/level_zero/device.cpp

@@ -322,6 +322,12 @@ ur_result_t urDeviceGetInfo(
 
     return ReturnValue(uint32_t{MaxComputeUnits});
   }
+  case UR_DEVICE_INFO_NUM_COMPUTE_UNITS:{
+    uint32_t NumComputeUnits =  
+        Device->ZeDeviceProperties->numSubslicesPerSlice *
+        Device->ZeDeviceProperties->numSlices;
+    return ReturnValue(uint32_t{NumComputeUnits});
+  }
   case UR_DEVICE_INFO_MAX_WORK_ITEM_DIMENSIONS:
     // Level Zero spec defines only three dimensions
     return ReturnValue(uint32_t{3});

source/adapters/native_cpu/device.cpp

@@ -164,6 +164,7 @@ UR_APIEXPORT ur_result_t UR_APICALL urDeviceGetInfo(ur_device_handle_t hDevice,
     return ReturnValue(bool{true});
   case UR_DEVICE_INFO_LINKER_AVAILABLE:
     return ReturnValue(bool{true});
+  case UR_DEVICE_INFO_NUM_COMPUTE_UNITS:
   case UR_DEVICE_INFO_MAX_COMPUTE_UNITS:
     return ReturnValue(static_cast<uint32_t>(hDevice->tp.num_threads()));
   case UR_DEVICE_INFO_PARTITION_MAX_SUB_DEVICES:

source/adapters/opencl/device.cpp

@@ -827,6 +827,31 @@ UR_APIEXPORT ur_result_t UR_APICALL urDeviceGetInfo(ur_device_handle_t hDevice,
   case UR_DEVICE_INFO_VIRTUAL_MEMORY_SUPPORT: {
     return ReturnValue(false);
   }
+  case UR_DEVICE_INFO_NUM_COMPUTE_UNITS:{
+    
+    bool ExtensionSupported = false;
+    UR_RETURN_ON_FAILURE(cl_adapter::checkDeviceExtensions(
+        cl_adapter::cast<cl_device_id>(hDevice),
+        {"cl_intel_device_attribute_query"}, ExtensionSupported));
+    
+    cl_device_type CLType;
+    CL_RETURN_ON_FAILURE(
+        clGetDeviceInfo(cl_adapter::cast<cl_device_id>(hDevice), CL_DEVICE_TYPE,
+                        sizeof(cl_device_type), &CLType, nullptr));
+    
+    cl_uint NumComputeUnits;
+    if (ExtensionSupported && (CLType & CL_DEVICE_TYPE_GPU)) {
+      cl_uint SliceCount = 0;
+      cl_uint SubSlicePerSliceCount =0; 
+      CL_RETURN_ON_FAILURE(clGetDeviceInfo(cl_adapter::cast<cl_device_id>(hDevice), CL_DEVICE_NUM_SLICES_INTEL, sizeof(cl_uint), &SliceCount, nullptr));
+      CL_RETURN_ON_FAILURE(clGetDeviceInfo(cl_adapter::cast<cl_device_id>(hDevice), CL_DEVICE_NUM_SUB_SLICES_PER_SLICE_INTEL, sizeof(cl_uint), &SubSlicePerSliceCount, nullptr));
+      NumComputeUnits = SliceCount*SubSlicePerSliceCount;  
+    }else{
+      CL_RETURN_ON_FAILURE(clGetDeviceInfo(cl_adapter::cast<cl_device_id>(hDevice), CL_DEVICE_MAX_COMPUTE_UNITS, sizeof(cl_uint), &NumComputeUnits, nullptr));
+    }
+    
+    return ReturnValue(static_cast<size_t>(NumComputeUnits));
+  }
   case UR_DEVICE_INFO_TIMESTAMP_RECORDING_SUPPORT_EXP: {
     return ReturnValue(false);
   }