Fixed dpctl_device_selector for open-source DPC++, make wrap/unwrap templated

Moved dpctl_*_selector definitions into dpctl::syclinterface namespace.

wrap/unwrap functions are made templated, with template parameter being C++
type to pointer of which the opaque pointer is cast.

dpctl_device_selector for SYCL 2020 implements virtual call operator to enable
type inference of this type as std::function<int(const device&)>. The derived
classes override the call operator as appropriate.

Calls to constructors of sycl::device and sycl::platform which take device selector
callable are implemented differently depending on the compiler version.

Author: oleksandr-pavlyk

libsyclinterface/include/dpctl_sycl_device_selector_interface.h

@@ -65,31 +65,31 @@ DPCTL_API
 __dpctl_give DPCTLSyclDeviceSelectorRef DPCTLCPUSelector_Create(void);
 
 /*!
- * @brief Returns an opaque wrapper for sycl::ONEAPI::filter_selector object
- * based on the passed in filter string.
+ * @brief Returns an opaque wrapper for sycl::ext::oneapi::filter_selector
+ * object based on the passed in filter string.
  *
  * @param    filter_str     A C string providing a filter based on which to
- *                          create a device_selector.
- * @return   An opaque pointer to a sycl::ONEAPI::filter_selector object.
+ *                          create a device selector.
+ * @return   An opaque pointer to a sycl::ext::oneapi::filter_selector object.
  * @ingroup DeviceSelectors
  */
 DPCTL_API
 __dpctl_give DPCTLSyclDeviceSelectorRef
 DPCTLFilterSelector_Create(__dpctl_keep const char *filter_str);
 
 /*!
- * @brief Returns an opaque wrapper for sycl::gpu_selector object.
+ * @brief Returns an opaque wrapper for dpctl_gpu_selector object.
  *
- * @return An opaque pointer to a sycl::gpu_selector object.
+ * @return An opaque pointer to a dpctl_gpu_selector object.
  * @ingroup DeviceSelectors
  */
 DPCTL_API
 __dpctl_give DPCTLSyclDeviceSelectorRef DPCTLGPUSelector_Create(void);
 
 /*!
- * @brief Returns an opaque wrapper for sycl::host_selector object.
+ * @brief Returns an opaque wrapper for dpctl_host_selector object.
  *
- * @return An opaque pointer to a sycl::host_selector object.
+ * @return An opaque pointer to a dpctl_host_selector object.
  * @ingroup DeviceSelectors
  */
 DPCTL_API

libsyclinterface/include/dpctl_sycl_platform_interface.h

@@ -63,9 +63,10 @@ __dpctl_give DPCTLSyclPlatformRef DPCTLPlatform_Create(void);
 
 /*!
  * @brief Creates a new DPCTLSyclPlatformRef for a SYCL platform constructed
- * using the device_selector wrapped by DPCTLSyclDeviceSelectorRef.
+ * using the dpctl_device_selector wrapped by DPCTLSyclDeviceSelectorRef.
  *
- * @param    DSRef          An opaque pointer to a SYCL device_selector object.
+ * @param    DSRef          An opaque pointer to a SYCL dpctl_device_selector
+ * object.
  * @return   A new DPCTLSyclPlatformRef pointer wrapping a SYCL platform object.
  * @ingroup PlatformInterface
  */

libsyclinterface/include/dpctl_sycl_type_casters.hpp

@@ -30,23 +30,32 @@
 
 #include "dpctl_sycl_types.h"
 #include <CL/sycl.hpp>
+#include <iostream>
 #include <vector>
 
