[SYCL] Added support for aspects and the has() function. (#2237)

* [SYCL] Added support for aspects and the has() function.

The SYCL 2020 Provisional Spec adds a new concept called device "aspects",
which provide a way for an application to query whether a device supports
certain features which are not available on all devices.

The device::has() function returns true if a device supports the aspect,
and false otherwise.  The platform::has() function returns true if all
devices on the platform support the given aspect, and false otherwise.

Signed-off-by: Gail Lyons <[email protected]>

Author: glyons-intel

sycl/include/CL/sycl.hpp

@@ -9,6 +9,7 @@
 #pragma once
 
 #include <CL/sycl/accessor.hpp>
+#include <CL/sycl/aspects.hpp>
 #include <CL/sycl/atomic.hpp>
 #include <CL/sycl/backend.hpp>
 #include <CL/sycl/buffer.hpp>

sycl/include/CL/sycl/aspects.hpp

@@ -0,0 +1,37 @@
+//==-------------- aspects.hpp - SYCL Aspect Enums ------------*- C++ -*---==//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+// ===--------------------------------------------------------------------=== //
+#pragma once
+
+#include <CL/sycl/detail/defines.hpp>
+
+__SYCL_INLINE_NAMESPACE(cl) {
+namespace sycl {
+
+enum class aspect {
+  host,
+  cpu,
+  gpu,
+  accelerator,
+  custom,
+  fp16,
+  fp64,
+  int64_base_atomics,
+  int64_extended_atomics,
+  image,
+  online_compiler,
+  online_linker,
+  queue_profiling,
+  usm_device_allocations,
+  usm_host_allocations,
+  usm_shared_allocations,
+  usm_restricted_shared_allocations,
+  usm_system_allocator
+};
+
+} // namespace sycl
+} // __SYCL_INLINE_NAMESPACE(cl)

sycl/include/CL/sycl/device.hpp

@@ -8,6 +8,7 @@
 
 #pragma once
 
+#include <CL/sycl/aspects.hpp>
 #include <CL/sycl/backend_types.hpp>
 #include <CL/sycl/detail/common.hpp>
 #include <CL/sycl/detail/export.hpp>
@@ -179,6 +180,14 @@ class __SYCL_EXPORT device {
     return (typename interop<BackendName, device>::type)getNative();
   }
 
+  /// Indicates if the SYCL device has the given feature.
+  ///
+  /// \param Aspect is one of the values in Table 4.20 of the SYCL 2020
+  /// Provisional Spec.
+  ///
+  /// \return true if the SYCL device has the given feature.
+  bool has(aspect Aspect) const;
+
 private:
   shared_ptr_class<detail::device_impl> impl;
   device(shared_ptr_class<detail::device_impl> impl) : impl(impl) {}

sycl/include/CL/sycl/platform.hpp

@@ -116,6 +116,16 @@ class __SYCL_EXPORT platform {
         getNative());
   }
 
+  /// Indicates if all of the SYCL devices on this platform have the
+  /// given feature.
+  ///
+  /// \param Aspect is one of the values in Table 4.20 of the SYCL 2020
+  /// Provisional Spec.
+  ///
+  /// \return true if all of the SYCL devices on this platform have the
+  /// given feature.
+  bool has(aspect Aspect) const;
+
 private:
   pi_native_handle getNative() const;
 

sycl/source/detail/device_impl.cpp

