Ginkgo Generated from develop branch based on develop. Ginkgo version 1.10.0
A numerical linear algebra library targeting many-core architectures
 
Loading...
Searching...
No Matches
matrix.hpp
1// SPDX-FileCopyrightText: 2017 - 2025 The Ginkgo authors
2//
3// SPDX-License-Identifier: BSD-3-Clause
4
5#ifndef GKO_PUBLIC_CORE_DISTRIBUTED_MATRIX_HPP_
6#define GKO_PUBLIC_CORE_DISTRIBUTED_MATRIX_HPP_
7
8
9#include <ginkgo/config.hpp>
10
11
12#if GINKGO_BUILD_MPI
13
14
15#include <ginkgo/core/base/dense_cache.hpp>
16#include <ginkgo/core/base/lin_op.hpp>
17#include <ginkgo/core/base/mpi.hpp>
18#include <ginkgo/core/base/std_extensions.hpp>
19#include <ginkgo/core/distributed/base.hpp>
20#include <ginkgo/core/distributed/index_map.hpp>
21
22
23namespace gko {
24namespace matrix {
25
26
27template <typename ValueType, typename IndexType>
28class Csr;
29
30
31}
32
33
34namespace multigrid {
35
36
37template <typename ValueType, typename IndexType>
38class Pgm;
39
40
41}
42
43
44namespace detail {
45
46
51template <typename Builder, typename ValueType, typename IndexType,
52 typename = void>
53struct is_matrix_type_builder : std::false_type {};
54
55
56template <typename Builder, typename ValueType, typename IndexType>
57struct is_matrix_type_builder<
58 Builder, ValueType, IndexType,
59 xstd::void_t<
60 decltype(std::declval<Builder>().template create<ValueType, IndexType>(
61 std::declval<std::shared_ptr<const Executor>>()))>>
62 : std::true_type {};
63
64
65template <template <typename, typename> class MatrixType,
66 typename... CreateArgs>
67struct MatrixTypeBuilderFromValueAndIndex {
68 template <typename ValueType, typename IndexType, std::size_t... I>
69 auto create_impl(std::shared_ptr<const Executor> exec,
70 std::index_sequence<I...>)
71 {
72 return MatrixType<ValueType, IndexType>::create(
73 exec, std::get<I>(create_args)...);
74 }
75
76
77 template <typename ValueType, typename IndexType>
78 auto create(std::shared_ptr<const Executor> exec)
79 {
80 // with c++17 we could use std::apply
81 static constexpr auto size = sizeof...(CreateArgs);
82 return create_impl<ValueType, IndexType>(
83 std::move(exec), std::make_index_sequence<size>{});
84 }
85
86 std::tuple<CreateArgs...> create_args;
87};
88
89
90} // namespace detail
91
92
124template <template <typename, typename> class MatrixType, typename... Args>
125auto with_matrix_type(Args&&... create_args)
126{
127 return detail::MatrixTypeBuilderFromValueAndIndex<MatrixType, Args...>{
128 std::forward_as_tuple(create_args...)};
129}
130
131
132namespace experimental {
133namespace distributed {
134
135
145enum class assembly_mode { communicate, local_only };
146
147
148template <typename LocalIndexType, typename GlobalIndexType>
149class Partition;
150template <typename ValueType>
151class Vector;
152
153
258template <typename ValueType = default_precision,
259 typename LocalIndexType = int32, typename GlobalIndexType = int64>
261 : public EnableLinOp<Matrix<ValueType, LocalIndexType, GlobalIndexType>>,
262 public ConvertibleTo<
263 Matrix<next_precision<ValueType>, LocalIndexType, GlobalIndexType>>,
264#if GINKGO_ENABLE_HALF
265 public ConvertibleTo<Matrix<next_precision<next_precision<ValueType>>,
266 LocalIndexType, GlobalIndexType>>,
267#endif
268 public DistributedBase {
269 friend class EnablePolymorphicObject<Matrix, LinOp>;
270 friend class Matrix<previous_precision<ValueType>, LocalIndexType,
271 GlobalIndexType>;
272 friend class multigrid::Pgm<ValueType, LocalIndexType>;
273
274
275public:
276 using value_type = ValueType;
277 using index_type = GlobalIndexType;
278 using local_index_type = LocalIndexType;
279 using global_index_type = GlobalIndexType;
280 using global_vector_type =
282 using local_vector_type = typename global_vector_type::local_vector_type;
283
284 using EnableLinOp<Matrix>::convert_to;
285 using EnableLinOp<Matrix>::move_to;
287 GlobalIndexType>>::convert_to;
289 GlobalIndexType>>::move_to;
290
291 void convert_to(Matrix<next_precision<value_type>, local_index_type,
292 global_index_type>* result) const override;
293
294 void move_to(Matrix<next_precision<value_type>, local_index_type,
295 global_index_type>* result) override;
296#if GINKGO_ENABLE_HALF
297 friend class Matrix<previous_precision<previous_precision<ValueType>>,
298 LocalIndexType, GlobalIndexType>;
299 using ConvertibleTo<
301 global_index_type>>::convert_to;
303 local_index_type, global_index_type>>::move_to;
304
305 void convert_to(
307 global_index_type>* result) const override;
308
310 local_index_type, global_index_type>* result) override;
311
312#endif
333 partition,
334 assembly_mode assembly_type = assembly_mode::local_only);
335
348 partition,
349 assembly_mode assembly_type = assembly_mode::local_only);
350
372 row_partition,
374 col_partition,
375 assembly_mode assembly_type = assembly_mode::local_only);
376
389 row_partition,
391 col_partition,
392 assembly_mode assembly_type = assembly_mode::local_only);
393
399 std::shared_ptr<const LinOp> get_local_matrix() const { return local_mtx_; }
400
406 std::shared_ptr<const LinOp> get_non_local_matrix() const
407 {
408 return non_local_mtx_;
409 }
410
416 Matrix(const Matrix& other);
417
423 Matrix(Matrix&& other) noexcept;
424
433 Matrix& operator=(const Matrix& other);
434
444
454 static std::unique_ptr<Matrix> create(std::shared_ptr<const Executor> exec,
455 mpi::communicator comm);
456
477 template <typename MatrixType,
478 typename = std::enable_if_t<gko::detail::is_matrix_type_builder<
479 MatrixType, ValueType, LocalIndexType>::value>>
480 static std::unique_ptr<Matrix> create(std::shared_ptr<const Executor> exec,
482 MatrixType matrix_template)
483 {
484 return create(
485 exec, comm,
486 matrix_template.template create<ValueType, LocalIndexType>(exec));
487 }
488
517 template <typename LocalMatrixType, typename NonLocalMatrixType,
518 typename = std::enable_if_t<
519 gko::detail::is_matrix_type_builder<
520 LocalMatrixType, ValueType, LocalIndexType>::value &&
521 gko::detail::is_matrix_type_builder<
522 NonLocalMatrixType, ValueType, LocalIndexType>::value>>
523 static std::unique_ptr<Matrix> create(
524 std::shared_ptr<const Executor> exec, mpi::communicator comm,
525 LocalMatrixType local_matrix_template,
526 NonLocalMatrixType non_local_matrix_template)
527 {
528 return create(
529 exec, comm,
530 local_matrix_template.template create<ValueType, LocalIndexType>(
531 exec),
532 non_local_matrix_template
533 .template create<ValueType, LocalIndexType>(exec));
534 }
535
550 static std::unique_ptr<Matrix> create(
551 std::shared_ptr<const Executor> exec, mpi::communicator comm,
552 ptr_param<const LinOp> matrix_template);
553
570 static std::unique_ptr<Matrix> create(
571 std::shared_ptr<const Executor> exec, mpi::communicator comm,
572 ptr_param<const LinOp> local_matrix_template,
573 ptr_param<const LinOp> non_local_matrix_template);
574
587 static std::unique_ptr<Matrix> create(std::shared_ptr<const Executor> exec,
588 mpi::communicator comm, dim<2> size,
589 std::shared_ptr<LinOp> local_linop);
590
609 [[deprecated(
610 "Please use the overload with an index_map instead.")]] static std::
611 unique_ptr<Matrix>
612 create(std::shared_ptr<const Executor> exec, mpi::communicator comm,
613 dim<2> size, std::shared_ptr<LinOp> local_linop,
614 std::shared_ptr<LinOp> non_local_linop,
615 std::vector<comm_index_type> recv_sizes,
616 std::vector<comm_index_type> recv_offsets,
617 array<local_index_type> recv_gather_idxs);
618
632 static std::unique_ptr<Matrix> create(
633 std::shared_ptr<const Executor> exec, mpi::communicator comm,
635 std::shared_ptr<LinOp> local_linop,
636 std::shared_ptr<LinOp> non_local_linop);
637
646
655
656protected:
657 explicit Matrix(std::shared_ptr<const Executor> exec,
658 mpi::communicator comm);
659
660 explicit Matrix(std::shared_ptr<const Executor> exec,
662 ptr_param<const LinOp> local_matrix_template,
663 ptr_param<const LinOp> non_local_matrix_template);
664
665 explicit Matrix(std::shared_ptr<const Executor> exec,
666 mpi::communicator comm, dim<2> size,
667 std::shared_ptr<LinOp> local_linop);
668
669 explicit Matrix(std::shared_ptr<const Executor> exec,
672 std::shared_ptr<LinOp> local_linop,
673 std::shared_ptr<LinOp> non_local_linop);
674
683 mpi::request communicate(const local_vector_type* local_b) const;
684
685 void apply_impl(const LinOp* b, LinOp* x) const override;
686
687 void apply_impl(const LinOp* alpha, const LinOp* b, const LinOp* beta,
688 LinOp* x) const override;
689
690private:
692 std::vector<comm_index_type> send_offsets_;
693 std::vector<comm_index_type> send_sizes_;
694 std::vector<comm_index_type> recv_offsets_;
695 std::vector<comm_index_type> recv_sizes_;
696 array<local_index_type> gather_idxs_;
697 gko::detail::DenseCache<value_type> one_scalar_;
698 gko::detail::DenseCache<value_type> host_send_buffer_;
699 gko::detail::DenseCache<value_type> host_recv_buffer_;
700 gko::detail::DenseCache<value_type> send_buffer_;
701 gko::detail::DenseCache<value_type> recv_buffer_;
702 std::shared_ptr<LinOp> local_mtx_;
703 std::shared_ptr<LinOp> non_local_mtx_;
704};
705
706
707} // namespace distributed
708} // namespace experimental
709} // namespace gko
710
711
712#endif
713
714
715#endif // GKO_PUBLIC_CORE_DISTRIBUTED_MATRIX_HPP_
ConvertibleTo interface is used to mark that the implementer can be converted to the object of Result...
Definition polymorphic_object.hpp:479
The EnableLinOp mixin can be used to provide sensible default implementations of the majority of the ...
Definition lin_op.hpp:879
This mixin inherits from (a subclass of) PolymorphicObject and provides a base implementation of a ne...
Definition polymorphic_object.hpp:668
LinOp(const LinOp &)=default
Copy-constructs a LinOp.
An array is a container which encapsulates fixed-sized arrays, stored on the Executor tied to the arr...
Definition array.hpp:166
This type is a device-side equivalent to matrix_data.
Definition device_matrix_data.hpp:36
std::shared_ptr< const LinOp > get_non_local_matrix() const
Get read access to the stored non-local matrix.
Definition matrix.hpp:406
Matrix(Matrix &&other) noexcept
Move constructs a Matrix.
static std::unique_ptr< Matrix > create(std::shared_ptr< const Executor > exec, mpi::communicator comm, index_map< local_index_type, global_index_type > imap, std::shared_ptr< LinOp > local_linop, std::shared_ptr< LinOp > non_local_linop)
Creates distributed matrix with existent local and non-local LinOp and the corresponding mapping to c...
void read_distributed(const matrix_data< value_type, global_index_type > &data, std::shared_ptr< const Partition< local_index_type, global_index_type > > row_partition, std::shared_ptr< const Partition< local_index_type, global_index_type > > col_partition, assembly_mode assembly_type=assembly_mode::local_only)
Reads a matrix from the matrix_data structure, a global row partition, and a global column partition.
static std::unique_ptr< Matrix > create(std::shared_ptr< const Executor > exec, mpi::communicator comm, ptr_param< const LinOp > local_matrix_template, ptr_param< const LinOp > non_local_matrix_template)
Creates an empty distributed matrix with specified types for the local matrix and the non-local matri...
void col_scale(ptr_param< const global_vector_type > scaling_factors)
Scales the columns of the matrix by the respective entries of the vector.
std::shared_ptr< const LinOp > get_local_matrix() const
Get read access to the stored local matrix.
Definition matrix.hpp:399
void read_distributed(const device_matrix_data< value_type, global_index_type > &data, std::shared_ptr< const Partition< local_index_type, global_index_type > > row_partition, std::shared_ptr< const Partition< local_index_type, global_index_type > > col_partition, assembly_mode assembly_type=assembly_mode::local_only)
Reads a matrix from the device_matrix_data structure, a global row partition, and a global column par...
static std::unique_ptr< Matrix > create(std::shared_ptr< const Executor > exec, mpi::communicator comm)
Creates an empty distributed matrix.
void read_distributed(const matrix_data< value_type, global_index_type > &data, std::shared_ptr< const Partition< local_index_type, global_index_type > > partition, assembly_mode assembly_type=assembly_mode::local_only)
Reads a square matrix from the matrix_data structure and a global partition.
void row_scale(ptr_param< const global_vector_type > scaling_factors)
Scales the rows of the matrix by the respective entries of the vector.
static std::unique_ptr< Matrix > create(std::shared_ptr< const Executor > exec, mpi::communicator comm, dim< 2 > size, std::shared_ptr< LinOp > local_linop)
Creates a local-only distributed matrix with existent LinOp.
static std::unique_ptr< Matrix > create(std::shared_ptr< const Executor > exec, mpi::communicator comm, dim< 2 > size, std::shared_ptr< LinOp > local_linop, std::shared_ptr< LinOp > non_local_linop, std::vector< comm_index_type > recv_sizes, std::vector< comm_index_type > recv_offsets, array< local_index_type > recv_gather_idxs)
Creates distributed matrix with existent local and non-local LinOp and the corresponding mapping to c...
void read_distributed(const device_matrix_data< value_type, global_index_type > &data, std::shared_ptr< const Partition< local_index_type, global_index_type > > partition, assembly_mode assembly_type=assembly_mode::local_only)
Reads a square matrix from the device_matrix_data structure and a global partition.
Matrix(const Matrix &other)
Copy constructs a Matrix.
static std::unique_ptr< Matrix > create(std::shared_ptr< const Executor > exec, mpi::communicator comm, LocalMatrixType local_matrix_template, NonLocalMatrixType non_local_matrix_template)
Creates an empty distributed matrix with specified types for the local matrix and the non-local matri...
Definition matrix.hpp:523
static std::unique_ptr< Matrix > create(std::shared_ptr< const Executor > exec, mpi::communicator comm, MatrixType matrix_template)
Creates an empty distributed matrix with specified type for local matrices.
Definition matrix.hpp:480
Matrix & operator=(Matrix &&other)
Move assigns a Matrix.
Matrix & operator=(const Matrix &other)
Copy assigns a Matrix.
static std::unique_ptr< Matrix > create(std::shared_ptr< const Executor > exec, mpi::communicator comm, ptr_param< const LinOp > matrix_template)
Creates an empty distributed matrix with specified type for local matrices.
Represents a partition of a range of indices [0, size) into a disjoint set of parts.
Definition partition.hpp:83
Vector is a format which explicitly stores (multiple) distributed column vectors in a dense storage f...
Definition vector.hpp:74
This class defines mappings between global and local indices.
Definition index_map.hpp:68
A thin wrapper of MPI_Comm that supports most MPI calls.
Definition mpi.hpp:416
The request class is a light, move-only wrapper around the MPI_Request handle.
Definition mpi.hpp:327
CSR is a matrix format which stores only the nonzero coefficients by compressing each row of the matr...
Definition csr.hpp:124
Parallel graph match (Pgm) is the aggregate method introduced in the paper M.
Definition pgm.hpp:52
This class is used for function parameters in the place of raw pointers.
Definition utils_helper.hpp:41
assembly_mode
assembly_mode defines how the read_distributed function of the distributed matrix treats non-local in...
Definition matrix.hpp:145
The matrix namespace.
Definition dense_cache.hpp:15
The multigrid components namespace.
Definition matrix.hpp:34
The Ginkgo namespace.
Definition abstract_factory.hpp:20
std::int32_t int32
32-bit signed integral type.
Definition types.hpp:106
auto with_matrix_type(Args &&... create_args)
This function returns a type that delays a call to MatrixType::create.
Definition matrix.hpp:125
double default_precision
Precision used if no precision is explicitly specified.
Definition types.hpp:171
std::int64_t int64
64-bit signed integral type.
Definition types.hpp:112
next_precision_base< T > next_precision
Obtains the next type in the singly-linked precision list with half.
Definition math.hpp:445
A type representing the dimensions of a multidimensional object.
Definition dim.hpp:26
This structure is used as an intermediate data type to store a sparse matrix.
Definition matrix_data.hpp:126