[bugfix, enhancement] enable proper GPU offloading with fp64 support when DPCtl unavailable

onedal/_device_offload.py

@@ -29,37 +29,17 @@
     from dpctl import SyclQueue
     from dpctl.memory import MemoryUSMDevice, as_usm_memory
     from dpctl.tensor import usm_ndarray
+else:
+    import onedal
+
+    SyclQueue = getattr(onedal._backend, "SyclQueue", None)
 
 if dpnp_available:
     import dpnp
 
     from .utils._array_api import _convert_to_dpnp
 
 
-class DummySyclQueue:
-    """This class is designed to act like dpctl.SyclQueue
-    to allow device dispatching in scenarios when dpctl is not available"""
-
-    class DummySyclDevice:
-        def __init__(self, filter_string):
-            self._filter_string = filter_string
-            self.is_cpu = "cpu" in filter_string
-            self.is_gpu = "gpu" in filter_string
-            self.has_aspect_fp64 = self.is_cpu
-
-            if not (self.is_cpu):
-                logging.warning(
-                    "Device support is limited. "
-                    "Please install dpctl for full experience"
-                )
-
-        def get_filter_string(self):
-            return self._filter_string
-
-    def __init__(self, filter_string):
-        self.sycl_device = self.DummySyclDevice(filter_string)
-
-
 def _copy_to_usm(queue, array):
     if not dpctl_available:
         raise RuntimeError(
@@ -139,12 +119,10 @@ def _transfer_to_host(queue, *data):
 def _get_global_queue():
     target = _get_config()["target_offload"]
 
-    QueueClass = DummySyclQueue if not dpctl_available else SyclQueue
-
     if target != "auto":
-        if isinstance(target, QueueClass):
+        if isinstance(target, SyclQueue):
             return target
-        return QueueClass(target)
+        return SyclQueue(target)
     return None
 
 

onedal/common/_policy.py

@@ -48,12 +48,8 @@ def __init__(self):
 
 
 if _is_dpc_backend:
-    from onedal._device_offload import DummySyclQueue
 
     class _DataParallelInteropPolicy(_backend.data_parallel_policy):
         def __init__(self, queue):
             self._queue = queue
-            if isinstance(queue, DummySyclQueue):
-                super().__init__(self._queue.sycl_device.get_filter_string())
-                return
             super().__init__(self._queue)

onedal/common/policy.cpp

@@ -15,7 +15,7 @@
 *******************************************************************************/
 
 #include "oneapi/dal/detail/policy.hpp"
-#include "onedal/common/policy_common.hpp"
+#include "onedal/common/policy.hpp"
 #include "onedal/common/pybind11_helpers.hpp"
 
 namespace py = pybind11;
@@ -41,12 +41,28 @@ void instantiate_default_host_policy(py::module& m) {
 
 #ifdef ONEDAL_DATA_PARALLEL
 
-using data_parallel_policy_t = dal::detail::data_parallel_policy;
+using dp_policy_t = dal::detail::data_parallel_policy;
+
+dp_policy_t make_dp_policy(std::uint32_t id) {
+    sycl::queue queue = get_queue_by_device_id(id);
+    return dp_policy_t{ std::move(queue) };
+}
+
+dp_policy_t make_dp_policy(const py::object& syclobj) {
+    sycl::queue queue = get_queue_from_python(syclobj);
+    return dp_policy_t{ std::move(queue) };
+}
+
+dp_policy_t make_dp_policy(const std::string& filter) {
+    sycl::queue queue = get_queue_by_filter_string(filter);
+    return dp_policy_t{ std::move(queue) };
+}
 
 void instantiate_data_parallel_policy(py::module& m) {
     constexpr const char name[] = "data_parallel_policy";
-    py::class_<data_parallel_policy_t> policy(m, name);
-    policy.def(py::init<data_parallel_policy_t>());
+    py::class_<dp_policy_t> policy(m, name);
+    policy.def(py::init<dp_policy_t>());
+    policy.def(py::init<const sycl::queue&>());
     policy.def(py::init([](std::uint32_t id) {
         return make_dp_policy(id);
     }));
@@ -56,10 +72,10 @@ void instantiate_data_parallel_policy(py::module& m) {
     policy.def(py::init([](const py::object& syclobj) {
         return make_dp_policy(syclobj);
     }));
-    policy.def("get_device_id", [](const data_parallel_policy_t& policy) {
+    policy.def("get_device_id", [](const dp_policy_t& policy) {
         return get_device_id(policy);
     });
-    policy.def("get_device_name", [](const data_parallel_policy_t& policy) {
+    policy.def("get_device_name", [](const dp_policy_t& policy) {
         return get_device_name(policy);
     });
     m.def("get_used_memory", &get_used_memory, py::return_value_policy::take_ownership);

onedal/common/policy.hpp

@@ -0,0 +1,62 @@
+/*******************************************************************************
+* Copyright 2024 Intel Corporation
+*
+* Licensed under the Apache License, Version 2.0 (the "License");
+* you may not use this file except in compliance with the License.
+* You may obtain a copy of the License at
+*
+*     http://www.apache.org/licenses/LICENSE-2.0
+*
+* Unless required by applicable law or agreed to in writing, software
+* distributed under the License is distributed on an "AS IS" BASIS,
+* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+* See the License for the specific language governing permissions and
+* limitations under the License.
+*******************************************************************************/
+
+#pragma once
+
+#include <string>
+#include <cstdint>
+
+#ifdef ONEDAL_DATA_PARALLEL
+#include <sycl/sycl.hpp>
+#endif // ONEDAL_DATA_PARALLEL
+
+#include <pybind11/pybind11.h>
+
+#include "oneapi/dal/detail/policy.hpp"
+
+#include "onedal/common/sycl_interfaces.hpp"
+
+namespace py = pybind11;
+
+namespace oneapi::dal::python {
+
+#ifdef ONEDAL_DATA_PARALLEL
+
+using dp_policy_t = detail::data_parallel_policy;
+
+dp_policy_t make_dp_policy(std::uint32_t id);
+dp_policy_t make_dp_policy(const py::object& syclobj);
+dp_policy_t make_dp_policy(const std::string& filter);
+inline dp_policy_t make_dp_policy(const dp_policy_t& policy) {
+    return dp_policy_t{ policy };
+}
+
+#endif // ONEDAL_DATA_PARALLEL
+
+template <typename Policy>
+inline auto& instantiate_host_policy(py::class_<Policy>& policy) {
+    policy.def(py::init<>());
+    policy.def(py::init<Policy>());
+    policy.def("get_device_id", [](const Policy&) -> std::uint32_t {
+        return std::uint32_t{ 0u };
+    });
+    policy.def("get_device_name", [](const Policy&) -> std::string {
+        return std::string{ "cpu" };
+    });
+    return policy;
+}
+
+} // namespace oneapi::dal::python

onedal/common/spmd_policy.cpp

@@ -19,7 +19,7 @@
 #include "oneapi/dal/detail/spmd_policy.hpp"
 #include "oneapi/dal/spmd/mpi/communicator.hpp"
 
-#include "onedal/common/policy_common.hpp"
+#include "onedal/common/policy.hpp"
 #include "onedal/common/pybind11_helpers.hpp"
 
 namespace py = pybind11;

onedal/common/sycl.cpp

@@ -0,0 +1,77 @@
+/*******************************************************************************
+* Copyright 2024 Intel Corporation
+*
+* Licensed under the Apache License, Version 2.0 (the "License");
+* you may not use this file except in compliance with the License.
+* You may obtain a copy of the License at
+*
+*     http://www.apache.org/licenses/LICENSE-2.0
+*
+* Unless required by applicable law or agreed to in writing, software
+* distributed under the License is distributed on an "AS IS" BASIS,
+* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+* See the License for the specific language governing permissions and
+* limitations under the License.
+*******************************************************************************/
+
+#include "onedal/common/sycl_interfaces.hpp"
+#include "onedal/common/pybind11_helpers.hpp"
+
+namespace py = pybind11;
+
+namespace oneapi::dal::python {
+
+#ifdef ONEDAL_DATA_PARALLEL
+
+void instantiate_sycl_interfaces(py::module& m){
+    py::class_<sycl::queue> syclqueue(m, "SyclQueue");
+    syclqueue.def(py::init<const sycl::device&>())
+        .def(py::init([](const std::string& filter) {
+                return get_queue_by_filter_string(filter);
+            })
+        )
+        .def(py::init([](const py::int_& obj) {
+                return get_queue_by_pylong_pointer(obj);
+            })
+        )
+        .def(py::init([](const py::object& syclobj) {
+                return get_queue_from_python(syclobj);
+            })
+        )
+        .def("_get_capsule",[](const sycl::queue& queue) {
+                return pack_queue(std::make_shared<sycl::queue>(queue));
+            }
+        )
+        .def_property_readonly("sycl_device", &sycl::queue::get_device);
+
+    // expose limited sycl device features to python for oneDAL analysis
+    py::class_<sycl::device> sycldevice(m, "SyclDevice");
+        sycldevice.def(py::init([](std::uint32_t id) {
+                return get_device_by_id(id).value();
+            })
+        )
+        .def_property_readonly("has_aspect_fp64",[](const sycl::device& device) {
+                return device.has(sycl::aspect::fp64);
+            }
+        )
+        .def_property_readonly("has_aspect_fp16",[](const sycl::device& device) {
+                return device.has(sycl::aspect::fp16);
+            }
+        )
+        .def_property_readonly("filter_string",[](const sycl::device& device) {
+                // assumes we are not working with accelerators
+                std::string filter = get_device_name(device);
+                py::int_ id(get_device_id(device).value());
+                return py::str(filter + ":") + py::str(id);
+            }
+        )
+        .def_property_readonly("is_cpu", &sycl::device::is_cpu)
+        .def_property_readonly("is_gpu", &sycl::device::is_gpu);
+}
+
+ONEDAL_PY_INIT_MODULE(sycl) {
+    instantiate_sycl_interfaces(m);
+}
+#endif
+
+} // namespace oneapi::dal::python