Ginkgo: ginkgo/core/distributed/matrix.hpp Source File

| Ginkgo Generated from branch based on main. Ginkgo version 1.11.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#include <ginkgo/core/distributed/row_gatherer.hpp>
22#include <ginkgo/core/distributed/vector_cache.hpp>
23
24
25namespace gko {
26namespace matrix {
27
28
29template <typename ValueType, typename IndexType>
30class Csr;
31
32
33}
34
35
36 namespace multigrid {
37
38
39template <typename ValueType, typename IndexType>
40class Pgm;
41
42
43}
44
45
46namespace detail {
47
48
53template <typename Builder, typename ValueType, typename IndexType,
54 typename = void>
55struct is_matrix_type_builder : std::false_type {};
56
57
58template <typename Builder, typename ValueType, typename IndexType>
59struct is_matrix_type_builder<
60 Builder, ValueType, IndexType,
61 xstd::void_t<
62 decltype(std::declval<Builder>().template create<ValueType, IndexType>(
63 std::declval<std::shared_ptr<const Executor>>()))>>
64 : std::true_type {};
65
66
67template <template <typename, typename> class MatrixType,
68 typename... CreateArgs>
69struct MatrixTypeBuilderFromValueAndIndex {
70 template <typename ValueType, typename IndexType, std::size_t... I>
71 auto create_impl(std::shared_ptr<const Executor> exec,
72 std::index_sequence<I...>)
73 {
74 return MatrixType<ValueType, IndexType>::create(
75 exec, std::get<I>(create_args)...);
76 }
77
78
79 template <typename ValueType, typename IndexType>
80 auto create(std::shared_ptr<const Executor> exec)
81 {
82 // with c++17 we could use std::apply
83 static constexpr auto size = sizeof...(CreateArgs);
84 return create_impl<ValueType, IndexType>(
85 std::move(exec), std::make_index_sequence<size>{});
86 }
87
88 std::tuple<CreateArgs...> create_args;
89};
90
91
92} // namespace detail
93
94
126template <template <typename, typename> class MatrixType, typename... Args>
127 auto with_matrix_type(Args&&... create_args)
128{
129 return detail::MatrixTypeBuilderFromValueAndIndex<MatrixType, Args...>{
130 std::forward_as_tuple(create_args...)};
131}
132
133
134namespace experimental {
135namespace distributed {
136
137
147 enum class assembly_mode { communicate, local_only };
148
149
150template <typename LocalIndexType, typename GlobalIndexType>
151class Partition;
152template <typename ValueType>
153class Vector;
154
155
260template <typename ValueType = default_precision,
261 typename LocalIndexType = int32, typename GlobalIndexType = int64>
262 class Matrix
263 : public EnableLinOp<Matrix<ValueType, LocalIndexType, GlobalIndexType>>,
264 public ConvertibleTo<
265 Matrix<next_precision<ValueType>, LocalIndexType, GlobalIndexType>>,
266#if GINKGO_ENABLE_HALF || GINKGO_ENABLE_BFLOAT16
267 public ConvertibleTo<Matrix<next_precision<ValueType, 2>, LocalIndexType,
268 GlobalIndexType>>,
269#endif
270#if GINKGO_ENABLE_HALF && GINKGO_ENABLE_BFLOAT16
271 public ConvertibleTo<Matrix<next_precision<ValueType, 3>, LocalIndexType,
272 GlobalIndexType>>,
273#endif
274 public DistributedBase {
275 friend class EnablePolymorphicObject<Matrix, LinOp>;
276 friend class Matrix<previous_precision<ValueType>, LocalIndexType,
277 GlobalIndexType>;
278 friend class multigrid::Pgm<ValueType, LocalIndexType>;
279 GKO_ASSERT_SUPPORTED_VALUE_AND_DIST_INDEX_TYPE;
280
281public:
282 using value_type = ValueType;
283 using index_type = GlobalIndexType;
284 using local_index_type = LocalIndexType;
285 using global_index_type = GlobalIndexType;
286 using global_vector_type =
287 gko::experimental::distributed::Vector<ValueType>;
288 using local_vector_type = typename global_vector_type::local_vector_type;
289
290 using EnableLinOp<Matrix>::convert_to;
291 using EnableLinOp<Matrix>::move_to;
292 using ConvertibleTo<Matrix<next_precision<ValueType>, LocalIndexType,
293 GlobalIndexType>>::convert_to;
294 using ConvertibleTo<Matrix<next_precision<ValueType>, LocalIndexType,
295 GlobalIndexType>>::move_to;
296
297 void convert_to(Matrix<next_precision<value_type>, local_index_type,
298 global_index_type>* result) const override;
299
300 void move_to(Matrix<next_precision<value_type>, local_index_type,
301 global_index_type>* result) override;
302
303#if GINKGO_ENABLE_HALF || GINKGO_ENABLE_BFLOAT16
304 friend class Matrix<previous_precision<ValueType, 2>, LocalIndexType,
305 GlobalIndexType>;
306 using ConvertibleTo<Matrix<next_precision<value_type, 2>, local_index_type,
307 global_index_type>>::convert_to;
308 using ConvertibleTo<Matrix<next_precision<value_type, 2>, local_index_type,
309 global_index_type>>::move_to;
310
311 void convert_to(Matrix<next_precision<value_type, 2>, local_index_type,
312 global_index_type>* result) const override;
313
314 void move_to(Matrix<next_precision<value_type, 2>, local_index_type,
315 global_index_type>* result) override;
316#endif
317
318#if GINKGO_ENABLE_HALF && GINKGO_ENABLE_BFLOAT16
319 friend class Matrix<previous_precision<ValueType, 3>, LocalIndexType,
320 GlobalIndexType>;
321 using ConvertibleTo<Matrix<next_precision<value_type, 3>, local_index_type,
322 global_index_type>>::convert_to;
323 using ConvertibleTo<Matrix<next_precision<value_type, 3>, local_index_type,
324 global_index_type>>::move_to;
325
326 void convert_to(Matrix<next_precision<value_type, 3>, local_index_type,
327 global_index_type>* result) const override;
328
329 void move_to(Matrix<next_precision<value_type, 3>, local_index_type,
330 global_index_type>* result) override;
331#endif
349 void read_distributed(
350 const device_matrix_data<value_type, global_index_type>& data,
351 std::shared_ptr<const Partition<local_index_type, global_index_type>>
352 partition,
353 assembly_mode assembly_type = assembly_mode::local_only);
354
364 void read_distributed(
365 const matrix_data<value_type, global_index_type>& data,
366 std::shared_ptr<const Partition<local_index_type, global_index_type>>
367 partition,
368 assembly_mode assembly_type = assembly_mode::local_only);
369
388 void read_distributed(
389 const device_matrix_data<value_type, global_index_type>& data,
390 std::shared_ptr<const Partition<local_index_type, global_index_type>>
391 row_partition,
392 std::shared_ptr<const Partition<local_index_type, global_index_type>>
393 col_partition,
394 assembly_mode assembly_type = assembly_mode::local_only);
395
405 void read_distributed(
406 const matrix_data<value_type, global_index_type>& data,
407 std::shared_ptr<const Partition<local_index_type, global_index_type>>
408 row_partition,
409 std::shared_ptr<const Partition<local_index_type, global_index_type>>
410 col_partition,
411 assembly_mode assembly_type = assembly_mode::local_only);
412
418 std::shared_ptr<const LinOp> get_local_matrix() const { return local_mtx_; }
419
425 std::shared_ptr<const LinOp> get_non_local_matrix() const
426 {
427 return non_local_mtx_;
428 }
429
435 Matrix(const Matrix& other);
436
442 Matrix(Matrix&& other) noexcept;
443
452 Matrix& operator=(const Matrix& other);
453
462 Matrix& operator=(Matrix&& other);
463
473 static std::unique_ptr<Matrix> create(std::shared_ptr<const Executor> exec,
474 mpi::communicator comm);
475
489 static std::unique_ptr<Matrix> create(
490 std::shared_ptr<const Executor> exec,
491 std::shared_ptr<const RowGatherer<LocalIndexType>>
492 row_gatherer_template);
493
514 template <typename MatrixType,
515 typename = std::enable_if_t<gko::detail::is_matrix_type_builder<
516 MatrixType, ValueType, LocalIndexType>::value>>
517 static std::unique_ptr<Matrix> create(std::shared_ptr<const Executor> exec,
518 mpi::communicator comm,
519 MatrixType matrix_template)
520 {
521 return create(
522 exec, comm,
523 matrix_template.template create<ValueType, LocalIndexType>(exec));
524 }
525
554 template <typename LocalMatrixType, typename NonLocalMatrixType,
555 typename = std::enable_if_t<
556 gko::detail::is_matrix_type_builder<
557 LocalMatrixType, ValueType, LocalIndexType>::value &&
558 gko::detail::is_matrix_type_builder<
559 NonLocalMatrixType, ValueType, LocalIndexType>::value>>
560 static std::unique_ptr<Matrix> create(
561 std::shared_ptr<const Executor> exec, mpi::communicator comm,
562 LocalMatrixType local_matrix_template,
563 NonLocalMatrixType non_local_matrix_template)
564 {
565 return create(
566 exec, comm,
567 local_matrix_template.template create<ValueType, LocalIndexType>(
568 exec),
569 non_local_matrix_template
570 .template create<ValueType, LocalIndexType>(exec));
571 }
572
587 static std::unique_ptr<Matrix> create(
588 std::shared_ptr<const Executor> exec, mpi::communicator comm,
589 ptr_param<const LinOp> matrix_template);
590
607 static std::unique_ptr<Matrix> create(
608 std::shared_ptr<const Executor> exec, mpi::communicator comm,
609 ptr_param<const LinOp> local_matrix_template,
610 ptr_param<const LinOp> non_local_matrix_template);
611
624 static std::unique_ptr<Matrix> create(std::shared_ptr<const Executor> exec,
625 mpi::communicator comm, dim<2> size,
626 std::shared_ptr<LinOp> local_linop);
627
646 [[deprecated(
647 "Please use the overload with an index_map instead.")]] static std::
648 unique_ptr<Matrix>
649 create(std::shared_ptr<const Executor> exec, mpi::communicator comm,
650 dim<2> size, std::shared_ptr<LinOp> local_linop,
651 std::shared_ptr<LinOp> non_local_linop,
652 std::vector<comm_index_type> recv_sizes,
653 std::vector<comm_index_type> recv_offsets,
654 array<local_index_type> recv_gather_idxs);
655
669 static std::unique_ptr<Matrix> create(
670 std::shared_ptr<const Executor> exec, mpi::communicator comm,
671 index_map<local_index_type, global_index_type> imap,
672 std::shared_ptr<LinOp> local_linop,
673 std::shared_ptr<LinOp> non_local_linop);
674
682 void col_scale(ptr_param<const global_vector_type> scaling_factors);
683
691 void row_scale(ptr_param<const global_vector_type> scaling_factors);
692
693protected:
694 explicit Matrix(std::shared_ptr<const Executor> exec,
695 mpi::communicator comm);
696
697 explicit Matrix(std::shared_ptr<const Executor> exec,
698 std::shared_ptr<const RowGatherer<LocalIndexType>>
699 row_gatherer_template,
700 ptr_param<const LinOp> local_matrix_template,
701 ptr_param<const LinOp> non_local_matrix_template);
702
703 explicit Matrix(std::shared_ptr<const Executor> exec,
704 mpi::communicator comm, dim<2> size,
705 std::shared_ptr<LinOp> local_linop);
706
707 explicit Matrix(std::shared_ptr<const Executor> exec,
708 mpi::communicator comm,
709 index_map<local_index_type, global_index_type> imap,
710 std::shared_ptr<LinOp> local_linop,
711 std::shared_ptr<LinOp> non_local_linop);
712
713 void apply_impl(const LinOp* b, LinOp* x) const override;
714
715 void apply_impl(const LinOp* alpha, const LinOp* b, const LinOp* beta,
716 LinOp* x) const override;
717
718private:
719 std::shared_ptr<RowGatherer<LocalIndexType>> row_gatherer_;
720 index_map<local_index_type, global_index_type> imap_;
721 gko::detail::ScalarCache one_scalar_;
722 detail::GenericVectorCache recv_buffer_;
723 detail::GenericVectorCache host_recv_buffer_;
724 std::shared_ptr<LinOp> local_mtx_;
725 std::shared_ptr<LinOp> non_local_mtx_;
726};
727
728
729} // namespace distributed
730} // namespace experimental
731} // namespace gko
732
733
734#endif
735
736
737#endif // GKO_PUBLIC_CORE_DISTRIBUTED_MATRIX_HPP_
gko::EnableLinOp
The EnableLinOp mixin can be used to provide sensible default implementations of the majority of the ...
Definition lin_op.hpp:879
gko::EnablePolymorphicObject
This mixin inherits from (a subclass of) PolymorphicObject and provides a base implementation of a ne...
Definition polymorphic_object.hpp:668
gko::LinOp
Definition lin_op.hpp:117
gko::array
An array is a container which encapsulates fixed-sized arrays, stored on the Executor tied to the arr...
Definition array.hpp:166
gko::device_matrix_data
This type is a device-side equivalent to matrix_data.
Definition device_matrix_data.hpp:36
gko::experimental::distributed::Matrix::get_non_local_matrix
std::shared_ptr< const LinOp > get_non_local_matrix() const
Get read access to the stored non-local matrix.
Definition matrix.hpp:425
gko::experimental::distributed::Matrix::Matrix
Matrix(Matrix &&other) noexcept
Move constructs a Matrix.
gko::experimental::distributed::Matrix::create
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...
gko::experimental::distributed::Matrix::read_distributed
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.
gko::experimental::distributed::Matrix::create
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...
gko::experimental::distributed::Matrix::col_scale
void col_scale(ptr_param< const global_vector_type > scaling_factors)
Scales the columns of the matrix by the respective entries of the vector.
gko::experimental::distributed::Matrix::get_local_matrix
std::shared_ptr< const LinOp > get_local_matrix() const
Get read access to the stored local matrix.
Definition matrix.hpp:418
gko::experimental::distributed::Matrix::read_distributed
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...
gko::experimental::distributed::Matrix::create
static std::unique_ptr< Matrix > create(std::shared_ptr< const Executor > exec, mpi::communicator comm)
Creates an empty distributed matrix.
gko::experimental::distributed::Matrix::read_distributed
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.
gko::experimental::distributed::Matrix::row_scale
void row_scale(ptr_param< const global_vector_type > scaling_factors)
Scales the rows of the matrix by the respective entries of the vector.
gko::experimental::distributed::Matrix::create
static std::unique_ptr< Matrix > create(std::shared_ptr< const Executor > exec, std::shared_ptr< const RowGatherer< LocalIndexType > > row_gatherer_template)
Creates an empty distributed matrix with a specified implementation of the row gather operation.
gko::experimental::distributed::Matrix::create
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.
gko::experimental::distributed::Matrix::create
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...
gko::experimental::distributed::Matrix::read_distributed
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.
gko::experimental::distributed::Matrix::Matrix
Matrix(const Matrix &other)
Copy constructs a Matrix.
gko::experimental::distributed::Matrix::create
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:560
gko::experimental::distributed::Matrix::create
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:517
gko::experimental::distributed::Matrix::operator=
Matrix & operator=(Matrix &&other)
Move assigns a Matrix.
gko::experimental::distributed::Matrix::operator=
Matrix & operator=(const Matrix &other)
Copy assigns a Matrix.
gko::experimental::distributed::Matrix::create
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.
gko::experimental::distributed::Partition
Represents a partition of a range of indices [0, size) into a disjoint set of parts.
Definition partition.hpp:83
gko::experimental::distributed::RowGatherer
The distributed::RowGatherer gathers the rows of distributed::Vector that are located on other proces...
Definition row_gatherer.hpp:94
gko::experimental::distributed::Vector
Vector is a format which explicitly stores (multiple) distributed column vectors in a dense storage f...
Definition vector.hpp:77
gko::experimental::distributed::index_map
This class defines mappings between global and local indices.
Definition index_map.hpp:68
gko::experimental::mpi::communicator
A thin wrapper of MPI_Comm that supports most MPI calls.
Definition mpi.hpp:419
gko::matrix::Csr
CSR is a matrix format which stores only the nonzero coefficients by compressing each row of the matr...
Definition csr.hpp:126
gko::multigrid::Pgm
Parallel graph match (Pgm) is the aggregate method introduced in the paper M.
Definition pgm.hpp:52
gko::ptr_param
This class is used for function parameters in the place of raw pointers.
Definition utils_helper.hpp:41
gko::experimental::distributed::assembly_mode
assembly_mode
assembly_mode defines how the read_distributed function of the distributed matrix treats non-local in...
Definition matrix.hpp:147
gko::matrix
The matrix namespace.
Definition dense_cache.hpp:24
gko::multigrid
The multigrid components namespace.
Definition matrix.hpp:36
gko
The Ginkgo namespace.
Definition abstract_factory.hpp:20
gko::int32
std::int32_t int32
32-bit signed integral type.
Definition types.hpp:107
gko::with_matrix_type
auto with_matrix_type(Args &&... create_args)
This function returns a type that delays a call to MatrixType::create.
Definition matrix.hpp:127
gko::default_precision
double default_precision
Precision used if no precision is explicitly specified.
Definition types.hpp:172
gko::int64
std::int64_t int64
64-bit signed integral type.
Definition types.hpp:113
gko::previous_precision
typename detail::find_precision_impl< T, -step >::type previous_precision
Obtains the previous move type of T in the singly-linked precision corresponding bfloat16/half.
Definition math.hpp:473
gko::next_precision
typename detail::find_precision_impl< T, step >::type next_precision
Obtains the next move type of T in the singly-linked precision corresponding bfloat16/half.
Definition math.hpp:466
gko::dim
A type representing the dimensions of a multidimensional object.
Definition dim.hpp:26
gko::matrix_data
This structure is used as an intermediate data type to store a sparse matrix.
Definition matrix_data.hpp:126