Implement basic Kokkos backend API changes for the cg_streaming solver type.

Note: functionality currently not implemented!

Author: breyerml

include/plssvm/backends/Kokkos/csvm.hpp

@@ -139,7 +139,7 @@ class csvm : public ::plssvm::detail::gpu_csvm<detail::device_ptr, detail::devic
     /**
      * @copydoc plssvm::detail::gpu_csvm::run_assemble_kernel_matrix_explicit
      */
-    [[nodiscard]] device_ptr_type run_assemble_kernel_matrix_explicit(std::size_t device_id, const ::plssvm::detail::execution_range &exec, const parameter &params, const device_ptr_type &data_d, const device_ptr_type &q_red_d, real_type QA_cost) const final;
+    [[nodiscard]] device_ptr_type run_assemble_kernel_matrix_explicit(std::size_t device_id, const ::plssvm::detail::execution_range &exec, const parameter &params, bool use_usm_allocations, const device_ptr_type &data_d, const device_ptr_type &q_red_d, real_type QA_cost) const final;
     /**
      * @copydoc plssvm::detail::gpu_csvm::run_blas_level_3_kernel_explicit
      */

include/plssvm/backends/Kokkos/detail/device_ptr.hpp

@@ -34,6 +34,7 @@ class device_ptr : public ::plssvm::detail::gpu_device_ptr<T, device_wrapper, de
     using base_type::data_;
     using base_type::queue_;
     using base_type::shape_;
+    using base_type::use_usm_allocations_;
 
   public:
     // Be able to use overloaded base class functions.
@@ -60,21 +61,24 @@ class device_ptr : public ::plssvm::detail::gpu_device_ptr<T, device_wrapper, de
      * @brief Allocates `size * sizeof(T)` bytes in the Kokkos execution space @p exec.
      * @param[in] size the number of elements represented by the device_ptr
      * @param[in] device the device wrapper
+     * @param[in] use_usm_allocations if `true` use USM allocations
      */
-    explicit device_ptr(size_type size, const device_wrapper &device);
+    explicit device_ptr(size_type size, const device_wrapper &device, bool use_usm_allocations = false);
     /**
      * @brief Allocates `shape.x * shape.y * sizeof(T)` bytes in the Kokkos execution space @p exec.
      * @param[in] shape the number of elements represented by the device_ptr
      * @param[in] device the device wrapper
+     * @param[in] use_usm_allocations if `true` use USM allocations
      */
-    explicit device_ptr(plssvm::shape shape, const device_wrapper &device);
+    explicit device_ptr(plssvm::shape shape, const device_wrapper &device, bool use_usm_allocations = false);
     /**
      * @brief Allocates `(shape.x + padding.x) * (shape.y + padding.y) * sizeof(T)` bytes in the Kokkos execution space @p exec.
      * @param[in] shape the number of elements represented by the device_ptr
      * @param[in] padding the number of padding elements added to the extent values
      * @param[in] device the device wrapper
+     * @param[in] use_usm_allocations if `true` use USM allocations
      */
-    device_ptr(plssvm::shape shape, plssvm::shape padding, const device_wrapper &device);
+    device_ptr(plssvm::shape shape, plssvm::shape padding, const device_wrapper &device, bool use_usm_allocations = false);
 
     /**
      * @copydoc plssvm::detail::gpu_device_ptr::gpu_device_ptr(const plssvm::detail::gpu_device_ptr &)

src/plssvm/backends/Kokkos/csvm.cpp

@@ -505,7 +505,7 @@ ::plssvm::detail::dim_type csvm::get_max_grid_size([[maybe_unused]] const std::s
 //                        fit                        //
 //***************************************************//
 
