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

sycl/cmake/modules/FetchUnifiedRuntime.cmake

@@ -116,7 +116,7 @@ if(SYCL_UR_USE_FETCH_CONTENT)
       CACHE PATH "Path to external '${name}' adapter source dir" FORCE)
   endfunction()
 
-  set(UNIFIED_RUNTIME_REPO "https://github.com/oneapi-src/unified-runtime.git")
+  set(UNIFIED_RUNTIME_REPO "https://github.com/aarongreig/unified-runtime.git")
   include(${CMAKE_CURRENT_SOURCE_DIR}/cmake/modules/UnifiedRuntimeTag.cmake)
 
   set(UMF_BUILD_EXAMPLES OFF CACHE INTERNAL "EXAMPLES")

sycl/cmake/modules/UnifiedRuntimeTag.cmake

@@ -1,7 +1 @@
-# commit dbd168cbed2d2590b47904728cd5762f1c2f4c6b (HEAD, origin/main, origin/HEAD)
-# Merge: 694c1b9a 27ad3f7d
-# Author: Piotr Balcer <[email protected]>
-# Date:   Mon Oct 28 16:29:45 2024 +0100
-#   Merge pull request #2242 from nrspruit/sysman_env_disable
-#   [L0] Enable Sysman Thru Env by default and have zesInit be optional
-set(UNIFIED_RUNTIME_TAG dbd168cbed2d2590b47904728cd5762f1c2f4c6b)
+set(UNIFIED_RUNTIME_TAG aaron/stopReportingFPExtensions)

sycl/source/detail/device_impl.cpp

@@ -367,9 +367,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:
@@ -800,6 +800,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/unittests/helpers/UrMock.hpp

@@ -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