From 93478c3a0578a808b3809539ebf4bf45419a09ba Mon Sep 17 00:00:00 2001
From: Fritz Goebel <fritz.goebel@kit.edu>
Date: Wed, 29 Nov 2023 15:55:44 +0000
Subject: [PATCH] Fix missed moves to gko::experimental::mpi

---
 include/ginkgo/core/distributed/matrix.hpp | 145 ++++++++++++++++++++-
 1 file changed, 143 insertions(+), 2 deletions(-)

diff --git a/include/ginkgo/core/distributed/matrix.hpp b/include/ginkgo/core/distributed/matrix.hpp
index b8d0807df8e..a32d6c3fb16 100644
--- a/include/ginkgo/core/distributed/matrix.hpp
+++ b/include/ginkgo/core/distributed/matrix.hpp
@@ -117,6 +117,147 @@ auto with_matrix_type(Args&&... create_args)
 }
 
 
+namespace experimental {
+namespace distributed {
+
+#include <ginkgo/config.hpp>
+
+
+#if GINKGO_BUILD_MPI
+
+
+#include <ginkgo/core/base/dense_cache.hpp>
+#include <ginkgo/core/base/mpi.hpp>
+#include <ginkgo/core/distributed/base.hpp>
+#include <ginkgo/core/distributed/lin_op.hpp>
+
+
+namespace gko {
+namespace matrix {
+
+
+template <typename ValueType, typename IndexType>
+class Csr;
+
+
+}
+
+
+namespace detail {
+
+
+/**
+#include <ginkgo/config.hpp>
+
+
+#if GINKGO_BUILD_MPI
+
+
+#include <ginkgo/core/base/dense_cache.hpp>
+#include <ginkgo/core/base/mpi.hpp>
+#include <ginkgo/core/distributed/base.hpp>
+#include <ginkgo/core/distributed/lin_op.hpp>
+
+
+namespace gko {
+namespace matrix {
+
+
+template <typename ValueType, typename IndexType>
+class Csr;
+
+
+}
+
+
+namespace detail {
+
+
+/**
+ * Helper struct to test if the Builder type has a function create<ValueType,
+ * IndexType>(std::shared_ptr<const Executor>).
+ */
+template <typename Builder, typename ValueType, typename IndexType,
+          typename = void>
+struct is_matrix_type_builder : std::false_type {};
+
+
+template <typename Builder, typename ValueType, typename IndexType>
+struct is_matrix_type_builder<
+    Builder, ValueType, IndexType,
+    gko::xstd::void_t<
+        decltype(std::declval<Builder>().template create<ValueType, IndexType>(
+            std::declval<std::shared_ptr<const Executor>>()))>>
+    : std::true_type {};
+
+
+template <template <typename, typename> class MatrixType,
+          typename... CreateArgs>
+struct MatrixTypeBuilderFromValueAndIndex {
+    template <typename ValueType, typename IndexType, std::size_t... I>
+    auto create_impl(std::shared_ptr<const Executor> exec,
+                     std::index_sequence<I...>)
+    {
+        return MatrixType<ValueType, IndexType>::create(
+            exec, std::get<I>(create_args)...);
+    }
+
+
+    template <typename ValueType, typename IndexType>
+    auto create(std::shared_ptr<const Executor> exec)
+    {
+        // with c++17 we could use std::apply
+        static constexpr auto size = sizeof...(CreateArgs);
+        return create_impl<ValueType, IndexType>(
+            std::move(exec), std::make_index_sequence<size>{});
+    }
+
+    std::tuple<CreateArgs...> create_args;
+};
+
+
+}  // namespace detail
+
+
+/**
+ * This function returns a type that delays a call to MatrixType::create.
+ *
+ * It can be used to set the used value and index type, as well as the executor
+ * at a later stage.
+ *
+ * For example, the following code creates first a temporary object, which is
+ * then used later to construct an operator of the previously defined base type:
+ * ```
+ * auto type = gko::with_matrix_type<gko::matrix::Csr>();
+ * ...
+ * std::unique_ptr<LinOp> concrete_op
+ * if(flag1){
+ *   concrete_op = type.template create<double, int>(exec);
+ * } else {
+ *   concrete_op = type.template create<float, int>(exec);
+ * }
+ * ```
+ *
+ * @note This is mainly a helper function to specify the local matrix type for a
+ *       gko::experimental::distributed::Matrix more easily.
+ *
+ * @tparam MatrixType  A template type that accepts two types, the first one
+ *                     will be set to the value type, the second one to the
+ *                     index type.
+ * @tparam Args  Types of the arguments passed to MatrixType::create.
+ *
+ * @param create_args  arguments that will be forwarded to MatrixType::create
+ *
+ * @return  A type with a function `create<value_type, index_type>(executor)`.
+ */
+template <template <typename, typename> class MatrixType, typename... Args>
+auto with_matrix_type(Args&&... create_args)
+{
+    return detail::MatrixTypeBuilderFromValueAndIndex<MatrixType, Args...>{
+        std::forward_as_tuple(create_args...)};
+}
+
+
 namespace experimental {
 namespace distributed {
 
@@ -359,8 +500,8 @@ class Matrix
     gko::matrix::Dense<ValueType>* get_recv_buffer() const
     {
         auto exec = this->get_executor();
-        auto use_host_buffer =
-            exec->get_master() != exec && !gko::mpi::is_gpu_aware();
+        auto use_host_buffer = exec->get_master() != exec &&
+                               !gko::experimental::mpi::is_gpu_aware();
         if (use_host_buffer) {
             recv_buffer_->copy_from(host_recv_buffer_.get());
         }