-auto csvm::run_assemble_kernel_matrix_explicit(const std::size_t device_id, const ::plssvm::detail::execution_range &exec, const parameter &params, const device_ptr_type &data_d, const device_ptr_type &q_red_d, real_type QA_cost) const -> device_ptr_type {
+auto csvm::run_assemble_kernel_matrix_explicit(const std::size_t device_id, const ::plssvm::detail::execution_range &exec, const parameter &params, const bool use_usm_allocations, const device_ptr_type &data_d, const device_ptr_type &q_red_d, real_type QA_cost) const -> device_ptr_type {
     const unsigned long long num_rows_reduced = data_d.shape().x - 1;
     const unsigned long long num_features = data_d.shape().y;
 
@@ -519,7 +519,10 @@ auto csvm::run_assemble_kernel_matrix_explicit(const std::size_t device_id, cons
     const ::plssvm::detail::triangular_data_distribution &dist = dynamic_cast<::plssvm::detail::triangular_data_distribution &>(*data_distribution_);
     const std::size_t num_entries_padded = dist.calculate_explicit_kernel_matrix_num_entries_padded(device_id);
 
-    device_ptr_type kernel_matrix_d{ num_entries_padded, devices_[device_id] };  // only explicitly store the upper triangular matrix
+    // only store the upper triangular matrix
+    // if solver == solver_type::cg_explicit: store it explicitly
+    // if solver == solver_type::cg_streaming: store it using USM
+    device_ptr_type kernel_matrix_d{ num_entries_padded, devices_[device_id], use_usm_allocations };
     const real_type cost_factor = real_type{ 1.0 } / params.cost;
     const std::size_t scratch_memory_size = static_cast<std::size_t>(2u * THREAD_BLOCK_SIZE * THREAD_BLOCK_SIZE * INTERNAL_BLOCK_SIZE) * sizeof(real_type);
 

src/plssvm/backends/Kokkos/detail/device_ptr.cpp

@@ -36,16 +36,20 @@ template <typename T>
 using host_view_type = Kokkos::View<T *, Kokkos::HostSpace, Kokkos::MemoryUnmanaged>;
 
 template <typename T>
-device_ptr<T>::device_ptr(const size_type size, const device_wrapper &device) :
-    device_ptr{ plssvm::shape{ size, 1 }, plssvm::shape{ 0, 0 }, device } { }
+device_ptr<T>::device_ptr(const size_type size, const device_wrapper &device, const bool use_usm_allocations) :
+    device_ptr{ plssvm::shape{ size, 1 }, plssvm::shape{ 0, 0 }, device, use_usm_allocations } { }
 
 template <typename T>
-device_ptr<T>::device_ptr(const plssvm::shape shape, const device_wrapper &device) :
-    device_ptr{ shape, plssvm::shape{ 0, 0 }, device } { }
+device_ptr<T>::device_ptr(const plssvm::shape shape, const device_wrapper &device, const bool use_usm_allocations) :
+    device_ptr{ shape, plssvm::shape{ 0, 0 }, device, use_usm_allocations } { }
 
 template <typename T>
-device_ptr<T>::device_ptr(const plssvm::shape shape, const plssvm::shape padding, const device_wrapper &device) :
-    base_type{ shape, padding, device } {
+device_ptr<T>::device_ptr(const plssvm::shape shape, const plssvm::shape padding, const device_wrapper &device, const bool use_usm_allocations) :
+    base_type{ shape, padding, device, use_usm_allocations } {
+    if (use_usm_allocations_) {
+        // TODO: implement
+        throw backend_exception{ "Not implemented yet!" };
+    }
     data_ = make_device_view_wrapper<T *>(device, this->size_padded());
     this->memset(0);
 }

tests/backends/Kokkos/detail/device_ptr.cpp

@@ -24,10 +24,11 @@
 
 #include <tuple>  // std::tuple
 
-template <typename T, plssvm::kokkos::execution_space exec_space>
+template <typename T, bool UAA, plssvm::kokkos::execution_space exec_space>
 struct kokkos_device_ptr_test_type {
     using device_ptr_type = plssvm::kokkos::detail::device_ptr<T>;
     using queue_type = plssvm::kokkos::detail::device_wrapper;
+    constexpr static bool use_usm_allocations = UAA;
     constexpr static plssvm::kokkos::execution_space space = exec_space;
 
     static const queue_type &default_queue() {
@@ -37,9 +38,9 @@ struct kokkos_device_ptr_test_type {
 };
 
 template <plssvm::kokkos::execution_space space>
-using kokkos_device_ptr_test_type_float = kokkos_device_ptr_test_type<float, space>;
+using kokkos_device_ptr_test_type_float = kokkos_device_ptr_test_type<float, false, space>;
 template <plssvm::kokkos::execution_space space>
-using kokkos_device_ptr_test_type_double = kokkos_device_ptr_test_type<double, space>;
+using kokkos_device_ptr_test_type_double = kokkos_device_ptr_test_type<double, false, space>;
 
 using kokkos_device_ptr_tuple = util::detail::concat_tuple_types_t<util::create_kokkos_test_tuple_t<kokkos_device_ptr_test_type_float>,
                                                                    util::create_kokkos_test_tuple_t<kokkos_device_ptr_test_type_double>>;
@@ -53,3 +54,25 @@ INSTANTIATE_TYPED_TEST_SUITE_P(KokkosDevicePtr, DevicePtr, kokkos_device_ptr_typ
 INSTANTIATE_TYPED_TEST_SUITE_P(KokkosDevicePtr, DevicePtrLayout, kokkos_device_ptr_layout_type_gtest, naming::test_parameter_to_name);
 
 INSTANTIATE_TYPED_TEST_SUITE_P(KokkosDevicePtrDeathTest, DevicePtrDeathTest, kokkos_device_ptr_type_gtest, naming::test_parameter_to_name);
+
+//
+// test USM pointer
+//
+
+template <plssvm::kokkos::execution_space space>
+using kokkos_usm_device_ptr_test_type_float = kokkos_device_ptr_test_type<float, true, space>;
+template <plssvm::kokkos::execution_space space>
+using kokkos_usm_device_ptr_test_type_double = kokkos_device_ptr_test_type<double, true, space>;
+
+using kokkos_device_ptr_usm_tuple = util::detail::concat_tuple_types_t<util::create_kokkos_test_tuple_t<kokkos_usm_device_ptr_test_type_float>,
+                                                                       util::create_kokkos_test_tuple_t<kokkos_usm_device_ptr_test_type_double>>;
+
+// the tests used in the instantiated GTest test suites
+using kokkos_device_ptr_usm_type_gtest = util::combine_test_parameters_gtest_t<util::cartesian_type_product_t<kokkos_device_ptr_usm_tuple>>;
+using kokkos_device_ptr_usm_layout_type_gtest = util::combine_test_parameters_gtest_t<util::cartesian_type_product_t<kokkos_device_ptr_usm_tuple>, util::layout_type_list>;
+
+// instantiate type-parameterized tests
+INSTANTIATE_TYPED_TEST_SUITE_P(KokkosDevicePtrUSM, DevicePtr, kokkos_device_ptr_usm_type_gtest, naming::test_parameter_to_name);
+INSTANTIATE_TYPED_TEST_SUITE_P(KokkosDevicePtrUSM, DevicePtrLayout, kokkos_device_ptr_usm_layout_type_gtest, naming::test_parameter_to_name);
+
+INSTANTIATE_TYPED_TEST_SUITE_P(KokkosDevicePtrUSMDeathTest, DevicePtrDeathTest, kokkos_device_ptr_usm_type_gtest, naming::test_parameter_to_name);