Address code review feedback

- Renamed PI_DEVICE_INFO_HOMOGENEOUS_ARCH to PI_DEVICE_INFO_BUILD_ON_SUBDEVICE
- Aligned OpenCL backend with Level Zero backend

Author: bader

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

@@ -305,7 +305,8 @@ 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,
+  // Return true if sub-device should do its own program build
+  PI_DEVICE_INFO_BUILD_ON_SUBDEVICE = 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,9 +1490,9 @@ 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: {
+  case PI_DEVICE_INFO_BUILD_ON_SUBDEVICE: {
     return getInfo(param_value_size, param_value, param_value_size_ret,
-                   PI_FALSE);
+                   PI_TRUE);
   }
   case PI_DEVICE_INFO_COMPILER_AVAILABLE: {
     return getInfo(param_value_size, param_value, param_value_size_ret,

sycl/plugins/esimd_emulator/pi_esimd_emulator.cpp

@@ -586,8 +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_BUILD_ON_SUBDEVICE: // emulator doesn't support partition
+    return ReturnValue(pi_bool{true});
   case PI_DEVICE_INFO_COMPILER_AVAILABLE:
     return ReturnValue(pi_bool{false});
   case PI_DEVICE_INFO_LINKER_AVAILABLE:

sycl/plugins/hip/pi_hip.cpp

@@ -1409,9 +1409,9 @@ 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: {
+  case PI_DEVICE_INFO_BUILD_ON_SUBDEVICE: {
     return getInfo(param_value_size, param_value, param_value_size_ret,
-                   PI_FALSE);
+                   PI_TRUE);
   }
   case PI_DEVICE_INFO_COMPILER_AVAILABLE: {
     return getInfo(param_value_size, param_value, param_value_size_ret,

sycl/plugins/level_zero/pi_level_zero.cpp

@@ -2337,8 +2337,11 @@ 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);
+  // zeModuleCreate allows using root device module for sub-devices:
+  // > The application must only use the module for the device, or its
+  // > sub-devices, which was provided during creation.
+  case PI_DEVICE_INFO_BUILD_ON_SUBDEVICE:
+    return ReturnValue(PI_FALSE);
   case PI_DEVICE_INFO_COMPILER_AVAILABLE:
     return ReturnValue(pi_bool{1});
   case PI_DEVICE_INFO_LINKER_AVAILABLE:

sycl/plugins/opencl/pi_opencl.cpp

@@ -203,10 +203,14 @@ 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;
+  case PI_DEVICE_INFO_BUILD_ON_SUBDEVICE: {
+    cl_device_type devType = CL_DEVICE_TYPE_DEFAULT;
+    cl_int res = clGetDeviceInfo(cast<cl_device_id>(device), CL_DEVICE_TYPE,
+                                 sizeof(cl_device_type), &devType, nullptr);
+
+    // FIXME: here we assume that program built for a root GPU device can be
+    // used on its sub-devices without re-building
+    cl_bool result = (res == CL_SUCCESS) && (devType == CL_DEVICE_TYPE_GPU);
     std::memcpy(paramValue, &result, sizeof(cl_bool));
     return PI_SUCCESS;
   }

sycl/source/detail/program_manager/program_manager.cpp

@@ -481,36 +481,25 @@ RT::PiProgram ProgramManager::getBuiltPIProgram(
   if (Prg)
     Prg->stableSerializeSpecConstRegistry(SpecConsts);
 
-  // Check if root device architecture is homogeneous and we can optimize builds
-  // for sub-devices
+  // Check if we can optimize program builds for sub-devices by using a program
+  // built for the root device
   DeviceImplPtr RootDevImpl = DeviceImpl;
   while (!RootDevImpl->isRootDevice()) {
     auto ParentDev = detail::getSyclObjImpl(
         RootDevImpl->get_info<info::device::parent_device>());
+    // Sharing is allowed within a single context only
     if (!ContextImpl->hasDevice(ParentDev))
       break;
     RootDevImpl = ParentDev;
   }
 
-  pi_bool IsRootDeviceArchHomogeneous = PI_FALSE;
+  pi_bool MustBuildOnSubdevice = PI_TRUE;
   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
-  // (e.g. clGetKernelWorkGroupInfo returns CL_INVALID_KERNEL if kernel was
-  // created from the program built for sub-device and re-used either on root or
-  // other sub-device).
-  // To work around this case we optimize only one case: root device shares the
-  // same context with its sub-device(s). We built for the root device and
-  // cache the results.
-  // 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.
+      RootDevImpl->getHandleRef(), PI_DEVICE_INFO_BUILD_ON_SUBDEVICE,
+      sizeof(pi_bool), &MustBuildOnSubdevice, nullptr);
+
   DeviceImplPtr Dev =
-      (IsRootDeviceArchHomogeneous == PI_TRUE) ? RootDevImpl : DeviceImpl;
+      (MustBuildOnSubdevice == PI_TRUE) ? DeviceImpl : RootDevImpl;
   auto BuildF = [this, &M, &KSId, &ContextImpl, &Dev, Prg, &CompileOpts,
                  &LinkOpts, &JITCompilationIsRequired, SpecConsts] {
     auto Context = createSyclObjFromImpl<context>(ContextImpl);