Reworked engines classes whech bind with python

Author: antonwolfy

dpnp/backend/extensions/rng/device/common_impl.hpp

@@ -30,9 +30,6 @@
 #include <sycl/sycl.hpp>
 #include <oneapi/mkl/rng/device.hpp>
 
-// dpctl tensor headers
-// #include "utils/offset_utils.hpp"
-
 namespace dpnp
 {
 namespace backend
@@ -71,14 +68,15 @@ struct RngContigFunctor
 
     void operator()(sycl::nd_item<1> nd_it) const
     {
-        auto global_id = nd_it.get_global_id();
+        // auto global_id = nd_it.get_global_id();
 
         auto sg = nd_it.get_sub_group();
         const std::uint8_t sg_size = sg.get_local_range()[0];
         const std::uint8_t max_sg_size = sg.get_max_local_range()[0];
 
         using EngineT = typename EngineBuilderT::EngineType;
-        EngineT engine = engine_(nelems_ * global_id); // offset is questionable...
+        // EngineT engine = engine_(nelems_ * global_id); // offset is questionable...
+        EngineT engine = engine_();
 
         using DistrT = typename DistributorBuilderT::distr_type;
         DistrT distr = distr_();

dpnp/backend/extensions/rng/device/engine/base_engine.hpp

@@ -59,20 +59,52 @@ class EngineType {
 constexpr int no_of_engines = EngineType::base_id();
 
 class EngineBase {
+private:
+    sycl::queue q_{};
+    std::vector<std::uint64_t> seed_vec{};
+    std::vector<std::uint64_t> offset_vec{};
+
 public:
+    EngineBase() {}
+
+    EngineBase(sycl::queue &q, std::uint64_t seed, std::uint64_t offset) :
+        q_(q), seed_vec(1, seed), offset_vec(1, offset) {}
+
+    EngineBase(sycl::queue &q, std::vector<std::uint64_t> &seeds, std::uint64_t offset) :
+        q_(q), seed_vec(seeds), offset_vec(1, offset) {}
+
+    EngineBase(sycl::queue &q, std::vector<std::uint32_t> &seeds, std::uint64_t offset) : q_(q), offset_vec(1, offset) {
+        seed_vec.reserve(seeds.size());
+        seed_vec.assign(seeds.begin(), seeds.end());
+    }
+
+    EngineBase(sycl::queue &q, std::uint64_t seed, std::vector<std::uint64_t> &offsets) :
+        q_(q), seed_vec(1, seed), offset_vec(offsets) {}
+
+    EngineBase(sycl::queue &q, std::vector<std::uint64_t> &seeds, std::vector<std::uint64_t> &offsets) :
+        q_(q), seed_vec(seeds), offset_vec(offsets) {}
+
+    EngineBase(sycl::queue &q, std::vector<std::uint32_t> &seeds, std::vector<std::uint64_t> &offsets) : q_(q), offset_vec(offsets) {
+        seed_vec.reserve(seeds.size());
+        seed_vec.assign(seeds.begin(), seeds.end());
+    }
+
     virtual ~EngineBase() {}
-    virtual sycl::queue &get_queue() = 0;
 
     virtual EngineType get_type() const noexcept {
         return EngineType::Base;
     }
 
-    virtual std::vector<std::uint64_t> get_seeds() const noexcept {
-        return std::vector<std::uint64_t>();
+    sycl::queue &get_queue() noexcept {
+        return q_;
+    }
+
+    std::vector<std::uint64_t>& get_seeds() noexcept {
+        return seed_vec;
     }
 
-    virtual std::vector<std::uint64_t> get_offsets() const noexcept {
-        return std::vector<std::uint64_t>();
+    std::vector<std::uint64_t>& get_offsets() noexcept {
+        return offset_vec;
     }
 };
 } // dpnp::backend::ext::rng::device::engine

dpnp/backend/extensions/rng/device/engine/mcg31m1_engine.hpp

@@ -31,31 +31,15 @@
 namespace dpnp::backend::ext::rng::device::engine
 {
 class MCG31M1 : public EngineBase {
-private:
-    sycl::queue q_;
-    std::vector<std::uint64_t> seed_vec{};
-    std::vector<std::uint64_t> offset_vec{};
-
 public:
-    MCG31M1(sycl::queue &q, std::uint32_t seed, std::uint64_t offset = 0) : q_(q) {
-        seed_vec.push_back(seed);
-        offset_vec.push_back(offset);
-    }
+    MCG31M1(sycl::queue &q, std::uint32_t seed, std::uint64_t offset = 0) :
+        EngineBase(q, seed, offset) {}
 
-    sycl::queue &get_queue() override {
-        return q_;
-    }
+    MCG31M1(sycl::queue &q, std::vector<std::uint32_t> &seeds, std::uint64_t offset = 0) :
+        EngineBase(q, seeds, offset) {}
 
     virtual EngineType get_type() const noexcept override {
         return EngineType::MCG31M1;
     }
-
-    virtual std::vector<std::uint64_t> get_seeds() const noexcept override {
-        return seed_vec;
-    }
-
-    virtual std::vector<std::uint64_t> get_offsets() const noexcept override {
-        return offset_vec;
-    }
 };
 } // dpnp::backend::ext::rng::device::engine

dpnp/backend/extensions/rng/device/engine/mcg59_engine.hpp

@@ -31,31 +31,15 @@
 namespace dpnp::backend::ext::rng::device::engine
 {
 class MCG59 : public EngineBase {
-private:
-    sycl::queue q_;
-    std::vector<std::uint64_t> seed_vec{};
-    std::vector<std::uint64_t> offset_vec{};
-
 public:
-    MCG59(sycl::queue &q, std::uint32_t seed, std::uint64_t offset = 0) : q_(q) {
-        seed_vec.push_back(seed);
-        offset_vec.push_back(offset);
-    }
+    MCG59(sycl::queue &q, std::uint32_t seed, std::uint64_t offset = 0) :
+        EngineBase(q, seed, offset) {}
 
-    sycl::queue &get_queue() override {
-        return q_;
-    }
+    MCG59(sycl::queue &q, std::vector<std::uint32_t> &seeds, std::uint64_t offset = 0) :
+        EngineBase(q, seeds, offset) {}
 
     virtual EngineType get_type() const noexcept override {
         return EngineType::MCG59;
     }
-
-    virtual std::vector<std::uint64_t> get_seeds() const noexcept override {
-        return seed_vec;
-    }
-
-    virtual std::vector<std::uint64_t> get_offsets() const noexcept override {
-        return offset_vec;
-    }
 };
 } // dpnp::backend::ext::rng::device::engine

dpnp/backend/extensions/rng/device/engine/mrg32k3a_engine.hpp

@@ -31,31 +31,21 @@
 namespace dpnp::backend::ext::rng::device::engine
 {
 class MRG32k3a : public EngineBase {
-private:
-    sycl::queue q_;
-    std::vector<std::uint64_t> seed_vec{};
-    std::vector<std::uint64_t> offset_vec{};
-
 public:
-    MRG32k3a(sycl::queue &q, std::uint32_t seed, std::uint64_t offset = 0) : q_(q) {
-        seed_vec.push_back(seed);
-        offset_vec.push_back(offset);
-    }
+    MRG32k3a(sycl::queue &q, std::uint32_t seed, std::uint64_t offset = 0) :
+        EngineBase(q, seed, offset) {}
 
-    sycl::queue &get_queue() override {
-        return q_;
-    }
+    MRG32k3a(sycl::queue &q, std::vector<std::uint32_t> &seeds, std::uint64_t offset = 0) :
+        EngineBase(q, seeds, offset) {}
 
-    virtual EngineType get_type() const noexcept override {
-        return EngineType::MRG32k3a;
-    }
+    MRG32k3a(sycl::queue &q, std::uint32_t seed, std::vector<std::uint64_t> &offsets) :
+        EngineBase(q, seed, offsets) {}
 
-    virtual std::vector<std::uint64_t> get_seeds() const noexcept override {
-        return seed_vec;
-    }
+    MRG32k3a(sycl::queue &q, std::vector<std::uint32_t> &seeds, std::vector<std::uint64_t> &offsets) :
+        EngineBase(q, seeds, offsets) {}
 
-    virtual std::vector<std::uint64_t> get_offsets() const noexcept override {
-        return offset_vec;
+    virtual EngineType get_type() const noexcept override {
+        return EngineType::MRG32k3a;
     }
 };
 } // dpnp::backend::ext::rng::device::engine

dpnp/backend/extensions/rng/device/engine/philox4x32x10_engine.hpp

@@ -31,31 +31,21 @@
 namespace dpnp::backend::ext::rng::device::engine
 {
 class PHILOX4x32x10 : public EngineBase {
-private:
-    sycl::queue q_;
-    std::vector<std::uint64_t> seed_vec{};
-    std::vector<std::uint64_t> offset_vec{};
-
 public:
-    PHILOX4x32x10(sycl::queue &q, std::uint64_t seed, std::uint64_t offset = 0) : q_(q) {
-        seed_vec.push_back(seed);
-        offset_vec.push_back(offset);
-    }
+    PHILOX4x32x10(sycl::queue &q, std::uint64_t seed, std::uint64_t offset = 0) :
+        EngineBase(q, seed, offset) {}
 
-    sycl::queue &get_queue() override {
-        return q_;
-    }
+    PHILOX4x32x10(sycl::queue &q, std::vector<std::uint64_t> &seeds, std::uint64_t offset = 0) :
+        EngineBase(q, seeds, offset) {}
 
-    virtual EngineType get_type() const noexcept override {
-        return EngineType::PHILOX4x32x10;
-    }
+    PHILOX4x32x10(sycl::queue &q, std::uint64_t seed, std::vector<std::uint64_t> &offsets) :
+        EngineBase(q, seed, offsets) {}
 
-    virtual std::vector<std::uint64_t> get_seeds() const noexcept override {
-        return seed_vec;
-    }
+    PHILOX4x32x10(sycl::queue &q, std::vector<std::uint64_t> &seeds, std::vector<std::uint64_t> &offsets) :
+        EngineBase(q, seeds, offsets) {}
 
-    virtual std::vector<std::uint64_t> get_offsets() const noexcept override {
-        return offset_vec;
+    virtual EngineType get_type() const noexcept override {
+        return EngineType::PHILOX4x32x10;
     }
 };
 } // dpnp::backend::ext::rng::device::engine

dpnp/backend/extensions/rng/device/gaussian.cpp

@@ -26,38 +26,26 @@
 #include <pybind11/pybind11.h>
 
 // dpctl tensor headers
-// #include "utils/memory_overlap.hpp"
 #include "utils/type_dispatch.hpp"
 #include "utils/type_utils.hpp"
-
-// dpctl tensor headers
 #include "kernels/alignment.hpp"
 
-#include "common_impl.hpp"
 #include "gaussian.hpp"
+#include "common_impl.hpp"
 
-#include "engine/base_engine.hpp"
 #include "engine/builder/builder.hpp"
 
 #include "dispatch/matrix.hpp"
 #include "dispatch/table_builder.hpp"
 
 
-namespace dpnp
-{
-namespace backend
-{
-namespace ext
-{
-namespace rng
-{
-namespace device
+namespace dpnp::backend::ext::rng::device
 {
 namespace dpctl_krn_ns = dpctl::tensor::kernels::alignment_utils;
 namespace dpctl_td_ns = dpctl::tensor::type_dispatch;
+namespace dpctl_tu_ns = dpctl::tensor::type_utils;
 namespace mkl_rng_dev = oneapi::mkl::rng::device;
 namespace py = pybind11;
-namespace type_utils = dpctl::tensor::type_utils;
 
 using dpctl_krn_ns::disabled_sg_loadstore_wrapper_krn;
 using dpctl_krn_ns::is_aligned;
@@ -109,7 +97,7 @@ static sycl::event gaussian_impl(engine::EngineBase *engine,
                                  const std::vector<sycl::event> &depends)
 {
     auto &exec_q = engine->get_queue();
-    type_utils::validate_type_for_device<DataT>(exec_q);
+    dpctl_tu_ns::validate_type_for_device<DataT>(exec_q);
 
     DataT *out = reinterpret_cast<DataT *>(out_ptr);
     DataT mean = static_cast<DataT>(mean_val);
@@ -242,13 +230,9 @@ struct GaussianContigFactory
     }
 };
 
-void init_gaussian_dispatch_table(void)
+void init_gaussian_dispatch_3d_table(void)
 {
     dispatch::Dispatch3DTableBuilder<gaussian_impl_fn_ptr_t, GaussianContigFactory, engine::no_of_engines, dpctl_td_ns::num_types, no_of_methods> contig;
     contig.populate(gaussian_dispatch_table);
 }
-} // namespace device
-} // namespace rng
-} // namespace ext
-} // namespace backend
-} // namespace dpnp
+} // dpnp::backend::ext::rng::device

dpnp/backend/extensions/rng/device/gaussian.hpp

@@ -25,10 +25,6 @@
 
 #pragma once
 
-#include <sycl/sycl.hpp>
-#include <oneapi/mkl.hpp>
-#include <oneapi/mkl/rng/device.hpp>
-
 #include <dpctl4pybind11.hpp>
 
 #include "engine/base_engine.hpp"
@@ -44,5 +40,5 @@ extern std::pair<sycl::event, sycl::event> gaussian(engine::EngineBase *engine,
                                                     dpctl::tensor::usm_ndarray res,
                                                     const std::vector<sycl::event> &depends = {});
 
-extern void init_gaussian_dispatch_table(void);
+extern void init_gaussian_dispatch_3d_table(void);
 } // namespace dpnp::backend::ext::rng::device