@@ -53,8 +53,9 @@ device_impl::device_impl(pi_native_handle InteropDeviceHandle,
 
   RT::PiDevice parent = nullptr;
   // TODO catch an exception and put it to list of asynchronous exceptions
-  Plugin.call<PiApiKind::piDeviceGetInfo>(
-      MDevice, PI_DEVICE_INFO_PARENT_DEVICE, sizeof(RT::PiDevice), &parent, nullptr);
+  Plugin.call<PiApiKind::piDeviceGetInfo>(MDevice, PI_DEVICE_INFO_PARENT_DEVICE,
+                                          sizeof(RT::PiDevice), &parent,
+                                          nullptr);
 
   MIsRootDevice = (nullptr == parent);
   if (!MIsRootDevice && !InteroperabilityConstructor) {
@@ -181,13 +182,11 @@ device_impl::create_sub_devices(const vector_class<size_t> &Counts) const {
         "Partitioning to subdevices of the host device is not implemented yet",
         PI_INVALID_DEVICE);
 
-  if (!is_partition_supported(
-          info::partition_property::partition_by_counts)) {
+  if (!is_partition_supported(info::partition_property::partition_by_counts)) {
     throw cl::sycl::feature_not_supported();
   }
   static const cl_device_partition_property P[] = {
-      CL_DEVICE_PARTITION_BY_COUNTS, CL_DEVICE_PARTITION_BY_COUNTS_LIST_END,
-      0};
+      CL_DEVICE_PARTITION_BY_COUNTS, CL_DEVICE_PARTITION_BY_COUNTS_LIST_END, 0};
   vector_class<cl_device_partition_property> Properties(P, P + 3);
   Properties.insert(Properties.begin() + 1, Counts.begin(), Counts.end());
   return create_sub_devices(Properties.data(), Counts.size());
@@ -210,8 +209,7 @@ vector_class<device> device_impl::create_sub_devices(
   const cl_device_partition_property Properties[3] = {
       CL_DEVICE_PARTITION_BY_AFFINITY_DOMAIN,
       (cl_device_partition_property)AffinityDomain, 0};
-  size_t SubDevicesCount =
-      get_info<info::device::partition_max_sub_devices>();
+  size_t SubDevicesCount = get_info<info::device::partition_max_sub_devices>();
   return create_sub_devices(Properties, SubDevicesCount);
 }
 
@@ -222,6 +220,38 @@ pi_native_handle device_impl::getNative() const {
   return Handle;
 }
 
+bool device_impl::has(aspect Aspect) const {
+  switch (Aspect) {
+  case aspect::host:
+    return is_host();
+  case aspect::cpu:
+    return is_cpu();
+  case aspect::gpu:
+    return is_gpu();
+  case aspect::accelerator:
+    return is_accelerator();
+  case aspect::fp16:
+    return has_extension("cl_khr_fp16");
+  case aspect::fp64:
+    return has_extension("cl_khr_fp64");
+  case aspect::int64_base_atomics:
+    return has_extension("cl_khr_int64_base_atomics");
+  case aspect::int64_extended_atomics:
+    return has_extension("cl_khr_int64_extended_atomics");
+  case aspect::image:
+    return get_info<info::device::image_support>();
+  case aspect::online_compiler:
+    return get_info<info::device::is_compiler_available>();
+  case aspect::online_linker:
+    return get_info<info::device::is_linker_available>();
+  case aspect::queue_profiling:
+    return get_info<info::device::queue_profiling>();
+  default:
+    throw runtime_error("This device aspect has not been implemented yet.",
+                        PI_INVALID_DEVICE);
+  }
+}
+
 } // namespace detail
 } // namespace sycl
 } // __SYCL_INLINE_NAMESPACE(cl)

sycl/source/detail/device_impl.hpp

@@ -8,6 +8,7 @@
 
 #pragma once
 
+#include <CL/sycl/aspects.hpp>
 #include <CL/sycl/detail/pi.hpp>
 #include <CL/sycl/stl.hpp>
 #include <detail/device_info.hpp>
@@ -203,6 +204,14 @@ class device_impl {
   /// \return a native handle.
   pi_native_handle getNative() const;
 
+  /// Indicates if the SYCL device has the given feature.
+  ///
+  /// \param Aspect is one of the values in Table 4.20 of the SYCL 2020
+  /// Provisional Spec.
+  //
+  /// \return true if the SYCL device has the given feature.
+  bool has(aspect Aspect) const;
+
 private:
   explicit device_impl(pi_native_handle InteropDevice, RT::PiDevice Device,
                        PlatformImplPtr Platform, const plugin &Plugin);

sycl/source/detail/platform_impl.cpp

@@ -298,6 +298,16 @@ platform_impl::get_info() const {
       param>::get(this->getHandleRef(), getPlugin());
 }
 
+// All devices on the platform must have the given aspect.
+bool platform_impl::has(aspect Aspect) const {
+  for (const auto &dev : get_devices()) {
+    if (dev.has(Aspect) == false) {
+      return false;
+    }
+  }
+  return true;
+}
+
 #define PARAM_TRAITS_SPEC(param_type, param, ret_type)                         \
   template ret_type platform_impl::get_info<info::param_type::param>() const;
 

sycl/source/detail/platform_impl.hpp

@@ -127,6 +127,16 @@ class platform_impl {
   /// \return a native handle.
   pi_native_handle getNative() const;
 
+  /// Indicates if all of the SYCL devices on this platform have the
+  /// given feature.
+  ///
+  /// \param Aspect is one of the values in Table 4.20 of the SYCL 2020
+  /// Provisional Spec.
+  ///
+  /// \return true all of the SYCL devices on this platform have the
+  /// given feature.
+  bool has(aspect Aspect) const;
+
 private:
   bool MHostPlatform = false;
   RT::PiPlatform MPlatform = 0;

sycl/source/device.cpp

@@ -137,5 +137,7 @@ device::get_info() const {
 
 pi_native_handle device::getNative() const { return impl->getNative(); }
 
+bool device::has(aspect Aspect) const { return impl->has(Aspect); }
+
 } // namespace sycl
 } // __SYCL_INLINE_NAMESPACE(cl)

sycl/source/platform.cpp

@@ -53,6 +53,8 @@ platform::get_info() const {
 
 pi_native_handle platform::getNative() const { return impl->getNative(); }
 
+bool platform::has(aspect Aspect) const { return impl->has(Aspect); }
+
 #define PARAM_TRAITS_SPEC(param_type, param, ret_type)                         \
   template __SYCL_EXPORT ret_type                                              \
   platform::get_info<info::param_type::param>() const;