[UR] Stop querying adapter fp16/fp64 support via extension.

sycl/source/detail/device_impl.cpp

@@ -373,9 +373,9 @@ bool device_impl::has(aspect Aspect) const {
   case aspect::host_debuggable:
     return false;
   case aspect::fp16:
-    return has_extension("cl_khr_fp16");
+    return isFp16Supported();
   case aspect::fp64:
-    return has_extension("cl_khr_fp64");
+    return isFp64Supported();
   case aspect::int64_base_atomics:
     return has_extension("cl_khr_int64_base_atomics");
   case aspect::int64_extended_atomics:
@@ -811,6 +811,18 @@ ext::oneapi::experimental::architecture device_impl::getDeviceArch() const {
   return MDeviceArch;
 }
 
+bool device_impl::isFp16Supported() const {
+  // If we don't get anything back from this we can assume the device doesn't
+  // support fp16.
+  return !get_info<info::device::half_fp_config>().empty();
+}
+
+bool device_impl::isFp64Supported() const {
+  // If we don't get anything back from this we can assume the device doesn't
+  // support fp64.
+  return !get_info<info::device::double_fp_config>().empty();
+}
+
 // On the first call this function queries for device timestamp
 // along with host synchronized timestamp and stores it in member variable
 // MDeviceHostBaseTime. Subsequent calls to this function would just retrieve

sycl/source/detail/device_impl.hpp

@@ -293,6 +293,12 @@ class device_impl {
   /// Get device architecture
   ext::oneapi::experimental::architecture getDeviceArch() const;
 
+  // Check if the device supports double precision floating point.
+  bool isFp64Supported() const;
+
+  // Check if the device supports half precision floating point.
+  bool isFp16Supported() const;
+
 private:
   explicit device_impl(ur_native_handle_t InteropDevice,
                        ur_device_handle_t Device, PlatformImplPtr Platform,

sycl/source/detail/device_info.hpp

@@ -232,12 +232,6 @@ struct get_device_info_impl<ReturnT, info::device::parent_device> {
 template <typename Param>
 struct get_device_info_impl<std::vector<info::fp_config>, Param> {
   static std::vector<info::fp_config> get(const DeviceImplPtr &Dev) {
-    // Check if fp type is supported
-    if (!get_device_info_impl<
-            typename check_fp_support<Param>::type::return_type,
-            typename check_fp_support<Param>::type>::get(Dev)) {
-      return {};
-    }
     ur_device_fp_capability_flags_t result;
     Dev->getAdapter()->call<UrApiKind::urDeviceGetInfo>(
         Dev->getHandleRef(), UrInfoCode<Param>::value, sizeof(result), &result,

sycl/source/detail/program_manager/program_manager.cpp

@@ -1587,16 +1587,13 @@ getDeviceLibPrograms(const ContextImplPtr Context,
       {DeviceLibExt::cl_intel_devicelib_bfloat16, false}};
 
   // Disable all devicelib extensions requiring fp64 support if at least
-  // one underlying device doesn't support cl_khr_fp64.
-  const bool fp64Support = std::all_of(
-      Devices.begin(), Devices.end(), [&Context](ur_device_handle_t Device) {
-        std::string DevExtList =
-            Context->getPlatformImpl()
-                ->getDeviceImpl(Device)
-                ->get_device_info_string(
-                    UrInfoCode<info::device::extensions>::value);
-        return (DevExtList.npos != DevExtList.find("cl_khr_fp64"));
-      });
+  // one underlying device doesn't support doubles.
+  const bool fp64Support = std::all_of(Devices.begin(), Devices.end(),
+                                       [&Context](ur_device_handle_t Device) {
+                                         return Context->getPlatformImpl()
+                                             ->getDeviceImpl(Device)
+                                             ->isFp64Supported();
+                                       });
 
   // Load a fallback library for an extension if the any device does not
   // support it.

sycl/unittests/helpers/UrMock.hpp

@@ -156,7 +156,7 @@ inline ur_result_t mock_urDeviceGetInfo(void *pParams) {
   auto params = reinterpret_cast<ur_device_get_info_params_t *>(pParams);
   constexpr char MockDeviceName[] = "Mock device";
   constexpr char MockSupportedExtensions[] =
-      "cl_khr_fp64 cl_khr_fp16 cl_khr_il_program ur_exp_command_buffer";
+      "cl_khr_fp64 cl_khr_il_program ur_exp_command_buffer";
   switch (*params->ppropName) {
   case UR_DEVICE_INFO_TYPE: {
     // Act like any device is a GPU.
@@ -253,6 +253,24 @@ inline ur_result_t mock_urDeviceGetInfo(void *pParams) {
       **params->ppPropSizeRet = 0;
     }
     return UR_RESULT_SUCCESS;
+  case UR_DEVICE_INFO_SINGLE_FP_CONFIG:
+  case UR_DEVICE_INFO_HALF_FP_CONFIG:
+  case UR_DEVICE_INFO_DOUBLE_FP_CONFIG:
+    if (*params->ppPropValue) {
+      // This is the minimum requirement for a device reporting support for a
+      // given FP type.
+      ur_device_fp_capability_flags_t capabilities =
+          UR_DEVICE_FP_CAPABILITY_FLAG_DENORM |
+          UR_DEVICE_FP_CAPABILITY_FLAG_INF_NAN |
+          UR_DEVICE_FP_CAPABILITY_FLAG_ROUND_TO_NEAREST |
+          UR_DEVICE_FP_CAPABILITY_FLAG_FMA;
+      *static_cast<ur_device_fp_capability_flags_t *>(*params->ppPropValue) =
+          capabilities;
+    }
+    if (*params->ppPropSizeRet) {
+      **params->ppPropSizeRet = sizeof(ur_device_fp_capability_flags_t);
+    }
+    return UR_RESULT_SUCCESS;
   default: {
     // In the default case we fill the return value with 0's. This may not be
     // valid for all device queries, but it will mean a consistent return value

sycl/unittests/pipes/host_pipe_registration.cpp

@@ -69,12 +69,11 @@ ur_result_t redefinedEnqueueWriteHostPipe(void *pParams) {
 ur_result_t after_urDeviceGetInfo(void *pParams) {
   auto params = *static_cast<ur_device_get_info_params_t *>(pParams);
   constexpr char MockSupportedExtensions[] =
-      "cl_khr_fp64 cl_khr_fp16 cl_khr_il_program "
+      "cl_khr_fp64 cl_khr_il_program ur_exp_command_buffer "
       "cl_intel_program_scope_host_pipe";
   switch (*params.ppropName) {
   case UR_DEVICE_INFO_EXTENSIONS:
     if (*params.ppPropValue) {
-      std::ignore = *params.ppropSize;
       assert(*params.ppropSize >= sizeof(MockSupportedExtensions));
       std::memcpy(*params.ppPropValue, MockSupportedExtensions,
                   sizeof(MockSupportedExtensions));

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

@@ -437,8 +437,27 @@ UR_APIEXPORT ur_result_t UR_APICALL urDeviceGetInfo(ur_device_handle_t hDevice,
     return ReturnValue(MemBaseAddrAlign);
   }
   case UR_DEVICE_INFO_HALF_FP_CONFIG: {
-    // TODO: is this config consistent across all NVIDIA GPUs?
-    return ReturnValue(0u);
+    int Major = 0;
+    int Minor = 0;
+
+    UR_CHECK_ERROR(cuDeviceGetAttribute(
+        &Major, CU_DEVICE_ATTRIBUTE_COMPUTE_CAPABILITY_MAJOR, hDevice->get()));
+    UR_CHECK_ERROR(cuDeviceGetAttribute(
+        &Minor, CU_DEVICE_ATTRIBUTE_COMPUTE_CAPABILITY_MINOR, hDevice->get()));
+
+    if ((Major >= 6) || ((Major == 5) && (Minor >= 3))) {
+      // TODO: is this config consistent across all NVIDIA GPUs?
+      ur_device_fp_capability_flags_t Config =
+          UR_DEVICE_FP_CAPABILITY_FLAG_DENORM |
+          UR_DEVICE_FP_CAPABILITY_FLAG_INF_NAN |
+          UR_DEVICE_FP_CAPABILITY_FLAG_ROUND_TO_NEAREST |
+          UR_DEVICE_FP_CAPABILITY_FLAG_ROUND_TO_ZERO |
+          UR_DEVICE_FP_CAPABILITY_FLAG_ROUND_TO_INF |
+          UR_DEVICE_FP_CAPABILITY_FLAG_FMA;
+      return ReturnValue(Config);
+    } else {
+      return ReturnValue(0u);
+    }
   }
   case UR_DEVICE_INFO_SINGLE_FP_CONFIG: {
     // TODO: is this config consistent across all NVIDIA GPUs?
@@ -616,26 +635,14 @@ UR_APIEXPORT ur_result_t UR_APICALL urDeviceGetInfo(ur_device_handle_t hDevice,
   }
   case UR_DEVICE_INFO_EXTENSIONS: {
 
-    std::string SupportedExtensions = "cl_khr_fp64 cl_khr_subgroups ";
+    std::string SupportedExtensions = "cl_khr_subgroups ";
     SupportedExtensions += "cl_intel_devicelib_assert ";
     // Return supported for the UR command-buffer experimental feature
     SupportedExtensions += "ur_exp_command_buffer ";
     SupportedExtensions += "ur_exp_usm_p2p ";
     SupportedExtensions += "ur_exp_launch_properties ";
     SupportedExtensions += " ";
 
-    int Major = 0;
-    int Minor = 0;
-
-    UR_CHECK_ERROR(cuDeviceGetAttribute(
-        &Major, CU_DEVICE_ATTRIBUTE_COMPUTE_CAPABILITY_MAJOR, hDevice->get()));
-    UR_CHECK_ERROR(cuDeviceGetAttribute(
-        &Minor, CU_DEVICE_ATTRIBUTE_COMPUTE_CAPABILITY_MINOR, hDevice->get()));
-
-    if ((Major >= 6) || ((Major == 5) && (Minor >= 3))) {
-      SupportedExtensions += "cl_khr_fp16 ";
-    }
-
     return ReturnValue(SupportedExtensions.c_str());
   }
   case UR_DEVICE_INFO_PRINTF_BUFFER_SIZE: {

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

@@ -370,29 +370,44 @@ UR_APIEXPORT ur_result_t UR_APICALL urDeviceGetInfo(ur_device_handle_t hDevice,
     return ReturnValue(MemBaseAddrAlign);
   }
   case UR_DEVICE_INFO_HALF_FP_CONFIG: {
-    return ReturnValue(0u);
-  }
-  case UR_DEVICE_INFO_SINGLE_FP_CONFIG: {
     ur_device_fp_capability_flags_t Config =
         UR_DEVICE_FP_CAPABILITY_FLAG_DENORM |
         UR_DEVICE_FP_CAPABILITY_FLAG_INF_NAN |
         UR_DEVICE_FP_CAPABILITY_FLAG_ROUND_TO_NEAREST |
         UR_DEVICE_FP_CAPABILITY_FLAG_ROUND_TO_ZERO |
         UR_DEVICE_FP_CAPABILITY_FLAG_ROUND_TO_INF |
-        UR_DEVICE_FP_CAPABILITY_FLAG_FMA |
-        UR_DEVICE_FP_CAPABILITY_FLAG_CORRECTLY_ROUNDED_DIVIDE_SQRT;
+        UR_DEVICE_FP_CAPABILITY_FLAG_FMA;
     return ReturnValue(Config);
   }
-  case UR_DEVICE_INFO_DOUBLE_FP_CONFIG: {
+  case UR_DEVICE_INFO_SINGLE_FP_CONFIG: {
     ur_device_fp_capability_flags_t Config =
         UR_DEVICE_FP_CAPABILITY_FLAG_DENORM |
         UR_DEVICE_FP_CAPABILITY_FLAG_INF_NAN |
         UR_DEVICE_FP_CAPABILITY_FLAG_ROUND_TO_NEAREST |
         UR_DEVICE_FP_CAPABILITY_FLAG_ROUND_TO_ZERO |
         UR_DEVICE_FP_CAPABILITY_FLAG_ROUND_TO_INF |
-        UR_DEVICE_FP_CAPABILITY_FLAG_FMA;
+        UR_DEVICE_FP_CAPABILITY_FLAG_FMA |
+        UR_DEVICE_FP_CAPABILITY_FLAG_CORRECTLY_ROUNDED_DIVIDE_SQRT;
     return ReturnValue(Config);
   }
+  case UR_DEVICE_INFO_DOUBLE_FP_CONFIG: {
+    hipDeviceProp_t Props;
+    detail::ur::assertion(hipGetDeviceProperties(&Props, hDevice->get()) ==
+                          hipSuccess);
+
+    if (Props.arch.hasDoubles) {
+      ur_device_fp_capability_flags_t Config =
+          UR_DEVICE_FP_CAPABILITY_FLAG_DENORM |
+          UR_DEVICE_FP_CAPABILITY_FLAG_INF_NAN |
+          UR_DEVICE_FP_CAPABILITY_FLAG_ROUND_TO_NEAREST |
+          UR_DEVICE_FP_CAPABILITY_FLAG_ROUND_TO_ZERO |
+          UR_DEVICE_FP_CAPABILITY_FLAG_ROUND_TO_INF |
+          UR_DEVICE_FP_CAPABILITY_FLAG_FMA;
+      return ReturnValue(Config);
+    } else {
+      return ReturnValue(0u);
+    }
+  }
   case UR_DEVICE_INFO_GLOBAL_MEM_CACHE_TYPE: {
     return ReturnValue(UR_DEVICE_MEM_CACHE_TYPE_READ_WRITE_CACHE);
   }
@@ -581,16 +596,6 @@ UR_APIEXPORT ur_result_t UR_APICALL urDeviceGetInfo(ur_device_handle_t hDevice,
 
     SupportedExtensions += " ";
 
-    hipDeviceProp_t Props;
-    detail::ur::assertion(hipGetDeviceProperties(&Props, hDevice->get()) ==
-                          hipSuccess);
-
-    if (Props.arch.hasDoubles) {
-      SupportedExtensions += "cl_khr_fp64 ";
-    }
-
-    SupportedExtensions += "cl_khr_fp16 ";
-
     return ReturnValue(SupportedExtensions.c_str());
   }
   case UR_DEVICE_INFO_PRINTF_BUFFER_SIZE: {

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

@@ -260,8 +260,6 @@ ur_result_t urDeviceGetInfo(
     //   for performance.
     // cl_intel_required_subgroup_size - Extension to allow programmers to
     //   optionally specify the required subgroup size for a kernel function.
-    // cl_khr_fp16 - Optional half floating-point support.
-    // cl_khr_fp64 - Support for double floating-point precision.
     // cl_khr_int64_base_atomics, cl_khr_int64_extended_atomics - Optional
     //   extensions that implement atomic operations on 64-bit signed and
     //   unsigned integers to locations in __global and __local memory.
@@ -271,10 +269,6 @@ ur_result_t urDeviceGetInfo(
     // Hardcoding some extensions we know are supported by all Level Zero
     // devices.
     SupportedExtensions += (ZE_SUPPORTED_EXTENSIONS);
-    if (Device->ZeDeviceModuleProperties->flags & ZE_DEVICE_MODULE_FLAG_FP16)
-      SupportedExtensions += ("cl_khr_fp16 ");
-    if (Device->ZeDeviceModuleProperties->flags & ZE_DEVICE_MODULE_FLAG_FP64)
-      SupportedExtensions += ("cl_khr_fp64 ");
     if (Device->ZeDeviceModuleProperties->flags &
         ZE_DEVICE_MODULE_FLAG_INT64_ATOMICS)
       // int64AtomicsSupported indicates support for both.

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

@@ -154,10 +154,7 @@ UR_APIEXPORT ur_result_t UR_APICALL urDeviceGetInfo(ur_device_handle_t hDevice,
   case UR_DEVICE_INFO_HOST_UNIFIED_MEMORY:
     return ReturnValue(bool{1});
   case UR_DEVICE_INFO_EXTENSIONS:
-    // TODO : Populate return string accordingly - e.g. cl_khr_fp16,
-    // cl_khr_fp64, cl_khr_int64_base_atomics,
-    // cl_khr_int64_extended_atomics
-    return ReturnValue("cl_khr_fp16, cl_khr_fp64 ");
+    return ReturnValue("");
   case UR_DEVICE_INFO_VERSION:
     return ReturnValue("0.1");
   case UR_DEVICE_INFO_COMPILER_AVAILABLE:
@@ -193,19 +190,18 @@ UR_APIEXPORT ur_result_t UR_APICALL urDeviceGetInfo(ur_device_handle_t hDevice,
   case UR_DEVICE_INFO_IMAGE3D_MAX_DEPTH:
     // Default minimum values required by the SYCL specification.
     return ReturnValue(size_t{2048});
-  case UR_DEVICE_INFO_HALF_FP_CONFIG: {
-    // todo:
-    ur_device_fp_capability_flags_t HalfFPValue = 0;
-    return ReturnValue(HalfFPValue);
-  }
-  case UR_DEVICE_INFO_SINGLE_FP_CONFIG: {
-    // todo
-    ur_device_fp_capability_flags_t SingleFPValue = 0;
-    return ReturnValue(SingleFPValue);
-  }
+  case UR_DEVICE_INFO_HALF_FP_CONFIG:
+  case UR_DEVICE_INFO_SINGLE_FP_CONFIG:
   case UR_DEVICE_INFO_DOUBLE_FP_CONFIG: {
-    ur_device_fp_capability_flags_t DoubleFPValue = 0;
-    return ReturnValue(DoubleFPValue);
+    // All fp types are supported, return minimum flags to indicate support.
+    // TODO: look at this in more detail.
+    ur_device_fp_capability_flags_t SupportedFlags =
+        UR_DEVICE_FP_CAPABILITY_FLAG_DENORM |
+        UR_DEVICE_FP_CAPABILITY_FLAG_INF_NAN |
+        UR_DEVICE_FP_CAPABILITY_FLAG_ROUND_TO_NEAREST |
+        UR_DEVICE_FP_CAPABILITY_FLAG_FMA;
+    ;
+    return ReturnValue(SupportedFlags);
   }
   case UR_DEVICE_INFO_MAX_WORK_ITEM_DIMENSIONS:
     return ReturnValue(uint32_t{3});