+namespace dpctl::syclinterface
+{
+
 #if __SYCL_COMPILER_VERSION >= 20221020
 
 class dpctl_device_selector
 {
 public:
     virtual ~dpctl_device_selector() = default;
-
-    virtual int operator()(const sycl::device &device) const = 0;
+    static constexpr int REJECT_DEVICE = -1;
+    virtual int operator()(const sycl::device &d) const
+    {
+        std::cout << "Outright rejecting "
+                  << d.get_info<sycl::info::device::name>() << std::endl;
+        return REJECT_DEVICE;
+    };
 };
 
 class dpctl_accelerator_selector : public dpctl_device_selector
 {
 public:
     dpctl_accelerator_selector() = default;
-    int operator()(const sycl::device &d) const
+    int operator()(const sycl::device &d) const override
     {
         return sycl::accelerator_selector_v(d);
     }
@@ -56,17 +65,19 @@ class dpctl_default_selector : public dpctl_device_selector
 {
 public:
     dpctl_default_selector() = default;
-    int operator()(const sycl::device &d) const
+    int operator()(const sycl::device &d) const override
     {
-        return sycl::default_selector_v(d);
+        auto score = sycl::default_selector_v(d);
+        std::cout << "Got score = " << score << std::endl;
+        return score;
     }
 };
 
 class dpctl_gpu_selector : public dpctl_device_selector
 {
 public:
     dpctl_gpu_selector() = default;
-    int operator()(const sycl::device &d) const
+    int operator()(const sycl::device &d) const override
     {
         return sycl::gpu_selector_v(d);
     }
@@ -76,7 +87,7 @@ class dpctl_cpu_selector : public dpctl_device_selector
 {
 public:
     dpctl_cpu_selector() = default;
-    int operator()(const sycl::device &d) const
+    int operator()(const sycl::device &d) const override
     {
         return sycl::cpu_selector_v(d);
     }
@@ -87,7 +98,7 @@ class dpctl_filter_selector : public dpctl_device_selector
 public:
     dpctl_filter_selector(const std::string &fs) : _impl(fs) {}
 
-    int operator()(const sycl::device &d) const
+    int operator()(const sycl::device &d) const override
     {
         return _impl(d);
     }
@@ -100,13 +111,10 @@ class dpctl_host_selector : public dpctl_device_selector
 {
 public:
     dpctl_host_selector() = default;
-    int operator()(const sycl::device &) const
+    int operator()(const sycl::device &) const override
     {
-        return REJECTED_SCORE;
+        return REJECT_DEVICE;
     }
-
-private:
-    constexpr static int REJECTED_SCORE = -1;
 };
 
 #else
@@ -201,22 +209,20 @@ class dpctl_host_selector : public dpctl_device_selector
 #endif
 
 /*!
-    @brief Creates two convenience functions to reinterpret_cast an opaque
-    pointer to a pointer to a Sycl type and vice-versa.
+    @brief Creates two convenience templated functions to
+    reinterpret_cast an opaque pointer to a pointer to a Sycl type
+    and vice-versa.
 */
 #define DEFINE_SIMPLE_CONVERSION_FUNCTIONS(ty, ref)                            \
-    __attribute__((unused)) inline ty *unwrap(ref P)                           \
+    template <typename T,                                                      \
+              std::enable_if_t<std::is_same<T, ty>::value, bool> = true>       \
+    __attribute__((unused)) T *unwrap(ref P)                                   \
     {                                                                          \
         return reinterpret_cast<ty *>(P);                                      \
-    }                                                                          \
-                                                                               \
-    __attribute__((unused)) inline ref wrap(const ty *P)                       \
-    {                                                                          \
-        return reinterpret_cast<ref>(const_cast<ty *>(P));                     \
     }                                                                          \
     template <typename T,                                                      \
               std::enable_if_t<std::is_same<T, ty>::value, bool> = true>       \
-    ref wrap(const ty *P)                                                      \
+    __attribute__((unused)) ref wrap(const ty *P)                              \
     {                                                                          \
         return reinterpret_cast<ref>(const_cast<ty *>(P));                     \
     }
@@ -247,3 +253,5 @@ DEFINE_SIMPLE_CONVERSION_FUNCTIONS(std::vector<DPCTLSyclEventRef>,
                                    DPCTLEventVectorRef)
 
 #endif
+
+} // namespace dpctl::syclinterface

libsyclinterface/source/dpctl_sycl_context_interface.cpp

@@ -32,21 +32,27 @@
 
 using namespace sycl;
 
+namespace
+{
+using namespace dpctl::syclinterface;
+} // end of anonymous namespace
+
 __dpctl_give DPCTLSyclContextRef
 DPCTLContext_Create(__dpctl_keep const DPCTLSyclDeviceRef DRef,
                     error_handler_callback *handler,
                     int /**/)
 {
     DPCTLSyclContextRef CRef = nullptr;
-    auto Device = unwrap(DRef);
+    auto Device = unwrap<device>(DRef);
     if (!Device) {
         error_handler("Cannot create device from DPCTLSyclDeviceRef"
                       "as input is a nullptr.",
                       __FILE__, __func__, __LINE__);
         return nullptr;
     }
     try {
-        CRef = wrap(new context(*Device, DPCTL_AsyncErrorHandler(handler)));
+        CRef = wrap<context>(
+            new context(*Device, DPCTL_AsyncErrorHandler(handler)));
     } catch (std::exception const &e) {
         error_handler(e, __FILE__, __func__, __LINE__);
     }
@@ -61,7 +67,7 @@ DPCTLContext_CreateFromDevices(__dpctl_keep const DPCTLDeviceVectorRef DVRef,
 {
     DPCTLSyclContextRef CRef = nullptr;
     std::vector<device> Devices;
-    auto DeviceRefs = unwrap(DVRef);
+    auto DeviceRefs = unwrap<std::vector<DPCTLSyclDeviceRef>>(DVRef);
     if (!DeviceRefs) {
         error_handler("Cannot create device reference from DPCTLDeviceVectorRef"
                       "as input is a nullptr.",
@@ -71,11 +77,12 @@ DPCTLContext_CreateFromDevices(__dpctl_keep const DPCTLDeviceVectorRef DVRef,
     Devices.reserve(DeviceRefs->size());
 
     for (auto const &DRef : *DeviceRefs) {
-        Devices.emplace_back(*unwrap(DRef));
+        Devices.emplace_back(*unwrap<device>(DRef));
     }
 
     try {
-        CRef = wrap(new context(Devices, DPCTL_AsyncErrorHandler(handler)));
+        CRef = wrap<context>(
+            new context(Devices, DPCTL_AsyncErrorHandler(handler)));
     } catch (std::exception const &e) {
         error_handler(e, __FILE__, __func__, __LINE__);
     }
@@ -91,21 +98,21 @@ bool DPCTLContext_AreEq(__dpctl_keep const DPCTLSyclContextRef CtxRef1,
                       __LINE__);
         return false;
     }
-    return (*unwrap(CtxRef1) == *unwrap(CtxRef2));
+    return (*unwrap<context>(CtxRef1) == *unwrap<context>(CtxRef2));
 }
 
 __dpctl_give DPCTLSyclContextRef
 DPCTLContext_Copy(__dpctl_keep const DPCTLSyclContextRef CRef)
 {
-    auto Context = unwrap(CRef);
+    auto Context = unwrap<context>(CRef);
     if (!Context) {
         error_handler("Cannot copy DPCTLSyclContextRef as input is a nullptr.",
                       __FILE__, __func__, __LINE__);
         return nullptr;
     }
     try {
         auto CopiedContext = new context(*Context);
-        return wrap(CopiedContext);
+        return wrap<context>(CopiedContext);
     } catch (std::exception const &e) {
         error_handler(e, __FILE__, __func__, __LINE__);
         return nullptr;
@@ -115,16 +122,17 @@ DPCTLContext_Copy(__dpctl_keep const DPCTLSyclContextRef CRef)
 __dpctl_give DPCTLDeviceVectorRef
 DPCTLContext_GetDevices(__dpctl_keep const DPCTLSyclContextRef CRef)
 {
-    auto Context = unwrap(CRef);
+    auto Context = unwrap<context>(CRef);
     if (!Context) {
         error_handler("Cannot retrieve devices from DPCTLSyclContextRef as "
                       "input is a nullptr.",
                       __FILE__, __func__, __LINE__);
         return nullptr;
     }
-    std::vector<DPCTLSyclDeviceRef> *DevicesVectorPtr = nullptr;
+    using vecTy = std::vector<DPCTLSyclDeviceRef>;
+    vecTy *DevicesVectorPtr = nullptr;
     try {
-        DevicesVectorPtr = new std::vector<DPCTLSyclDeviceRef>();
+        DevicesVectorPtr = new vecTy();
     } catch (std::exception const &e) {
         delete DevicesVectorPtr;
         error_handler(e, __FILE__, __func__, __LINE__);
@@ -134,9 +142,9 @@ DPCTLContext_GetDevices(__dpctl_keep const DPCTLSyclContextRef CRef)
         auto Devices = Context->get_devices();
         DevicesVectorPtr->reserve(Devices.size());
         for (const auto &Dev : Devices) {
-            DevicesVectorPtr->emplace_back(wrap(new device(Dev)));
+            DevicesVectorPtr->emplace_back(wrap<device>(new device(Dev)));
         }
-        return wrap(DevicesVectorPtr);
+        return wrap<vecTy>(DevicesVectorPtr);
     } catch (std::exception const &e) {
         delete DevicesVectorPtr;
         error_handler(e, __FILE__, __func__, __LINE__);
@@ -146,7 +154,7 @@ DPCTLContext_GetDevices(__dpctl_keep const DPCTLSyclContextRef CRef)
 
 size_t DPCTLContext_DeviceCount(__dpctl_keep const DPCTLSyclContextRef CRef)
 {
-    auto Context = unwrap(CRef);
+    auto Context = unwrap<context>(CRef);
     if (!Context) {
         error_handler("Cannot retrieve devices from DPCTLSyclContextRef as "
                       "input is a nullptr.",
@@ -159,7 +167,7 @@ size_t DPCTLContext_DeviceCount(__dpctl_keep const DPCTLSyclContextRef CRef)
 
 bool DPCTLContext_IsHost(__dpctl_keep const DPCTLSyclContextRef CtxRef)
 {
-    auto Ctx = unwrap(CtxRef);
+    auto Ctx = unwrap<context>(CtxRef);
     if (Ctx) {
         return Ctx->is_host();
     }
@@ -168,7 +176,7 @@ bool DPCTLContext_IsHost(__dpctl_keep const DPCTLSyclContextRef CtxRef)
 
 void DPCTLContext_Delete(__dpctl_take DPCTLSyclContextRef CtxRef)
 {
-    delete unwrap(CtxRef);
+    delete unwrap<context>(CtxRef);
 }
 
 DPCTLSyclBackendType
@@ -178,7 +186,7 @@ DPCTLContext_GetBackend(__dpctl_keep const DPCTLSyclContextRef CtxRef)
         return DPCTL_UNKNOWN_BACKEND;
     }
 
-    auto BE = unwrap(CtxRef)->get_platform().get_backend();
+    auto BE = unwrap<context>(CtxRef)->get_platform().get_backend();
 
     switch (BE) {
     case backend::host:
@@ -197,7 +205,7 @@ DPCTLContext_GetBackend(__dpctl_keep const DPCTLSyclContextRef CtxRef)
 size_t DPCTLContext_Hash(__dpctl_keep const DPCTLSyclContextRef CtxRef)
 {
     if (CtxRef) {
-        auto C = unwrap(CtxRef);
+        auto C = unwrap<context>(CtxRef);
         std::hash<context> hash_fn;
         return hash_fn(*C);
     }