[SYCL] SYCL 2020 callable device selectors (#6486)

Signed-off-by: Chris Perkins <[email protected]>

Author: cperkinsintel

sycl/include/sycl/device.hpp

@@ -33,6 +33,13 @@ class device_impl;
 auto getDeviceComparisonLambda();
 } // namespace detail
 
+namespace ext {
+namespace oneapi {
+// Forward declaration
+class filter_selector;
+} // namespace oneapi
+} // namespace ext
+
 /// The SYCL device class encapsulates a single SYCL device on which kernels
 /// may be executed.
 ///
@@ -53,9 +60,20 @@ class __SYCL_EXPORT device {
   /// Constructs a SYCL device instance using the device selected
   /// by the DeviceSelector provided.
   ///
-  /// \param DeviceSelector SYCL device selector to be used (see 4.6.1.1).
+  /// \param DeviceSelector SYCL 1.2.1 device_selector to be used (see 4.6.1.1).
   explicit device(const device_selector &DeviceSelector);
 
+#if __cplusplus >= 201703L
+  /// Constructs a SYCL device instance using the device
+  /// identified by the device selector provided.
+  /// \param DeviceSelector is SYCL 2020 Device Selector, a simple callable that
+  /// takes a device and returns an int
+  template <typename DeviceSelector,
+            typename = detail::EnableIfDeviceSelectorInvocable<DeviceSelector>>
+  explicit device(const DeviceSelector &deviceSelector)
+      : device(detail::select_device(deviceSelector)) {}
+#endif
+
   bool operator==(const device &rhs) const { return impl == rhs.impl; }
 
   bool operator!=(const device &rhs) const { return !(*this == rhs); }

sycl/include/sycl/device_selector.hpp

@@ -19,16 +19,19 @@ namespace sycl {
 // Forward declarations
 class device;
 
-/// The device_selector class provides ability to choose the best SYCL device
-/// based on heuristics specified by the user.
+namespace ext {
+namespace oneapi {
+class filter_selector;
+}
+} // namespace ext
+
+/// The SYCL 1.2.1 device_selector class provides ability to choose the
+/// best SYCL device based on heuristics specified by the user.
 ///
 /// \sa device
 ///
 /// \ingroup sycl_api_dev_sel
 class __SYCL_EXPORT device_selector {
-protected:
-  // SYCL 1.2.1 defines a negative score to reject a device from selection
-  static constexpr int REJECT_DEVICE_SCORE = -1;
 
 public:
   virtual ~device_selector() = default;
@@ -87,5 +90,33 @@ class __SYCL_EXPORT host_selector : public device_selector {
 public:
   int operator()(const device &dev) const override;
 };
+
+namespace detail {
+
+// SYCL 2020 section 4.6.1.1 defines a negative score to reject a device from
+// selection
+static constexpr int REJECT_DEVICE_SCORE = -1;
+
+using DSelectorInvocableType = std::function<int(const sycl::device &)>;
+
+#if __cplusplus >= 201703L
+
+// Enable if DeviceSelector callable has matching signature, but
+// exclude if descended from filter_selector which is not purely callable.
+// See [FilterSelector not Callable] in device_selector.cpp
+template <typename DeviceSelector>
+using EnableIfDeviceSelectorInvocable = std::enable_if_t<
+    std::is_invocable_r_v<int, DeviceSelector &, const device &> &&
+    !std::is_base_of_v<ext::oneapi::filter_selector, DeviceSelector>>;
+#endif
+
+__SYCL_EXPORT device
+select_device(const DSelectorInvocableType &DeviceSelectorInvocable);
+
+__SYCL_EXPORT device
+select_device(const DSelectorInvocableType &DeviceSelectorInvocable,
+              const context &SyclContext);
+
+} // namespace detail
 } // namespace sycl
 } // __SYCL_INLINE_NAMESPACE(cl)

sycl/include/sycl/platform.hpp

@@ -14,6 +14,7 @@
 #include <sycl/detail/common.hpp>
 #include <sycl/detail/export.hpp>
 #include <sycl/detail/info_desc_helpers.hpp>
+#include <sycl/device_selector.hpp>
 #include <sycl/stl.hpp>
 
 // 4.6.2 Platform class
@@ -31,6 +32,12 @@ auto get_native(const SyclObjectT &Obj)
 namespace detail {
 class platform_impl;
 }
+namespace ext {
+namespace oneapi {
+// Forward declaration
+class filter_selector;
+} // namespace oneapi
+} // namespace ext
 
 /// Encapsulates a SYCL platform on which kernels may be executed.
 ///
@@ -50,15 +57,26 @@ class __SYCL_EXPORT platform {
   explicit platform(cl_platform_id PlatformId);
 #endif
 
-  /// Constructs a SYCL platform instance using device selector.
+  /// Constructs a SYCL platform instance using a device_selector.
   ///
   /// One of the SYCL devices that is associated with the constructed SYCL
   /// platform instance must be the SYCL device that is produced from the
   /// provided device selector.
   ///
-  /// \param DeviceSelector is an instance of SYCL device_selector.
+  /// \param DeviceSelector is an instance of a SYCL 1.2.1 device_selector
   explicit platform(const device_selector &DeviceSelector);
 
+#if __cplusplus >= 201703L
+  /// Constructs a SYCL platform instance using the platform of the device
+  /// identified by the device selector provided.
+  /// \param DeviceSelector is SYCL 2020 Device Selector, a simple callable that
+  /// takes a device and returns an int
+  template <typename DeviceSelector,
+            typename = detail::EnableIfDeviceSelectorInvocable<DeviceSelector>>
+  explicit platform(const DeviceSelector &deviceSelector)
+      : platform(detail::select_device(deviceSelector)) {}
+#endif
+
   platform(const platform &rhs) = default;
 
   platform(platform &&rhs) = default;
@@ -141,6 +159,8 @@ class __SYCL_EXPORT platform {
   std::shared_ptr<detail::platform_impl> impl;
   platform(std::shared_ptr<detail::platform_impl> impl) : impl(impl) {}
 
+  platform(const device &Device);
+
   template <class T>
   friend T detail::createSyclObjFromImpl(decltype(T::impl) ImplObj);
   template <class Obj>

sycl/include/sycl/queue.hpp

@@ -28,6 +28,7 @@
 #define __STDC_FORMAT_MACROS 1
 #endif
 #include <cinttypes>
+#include <type_traits>
 #include <utility>
 
 // having _TWO_ mid-param #ifdefs makes the functions very difficult to read.
@@ -123,10 +124,68 @@ class __SYCL_EXPORT queue {
   queue(const async_handler &AsyncHandler, const property_list &PropList = {})
       : queue(default_selector(), AsyncHandler, PropList) {}
 
+#if __cplusplus >= 201703L
+  /// Constructs a SYCL queue instance using the device identified by the
+  /// device selector provided.
+  /// \param DeviceSelector is SYCL 2020 Device Selector, a simple callable that
+  /// takes a device and returns an int
+  /// \param AsyncHandler is a SYCL asynchronous exception handler.
+  /// \param PropList is a list of properties for queue construction.
+  template <typename DeviceSelector,
+            typename = detail::EnableIfDeviceSelectorInvocable<DeviceSelector>>
+  explicit queue(const DeviceSelector &deviceSelector,
+                 const async_handler &AsyncHandler,
+                 const property_list &PropList = {})
+      : queue(detail::select_device(deviceSelector), AsyncHandler, PropList) {}
+
+  /// Constructs a SYCL queue instance using the device identified by the
+  /// device selector provided.
+  /// \param DeviceSelector is SYCL 2020 Device Selector, a simple callable that
+  /// takes a device and returns an int
+  /// \param PropList is a list of properties for queue construction.
+  template <typename DeviceSelector,
+            typename = detail::EnableIfDeviceSelectorInvocable<DeviceSelector>>
+  explicit queue(const DeviceSelector &deviceSelector,
+                 const property_list &PropList = {})
+      : queue(detail::select_device(deviceSelector), async_handler{},
+              PropList) {}
+
+  /// Constructs a SYCL queue instance using the device identified by the
+  /// device selector provided.
+  /// \param SyclContext is an instance of SYCL context.
+  /// \param DeviceSelector is SYCL 2020 Device Selector, a simple callable that
+  /// takes a device and returns an int
+  /// \param PropList is a list of properties for queue construction.
+  template <typename DeviceSelector,
+            typename = detail::EnableIfDeviceSelectorInvocable<DeviceSelector>>
+  explicit queue(const context &syclContext,
+                 const DeviceSelector &deviceSelector,
+                 const property_list &propList = {})
+      : queue(syclContext, detail::select_device(deviceSelector, syclContext),
+              propList) {}
+
+  /// Constructs a SYCL queue instance using the device identified by the
+  /// device selector provided.
+  /// \param SyclContext is an instance of SYCL context.
+  /// \param DeviceSelector is SYCL 2020 Device Selector, a simple callable that
+  /// takes a device and returns an int
+  /// \param AsyncHandler is a SYCL asynchronous exception handler.
+  /// \param PropList is a list of properties for queue construction.
+  template <typename DeviceSelector,
+            typename = detail::EnableIfDeviceSelectorInvocable<DeviceSelector>>
+  explicit queue(const context &syclContext,
+                 const DeviceSelector &deviceSelector,
+                 const async_handler &AsyncHandler,
+                 const property_list &propList = {})
+      : queue(syclContext, detail::select_device(deviceSelector, syclContext),
+              AsyncHandler, propList) {}
+
+#endif
+
   /// Constructs a SYCL queue instance using the device returned by the
   /// DeviceSelector provided.
   ///
-  /// \param DeviceSelector is an instance of SYCL device selector.
+  /// \param DeviceSelector is an instance of a SYCL 1.2.1 device_selector.
   /// \param PropList is a list of properties for queue construction.
   queue(const device_selector &DeviceSelector,
         const property_list &PropList = {})
@@ -135,7 +194,7 @@ class __SYCL_EXPORT queue {
   /// Constructs a SYCL queue instance with an async_handler using the device
   /// returned by the DeviceSelector provided.
   ///
-  /// \param DeviceSelector is an instance of SYCL device selector.
+  /// \param DeviceSelector is an instance of SYCL 1.2.1 device_selector.
   /// \param AsyncHandler is a SYCL asynchronous exception handler.
   /// \param PropList is a list of properties for queue construction.
   queue(const device_selector &DeviceSelector,