Add device query for checking if device architecture is homogeneous

Currently, only Level Zero returns true for a new query. Level Zero
supports only Intel GPU devices at the moment and to my knowledge they
all should be homogeneous.

All other backends return false, which disables build optimizations.

Author: bader

sycl/include/CL/sycl/detail/pi.h

@@ -302,6 +302,7 @@ typedef enum {
   PI_DEVICE_INFO_GPU_EU_COUNT_PER_SUBSLICE = 0x10025,
   PI_DEVICE_INFO_MAX_MEM_BANDWIDTH = 0x10026,
   PI_DEVICE_INFO_IMAGE_SRGB = 0x10027,
+  PI_DEVICE_INFO_HOMOGENEOUS_ARCH = 0x10028,
   PI_DEVICE_INFO_ATOMIC_64 = 0x10110,
   PI_DEVICE_INFO_ATOMIC_MEMORY_ORDER_CAPABILITIES = 0x10111,
   PI_DEVICE_INFO_ATOMIC_MEMORY_SCOPE_CAPABILITIES = 0x11000,

sycl/plugins/cuda/pi_cuda.cpp

@@ -1490,6 +1490,10 @@ pi_result cuda_piDeviceGetInfo(pi_device device, pi_device_info param_name,
     return getInfo(param_value_size, param_value, param_value_size_ret,
                    PI_TRUE);
   }
+  case PI_DEVICE_INFO_HOMOGENEOUS_ARCH: {
+    return getInfo(param_value_size, param_value, param_value_size_ret,
+                   PI_FALSE);
+  }
   case PI_DEVICE_INFO_COMPILER_AVAILABLE: {
     return getInfo(param_value_size, param_value, param_value_size_ret,
                    PI_TRUE);

sycl/plugins/esimd_emulator/pi_esimd_emulator.cpp

@@ -586,6 +586,8 @@ pi_result piDeviceGetInfo(pi_device Device, pi_device_info ParamName,
     return ReturnValue("");
   case PI_DEVICE_INFO_VERSION:
     return ReturnValue(CmEmuDeviceVersionString);
+  case PI_DEVICE_INFO_HOMOGENEOUS_ARCH: // emulator doesn't support partition
+    return ReturnValue(pi_bool{false});
   case PI_DEVICE_INFO_COMPILER_AVAILABLE:
     return ReturnValue(pi_bool{false});
   case PI_DEVICE_INFO_LINKER_AVAILABLE:

sycl/plugins/hip/pi_hip.cpp

@@ -1409,6 +1409,10 @@ pi_result hip_piDeviceGetInfo(pi_device device, pi_device_info param_name,
     return getInfo(param_value_size, param_value, param_value_size_ret,
                    PI_TRUE);
   }
+  case PI_DEVICE_INFO_HOMOGENEOUS_ARCH: {
+    return getInfo(param_value_size, param_value, param_value_size_ret,
+                   PI_FALSE);
+  }
   case PI_DEVICE_INFO_COMPILER_AVAILABLE: {
     return getInfo(param_value_size, param_value, param_value_size_ret,
                    PI_TRUE);

sycl/plugins/level_zero/pi_level_zero.cpp

@@ -2326,6 +2326,8 @@ pi_result piDeviceGetInfo(pi_device Device, pi_device_info ParamName,
   }
   case PI_DEVICE_INFO_NAME:
     return ReturnValue(Device->ZeDeviceProperties->name);
+  case PI_DEVICE_INFO_HOMOGENEOUS_ARCH:
+    return ReturnValue(PI_TRUE);
   case PI_DEVICE_INFO_COMPILER_AVAILABLE:
     return ReturnValue(pi_bool{1});
   case PI_DEVICE_INFO_LINKER_AVAILABLE:

sycl/plugins/opencl/pi_opencl.cpp

@@ -203,7 +203,13 @@ pi_result piDeviceGetInfo(pi_device device, pi_device_info paramName,
     std::memcpy(paramValue, &result, sizeof(cl_bool));
     return PI_SUCCESS;
   }
-
+  case PI_DEVICE_INFO_HOMOGENEOUS_ARCH: {
+    // FIXME: conservatively return false due to lack of low-level API exposing
+    // actual status of this property
+    cl_bool result = false;
+    std::memcpy(paramValue, &result, sizeof(cl_bool));
+    return PI_SUCCESS;
+  }
   case PI_EXT_ONEAPI_DEVICE_INFO_MAX_WORK_GROUPS_3D:
     // Returns the maximum sizes of a work group for each dimension one
     // could use to submit a kernel. There is no such query defined in OpenCL

sycl/source/detail/program_manager/program_manager.cpp

@@ -481,6 +481,22 @@ RT::PiProgram ProgramManager::getBuiltPIProgram(
   if (Prg)
     Prg->stableSerializeSpecConstRegistry(SpecConsts);
 
+  // Check if root device architecture is homogeneous and we can optimize builds
+  // for sub-devices
+  DeviceImplPtr RootDevImpl = DeviceImpl;
+  while (!RootDevImpl->isRootDevice()) {
+    auto ParentDev = detail::getSyclObjImpl(
+        RootDevImpl->get_info<info::device::parent_device>());
+    if (!ContextImpl->hasDevice(ParentDev))
+      break;
+    RootDevImpl = ParentDev;
+  }
+
+  pi_bool IsRootDeviceArchHomogeneous = PI_FALSE;
+  ContextImpl->getPlugin().call<PiApiKind::piDeviceGetInfo>(
+      RootDevImpl->getHandleRef(), PI_DEVICE_INFO_HOMOGENEOUS_ARCH,
+      sizeof(pi_bool), &IsRootDeviceArchHomogeneous, nullptr);
+
   // FIXME: the logic is modified to work around unintuitive Intel OpenCL CPU
   // implementation behavior. Kernels created with the program built for root
   // device can be re-used on sub-devices, but other combinations doesn't work
@@ -493,17 +509,8 @@ RT::PiProgram ProgramManager::getBuiltPIProgram(
   // The expected solution is to build for any sub-device and use root device
   // handle as cache key to share build results for any other sub-device or even
   // a root device.
-  // TODO: it might be worth testing if Level Zero plug-in supports all cases
-  // and enable more cases for Level Zero.
-  DeviceImplPtr Dev = DeviceImpl;
-  while (!Dev->isRootDevice()) {
-    auto ParentDev =
-        detail::getSyclObjImpl(Dev->get_info<info::device::parent_device>());
-    if (!ContextImpl->hasDevice(ParentDev))
-      break;
-    Dev = ParentDev;
-  }
-
+  DeviceImplPtr Dev =
+      (IsRootDeviceArchHomogeneous == PI_TRUE) ? RootDevImpl : DeviceImpl;
   auto BuildF = [this, &M, &KSId, &ContextImpl, &Dev, Prg, &CompileOpts,
                  &LinkOpts, &JITCompilationIsRequired, SpecConsts] {
     auto Context = createSyclObjFromImpl<context>(ContextImpl);