#include <ginkgo/core/distributed/matrix.hpp>

Inheritance diagram for gko::experimental::distributed::Matrix< ValueType, LocalIndexType, GlobalIndexType >:

Public Types
using	value_type = ValueType

using	index_type = GlobalIndexType

using	local_index_type = LocalIndexType

using	global_index_type = GlobalIndexType

using	global_vector_type = gko::experimental::distributed::Vector< ValueType >

using	local_vector_type = typename global_vector_type::local_vector_type

Public Types inherited from gko::EnablePolymorphicAssignment< ConcreteLinOp >
using	result_type = ConcreteLinOp

Public Types inherited from gko::ConvertibleTo< ResultType >
using	result_type = ResultType

Public Member Functions
void	convert_to (Matrix< next_precision< value_type >, local_index_type, global_index_type > *result) const override

void	move_to (Matrix< next_precision< value_type >, local_index_type, global_index_type > *result) override

void	convert_to (Matrix< next_precision< next_precision< value_type > >, local_index_type, global_index_type > *result) const override

void	move_to (Matrix< next_precision< next_precision< value_type > >, local_index_type, global_index_type > *result) override

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)

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)

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)

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)

std::shared_ptr< const LinOp >	get_local_matrix () const

std::shared_ptr< const LinOp >	get_non_local_matrix () const

	Matrix (const Matrix &other)

	Matrix (Matrix &&other) noexcept

Matrix &	operator= (const Matrix &other)

Matrix &	operator= (Matrix &&other)

void	col_scale (ptr_param< const global_vector_type > scaling_factors)

void	row_scale (ptr_param< const global_vector_type > scaling_factors)

Public Member Functions inherited from gko::EnableLinOp< ConcreteLinOp, PolymorphicBase >
const ConcreteLinOp *	apply (ptr_param< const LinOp > b, ptr_param< LinOp > x) const

ConcreteLinOp *	apply (ptr_param< const LinOp > b, ptr_param< LinOp > x)

const ConcreteLinOp *	apply (ptr_param< const LinOp > alpha, ptr_param< const LinOp > b, ptr_param< const LinOp > beta, ptr_param< LinOp > x) const

ConcreteLinOp *	apply (ptr_param< const LinOp > alpha, ptr_param< const LinOp > b, ptr_param< const LinOp > beta, ptr_param< LinOp > x)

Public Member Functions inherited from gko::EnableAbstractPolymorphicObject< AbstractObject, PolymorphicBase >
std::unique_ptr< AbstractObject >	create_default (std::shared_ptr< const Executor > exec) const

std::unique_ptr< AbstractObject >	create_default () const

std::unique_ptr< AbstractObject >	clone (std::shared_ptr< const Executor > exec) const

std::unique_ptr< AbstractObject >	clone () const

AbstractObject *	copy_from (const PolymorphicObject *other)

template<typename Derived >
std::enable_if_t< std::is_base_of< PolymorphicObject, std::decay_t< Derived > >::value, AbstractObject > *	copy_from (std::unique_ptr< Derived > &&other)

template<typename Derived >
std::enable_if_t< std::is_base_of< PolymorphicObject, std::decay_t< Derived > >::value, AbstractObject > *	copy_from (const std::unique_ptr< Derived > &other)

AbstractObject *	copy_from (const std::shared_ptr< const PolymorphicObject > &other)

AbstractObject *	move_from (ptr_param< PolymorphicObject > other)

AbstractObject *	clear ()

Public Member Functions inherited from gko::PolymorphicObject
PolymorphicObject &	operator= (const PolymorphicObject &)

std::unique_ptr< PolymorphicObject >	create_default (std::shared_ptr< const Executor > exec) const

std::unique_ptr< PolymorphicObject >	create_default () const

std::unique_ptr< PolymorphicObject >	clone (std::shared_ptr< const Executor > exec) const

std::unique_ptr< PolymorphicObject >	clone () const

PolymorphicObject *	copy_from (const PolymorphicObject *other)

template<typename Derived , typename Deleter >
std::enable_if_t< std::is_base_of< PolymorphicObject, std::decay_t< Derived > >::value, PolymorphicObject > *	copy_from (std::unique_ptr< Derived, Deleter > &&other)

template<typename Derived , typename Deleter >
std::enable_if_t< std::is_base_of< PolymorphicObject, std::decay_t< Derived > >::value, PolymorphicObject > *	copy_from (const std::unique_ptr< Derived, Deleter > &other)

PolymorphicObject *	copy_from (const std::shared_ptr< const PolymorphicObject > &other)

PolymorphicObject *	move_from (ptr_param< PolymorphicObject > other)

PolymorphicObject *	clear ()

std::shared_ptr< const Executor >	get_executor () const noexcept

Public Member Functions inherited from gko::log::EnableLogging< PolymorphicObject >
void	add_logger (std::shared_ptr< const Logger > logger) override

void	remove_logger (const Logger *logger) override

void	remove_logger (ptr_param< const Logger > logger)

const std::vector< std::shared_ptr< const Logger > > &	get_loggers () const override

void	clear_loggers () override

Public Member Functions inherited from gko::log::Loggable
void	remove_logger (ptr_param< const Logger > logger)

Public Member Functions inherited from gko::EnablePolymorphicAssignment< ConcreteLinOp >
void	convert_to (result_type *result) const override

void	move_to (result_type *result) override

Public Member Functions inherited from gko::ConvertibleTo< ResultType >
virtual void	convert_to (result_type *result) const =0

void	convert_to (ptr_param< result_type > result) const

virtual void	move_to (result_type *result)=0

void	move_to (ptr_param< result_type > result)

Public Member Functions inherited from gko::experimental::distributed::DistributedBase
	DistributedBase (const DistributedBase &other)=default

	DistributedBase (DistributedBase &&other)=default

DistributedBase &	operator= (const DistributedBase &)

DistributedBase &	operator= (DistributedBase &&) noexcept

mpi::communicator	get_communicator () const

Static Public Member Functions
static std::unique_ptr< Matrix >	create (std::shared_ptr< const Executor > exec, mpi::communicator comm)

template<typename MatrixType , typename = std::enable_if_t<gko::detail::is_matrix_type_builder< MatrixType, ValueType, LocalIndexType>::value>>
static std::unique_ptr< Matrix >	create (std::shared_ptr< const Executor > exec, mpi::communicator comm, MatrixType matrix_template)

template<typename LocalMatrixType , typename NonLocalMatrixType , typename = std::enable_if_t< gko::detail::is_matrix_type_builder< LocalMatrixType, ValueType, LocalIndexType>::value && gko::detail::is_matrix_type_builder< NonLocalMatrixType, ValueType, LocalIndexType>::value>>
static std::unique_ptr< Matrix >	create (std::shared_ptr< const Executor > exec, mpi::communicator comm, LocalMatrixType local_matrix_template, NonLocalMatrixType non_local_matrix_template)

static std::unique_ptr< Matrix >	create (std::shared_ptr< const Executor > exec, mpi::communicator comm, ptr_param< const LinOp > matrix_template)

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)

static std::unique_ptr< Matrix >	create (std::shared_ptr< const Executor > exec, mpi::communicator comm, dim< 2 > size, std::shared_ptr< LinOp > local_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)

Protected Member Functions
	Matrix (std::shared_ptr< const Executor > exec, mpi::communicator comm)

	Matrix (std::shared_ptr< const Executor > exec, mpi::communicator comm, ptr_param< const LinOp > local_matrix_template, ptr_param< const LinOp > non_local_matrix_template)

	Matrix (std::shared_ptr< const Executor > exec, mpi::communicator comm, dim< 2 > size, std::shared_ptr< LinOp > local_linop)

	Matrix (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)

mpi::request	communicate (const local_vector_type *local_b) const

void	apply_impl (const LinOp b, LinOp x) const override

void	apply_impl (const LinOp alpha, const LinOp b, const LinOp beta, LinOp x) const override

Protected Member Functions inherited from gko::EnableLinOp< ConcreteLinOp, PolymorphicBase >
ConcreteLinOp *	self () noexcept

const ConcreteLinOp *	self () const noexcept

Protected Member Functions inherited from gko::EnablePolymorphicObject< ConcreteObject, PolymorphicBase >
std::unique_ptr< PolymorphicObject >	create_default_impl (std::shared_ptr< const Executor > exec) const override

PolymorphicObject *	copy_from_impl (const PolymorphicObject *other) override

PolymorphicObject *	copy_from_impl (std::unique_ptr< PolymorphicObject > other) override

PolymorphicObject *	move_from_impl (PolymorphicObject *other) override

PolymorphicObject *	move_from_impl (std::unique_ptr< PolymorphicObject > other) override

PolymorphicObject *	clear_impl () override

Protected Member Functions inherited from gko::PolymorphicObject
	PolymorphicObject (std::shared_ptr< const Executor > exec)

	PolymorphicObject (const PolymorphicObject &other)

Protected Member Functions inherited from gko::log::EnableLogging< PolymorphicObject >
void	log (Params &&... params) const

Protected Member Functions inherited from gko::experimental::distributed::DistributedBase
	DistributedBase (mpi::communicator comm)

Friends
class	EnablePolymorphicObject< Matrix, LinOp >

class	Matrix< previous_precision< ValueType >, LocalIndexType, GlobalIndexType >

class	multigrid::Pgm< ValueType, LocalIndexType >

class	Matrix< previous_precision< previous_precision< ValueType > >, LocalIndexType, GlobalIndexType >

Additional Inherited Members
Protected Attributes inherited from gko::log::EnableLogging< PolymorphicObject >
std::vector< std::shared_ptr< const Logger > >	loggers_

Detailed Description

template<typename ValueType = default_precision, typename LocalIndexType = int32, typename GlobalIndexType = int64>
class gko::experimental::distributed::Matrix< ValueType, LocalIndexType, GlobalIndexType >

The Matrix class defines a (MPI-)distributed matrix.

The matrix is stored in a row-wise distributed format. Each process owns a specific set of rows, where the assignment of rows is defined by a row Partition. The following depicts the distribution of global rows according to their assigned part-id (which will usually be the owning process id):

Part-Id  Global Rows                   Part-Id  Local Rows
      | .. 1  2  .. .. .. |         0        | .. 1  2  .. .. .. |
      | 3  4  .. .. .. .. |                  | 13 .. .. .. 14 .. |
      | .. 5  6  ..  7 .. |  ---->  1        | 3  4  .. .. .. .. |
      | .. .. .. 8  ..  9 |  ---->           | .. .. .. 10 11 12 |
      | .. .. .. 10 11 12 |         2        | .. 5  6  ..  7 .. |
      | 13 .. .. .. 14 .. |                  | .. .. .. 8  ..  9 |

The local rows are further split into two matrices on each process. One matrix, called local, contains only entries from columns that are also owned by the process, while the other one, called non_local, contains entries from columns that are not owned by the process. The non-local matrix is stored in a compressed format, where empty columns are discarded and the remaining columns are renumbered. This splitting is depicted in the following:

Part-Id  Global                            Local      Non-Local
0        | .. 1  ! 2  .. ! .. .. |         | .. 1  |  | 2  |
0        | 3  4  ! .. .. ! .. .. |         | 3  4  |  | .. |
         |-----------------------|
1        | .. 5  ! 6  .. ! 7  .. |  ---->  | 6  .. |  | 5  7  .. |
1        | .. .. ! .. 8  ! ..  9 |  ---->  | 8  .. |  | .. .. 9  |
         |-----------------------|
2        | .. .. ! .. 10 ! 11 12 |         | 11 12 |  | .. 10 |
2        | 13 .. ! .. .. ! 14 .. |         | 14 .. |  | 13 .. |

This uses the same ownership of the columns as for the rows. Additionally, the ownership of the columns may be explicitly defined with an second column partition. If that is not provided, the same row partition will be used for the columns. Using a column partition also allows to create non-square matrices, like the one below:

Part-Id  Global                  Local      Non-Local
P_R/P_C    2  2  0  1
0        | .. 1  2  .. |         | 2  |     | 1  .. |
0        | 3  4  .. .. |         | .. |     | 3  4  |
         |-------------|
1        | .. 5  6  .. |  ---->  | .. |     | 6  5  |
1        | .. .. .. 8  |  ---->  | 8  |     | .. .. |
         |-------------|
2        | .. .. .. 10 |         | .. .. |  | 10 |
2        | 13 .. .. .. |         | 13 .. |  | .. |

Here P_R denotes the row partition and P_C denotes the column partition.

The Matrix should be filled using the read_distributed method, e.g.

auto part = Partition<...>::build_from_mapping(...);
auto mat = Matrix<...>::create(exec, comm);
mat->read_distributed(matrix_data, part);

or if different partitions for the rows and columns are used:

auto row_part = Partition<...>::build_from_mapping(...);
auto col_part = Partition<...>::build_from_mapping(...);
auto mat = Matrix<...>::create(exec, comm);
mat->read_distributed(matrix_data, row_part, col_part);

This will set the dimensions of the global and local matrices automatically by deducing the sizes from the partitions.

By default the Matrix type uses Csr for both stored matrices. It is possible to explicitly change the datatype for the stored matrices, with the constraint that the new type should implement the LinOp and ReadableFromMatrixData interface. The type can be set by:

auto mat = Matrix<ValueType, LocalIndexType[, ...]>::create(
  exec, comm,
  Ell<ValueType, LocalIndexType>::create(exec).get(),
  Coo<ValueType, LocalIndexType>::create(exec).get());

Alternatively, the helper function with_matrix_type can be used:

auto mat = Matrix<ValueType, LocalIndexType>::create(
  exec, comm,
  with_matrix_type<Ell>(),
  with_matrix_type<Coo>());

See also: with_matrix_type

The Matrix LinOp supports the following operations:

experimental::distributed::Matrix *A;       // distributed matrix
experimental::distributed::Vector *b, *x;   // distributed multi-vectors
matrix::Dense *alpha, *beta;  // scalars of dimension 1x1
 
// Applying to distributed multi-vectors computes an SpMV/SpMM product
A->apply(b, x)              // x = A*b
A->apply(alpha, b, beta, x) // x = alpha*A*b + beta*x

Template Parameters

ValueType	The underlying value type.
LocalIndexType	The index type used by the local matrices.
GlobalIndexType	The type for global indices.

Constructor & Destructor Documentation

◆ Matrix() [1/2]

template<typename ValueType = default_precision, typename LocalIndexType = int32, typename GlobalIndexType = int64>

gko::experimental::distributed::Matrix< ValueType, LocalIndexType, GlobalIndexType >::Matrix ( const Matrix< ValueType, LocalIndexType, GlobalIndexType > & other )

Copy constructs a Matrix.

Parameters

other Matrix to copy from.

◆ Matrix() [2/2]

template<typename ValueType = default_precision, typename LocalIndexType = int32, typename GlobalIndexType = int64>

gko::experimental::distributed::Matrix< ValueType, LocalIndexType, GlobalIndexType >::Matrix ( Matrix< ValueType, LocalIndexType, GlobalIndexType > && other )

noexcept

Move constructs a Matrix.

Parameters

other Matrix to move from.

Member Function Documentation

◆ col_scale()

template<typename ValueType = default_precision, typename LocalIndexType = int32, typename GlobalIndexType = int64>

void gko::experimental::distributed::Matrix< ValueType, LocalIndexType, GlobalIndexType >::col_scale ( ptr_param< const global_vector_type > scaling_factors )

Scales the columns of the matrix by the respective entries of the vector. The vector's row partition has to be the same as the matrix's column partition. The scaling is done in-place.

Parameters

scaling_factors The vector containing the scaling factors.

◆ communicate()

template<typename ValueType = default_precision, typename LocalIndexType = int32, typename GlobalIndexType = int64>

mpi::request gko::experimental::distributed::Matrix< ValueType, LocalIndexType, GlobalIndexType >::communicate ( const local_vector_type * local_b ) const

protected

Starts a non-blocking communication of the values of b that are shared with other processors.

Parameters

local_b The full local vector to be communicated. The subset of shared values is automatically extracted.

Returns: MPI request for the non-blocking communication.

◆ create() [1/7]

template<typename ValueType = default_precision, typename LocalIndexType = int32, typename GlobalIndexType = int64>

static std::unique_ptr< Matrix > gko::experimental::distributed::Matrix< ValueType, LocalIndexType, GlobalIndexType >::create	(	std::shared_ptr< const Executor >	exec,
		mpi::communicator	comm
	)

static

Creates an empty distributed matrix.

Parameters

exec	Executor associated with this matrix.
comm	Communicator associated with this matrix. The default is the MPI_COMM_WORLD.

Returns: A smart pointer to the newly created matrix.

Referenced by gko::experimental::distributed::Matrix< ValueType, LocalIndexType, GlobalIndexType >::create(), and gko::experimental::distributed::Matrix< ValueType, LocalIndexType, GlobalIndexType >::create().

◆ create() [2/7]

template<typename ValueType = default_precision, typename LocalIndexType = int32, typename GlobalIndexType = int64>

static std::unique_ptr< Matrix > gko::experimental::distributed::Matrix< ValueType, LocalIndexType, GlobalIndexType >::create	(	std::shared_ptr< const Executor >	exec,
		mpi::communicator	comm,
		dim< 2 >	size,
		std::shared_ptr< LinOp >	local_linop
	)

static

Creates a local-only distributed matrix with existent LinOp

Note: It use the input to build up the distributed matrix

Parameters

exec	Executor associated with this matrix.
comm	Communicator associated with this matrix.
size	the global size
local_linop	the local linop

Returns: A smart pointer to the newly created matrix.

◆ create() [3/7]

template<typename ValueType = default_precision, typename LocalIndexType = int32, typename GlobalIndexType = int64>

static std::unique_ptr< Matrix > gko::experimental::distributed::Matrix< ValueType, LocalIndexType, GlobalIndexType >::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
	)

static

Creates distributed matrix with existent local and non-local LinOp and the corresponding mapping to collect the non-local data from the other ranks.

Note: It use the input to build up the distributed matrix

Parameters

exec	Executor associated with this matrix.
comm	Communicator associated with this matrix.
size	the global size
local_linop	the local linop
non_local_linop	the non-local linop
recv_sizes	the size of non-local receiver
recv_offset	the offset of non-local receiver
recv_gather_idxs	the gathering index of non-local receiver

Returns: A smart pointer to the newly created matrix.

◆ create() [4/7]

template<typename ValueType = default_precision, typename LocalIndexType = int32, typename GlobalIndexType = int64>

template<typename LocalMatrixType , typename NonLocalMatrixType , typename = std::enable_if_t< gko::detail::is_matrix_type_builder< LocalMatrixType, ValueType, LocalIndexType>::value && gko::detail::is_matrix_type_builder< NonLocalMatrixType, ValueType, LocalIndexType>::value>>

static std::unique_ptr< Matrix > gko::experimental::distributed::Matrix< ValueType, LocalIndexType, GlobalIndexType >::create	(	std::shared_ptr< const Executor >	exec,
		mpi::communicator	comm,
		LocalMatrixType	local_matrix_template,
		NonLocalMatrixType	non_local_matrix_template
	)

inlinestatic

Creates an empty distributed matrix with specified types for the local matrix and the non-local matrix.

Note: This is mainly a convenience wrapper for Matrix(std::shared_ptr<const Executor>, mpi::communicator, const LinOp*, const LinOp*)

Template Parameters

LocalMatrixType A type that has a create<ValueType, IndexType>(exec) function to create a smart pointer of a type derived from LinOp and ReadableFromMatrixData.

See also: with_matrix_type

Template Parameters

NonLocalMatrixType A (possible different) type with the same constraints as LocalMatrixType.

Parameters

exec	Executor associated with this matrix.
comm	Communicator associated with this matrix.
local_matrix_template	the local matrix will be constructed with the same type as `create` returns. It should be the return value of make_matrix_template.
non_local_matrix_template	the non-local matrix will be constructed with the same type as `create` returns. It should be the return value of make_matrix_template.

Returns: A smart pointer to the newly created matrix.

References gko::experimental::distributed::Matrix< ValueType, LocalIndexType, GlobalIndexType >::create().

◆ create() [5/7]

template<typename ValueType = default_precision, typename LocalIndexType = int32, typename GlobalIndexType = int64>

template<typename MatrixType , typename = std::enable_if_t<gko::detail::is_matrix_type_builder< MatrixType, ValueType, LocalIndexType>::value>>

static std::unique_ptr< Matrix > gko::experimental::distributed::Matrix< ValueType, LocalIndexType, GlobalIndexType >::create	(	std::shared_ptr< const Executor >	exec,
		mpi::communicator	comm,
		MatrixType	matrix_template
	)

inlinestatic

Creates an empty distributed matrix with specified type for local matrices.

Note: This is mainly a convenience wrapper for Matrix(std::shared_ptr<const Executor>, mpi::communicator, const LinOp*)

Template Parameters

MatrixType A type that has a create<ValueType, IndexType>(exec) function to create a smart pointer of a type derived from LinOp and ReadableFromMatrixData.

See also: with_matrix_type

Parameters

exec	Executor associated with this matrix.
comm	Communicator associated with this matrix.
matrix_template	the local matrices will be constructed with the same type as `create` returns. It should be the return value of make_matrix_template.

Returns: A smart pointer to the newly created matrix.

References gko::experimental::distributed::Matrix< ValueType, LocalIndexType, GlobalIndexType >::create().

◆ create() [6/7]

template<typename ValueType = default_precision, typename LocalIndexType = int32, typename GlobalIndexType = int64>

static std::unique_ptr< Matrix > gko::experimental::distributed::Matrix< ValueType, LocalIndexType, GlobalIndexType >::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
	)

static

Creates an empty distributed matrix with specified types for the local matrix and the non-local matrix.

Note: It internally clones the passed in local_matrix_template and non_local_matrix_template. Therefore, those LinOps should be empty.

Parameters

exec	Executor associated with this matrix.
comm	Communicator associated with this matrix.
local_matrix_template	the local matrix will be constructed with the same runtime type.
non_local_matrix_template	the non-local matrix will be constructed with the same runtime type.

Returns: A smart pointer to the newly created matrix.

◆ create() [7/7]

template<typename ValueType = default_precision, typename LocalIndexType = int32, typename GlobalIndexType = int64>

static std::unique_ptr< Matrix > gko::experimental::distributed::Matrix< ValueType, LocalIndexType, GlobalIndexType >::create	(	std::shared_ptr< const Executor >	exec,
		mpi::communicator	comm,
		ptr_param< const LinOp >	matrix_template
	)

static

Creates an empty distributed matrix with specified type for local matrices.

Note: It internally clones the passed in matrix_template. Therefore, the LinOp should be empty.

Parameters

exec	Executor associated with this matrix.
comm	Communicator associated with this matrix.
matrix_template	the local matrices will be constructed with the same runtime type.

Returns: A smart pointer to the newly created matrix.

◆ get_local_matrix()

template<typename ValueType = default_precision, typename LocalIndexType = int32, typename GlobalIndexType = int64>

std::shared_ptr< const LinOp > gko::experimental::distributed::Matrix< ValueType, LocalIndexType, GlobalIndexType >::get_local_matrix ( ) const

inline

Get read access to the stored local matrix.

Returns: Shared pointer to the stored local matrix

◆ get_non_local_matrix()

template<typename ValueType = default_precision, typename LocalIndexType = int32, typename GlobalIndexType = int64>

std::shared_ptr< const LinOp > gko::experimental::distributed::Matrix< ValueType, LocalIndexType, GlobalIndexType >::get_non_local_matrix ( ) const

inline

Get read access to the stored non-local matrix.

Returns: Shared pointer to the stored non-local matrix

◆ operator=() [1/2]

template<typename ValueType = default_precision, typename LocalIndexType = int32, typename GlobalIndexType = int64>

Matrix & gko::experimental::distributed::Matrix< ValueType, LocalIndexType, GlobalIndexType >::operator= ( const Matrix< ValueType, LocalIndexType, GlobalIndexType > & other )

Copy assigns a Matrix.

Parameters

other Matrix to copy from, has to have a communicator of the same size as this.

Returns: this.

◆ operator=() [2/2]

template<typename ValueType = default_precision, typename LocalIndexType = int32, typename GlobalIndexType = int64>

Matrix & gko::experimental::distributed::Matrix< ValueType, LocalIndexType, GlobalIndexType >::operator= ( Matrix< ValueType, LocalIndexType, GlobalIndexType > && other )

Move assigns a Matrix.

Parameters

other Matrix to move from, has to have a communicator of the same size as this.

Returns: this.

◆ read_distributed() [1/4]

template<typename ValueType = default_precision, typename LocalIndexType = int32, typename GlobalIndexType = int64>

void gko::experimental::distributed::Matrix< ValueType, LocalIndexType, GlobalIndexType >::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.

The global size of the final matrix is inferred from the size of the partition. Both the number of rows and columns of the device_matrix_data are ignored.

Note: The matrix data can contain entries for rows other than those owned by the process. Entries for those rows are discarded.

Parameters

data	The device_matrix_data structure.
partition	The global row and column partition.
assembly_type	The mode of assembly.

Returns: the index_map induced by the partitions and the matrix structure

◆ read_distributed() [2/4]

template<typename ValueType = default_precision, typename LocalIndexType = int32, typename GlobalIndexType = int64>

void gko::experimental::distributed::Matrix< ValueType, LocalIndexType, GlobalIndexType >::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 partition.

The global size of the final matrix is inferred from the size of the row partition and the size of the column partition. Both the number of rows and columns of the device_matrix_data are ignored.

Note: The matrix data can contain entries for rows other than those owned by the process. Entries for those rows are discarded.

Parameters

data	The device_matrix_data structure.
row_partition	The global row partition.
col_partition	The global col partition.
assembly_type	The mode of assembly.

Returns: the index_map induced by the partitions and the matrix structure

◆ read_distributed() [3/4]

template<typename ValueType = default_precision, typename LocalIndexType = int32, typename GlobalIndexType = int64>

void gko::experimental::distributed::Matrix< ValueType, LocalIndexType, GlobalIndexType >::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.

See also: read_distributed

Note: For efficiency it is advised to use the device_matrix_data overload.

◆ read_distributed() [4/4]

template<typename ValueType = default_precision, typename LocalIndexType = int32, typename GlobalIndexType = int64>

void gko::experimental::distributed::Matrix< ValueType, LocalIndexType, GlobalIndexType >::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.

See also: read_distributed

Note: For efficiency it is advised to use the device_matrix_data overload.

◆ row_scale()

template<typename ValueType = default_precision, typename LocalIndexType = int32, typename GlobalIndexType = int64>

void gko::experimental::distributed::Matrix< ValueType, LocalIndexType, GlobalIndexType >::row_scale ( ptr_param< const global_vector_type > scaling_factors )

Scales the rows of the matrix by the respective entries of the vector. The vector and the matrix have to have the same row partition. The scaling is done in-place.

Parameters

scaling_factors The vector containing the scaling factors.

The documentation for this class was generated from the following file:

ginkgo/core/distributed/matrix.hpp

Matrix< ValueType, LocalIndexType, GlobalIndexType > Class Template Reference

Matrix< ValueType, LocalIndexType, GlobalIndexType > Class Template Reference#

Public Types

Public Member Functions

Static Public Member Functions

Protected Member Functions

Friends

Additional Inherited Members

Detailed Description

Constructor & Destructor Documentation

◆ Matrix() [1/2]

◆ Matrix() [2/2]

Member Function Documentation

◆ col_scale()

◆ communicate()

◆ create() [1/7]

◆ create() [2/7]

◆ create() [3/7]

◆ create() [4/7]

◆ create() [5/7]

◆ create() [6/7]

◆ create() [7/7]

◆ get_local_matrix()

◆ get_non_local_matrix()

◆ operator=() [1/2]

◆ operator=() [2/2]

◆ read_distributed() [1/4]

◆ read_distributed() [2/4]

◆ read_distributed() [3/4]

◆ read_distributed() [4/4]

◆ row_scale()

Matrix< ValueType, LocalIndexType, GlobalIndexType > Class Template Reference

Matrix&lt; ValueType, LocalIndexType, GlobalIndexType &gt; Class Template Reference#

Public Types

Public Member Functions

Static Public Member Functions

Protected Member Functions

Friends

Additional Inherited Members

Detailed Description

Constructor & Destructor Documentation

◆ Matrix() [1/2]

◆ Matrix() [2/2]

Member Function Documentation

◆ col_scale()

◆ communicate()

◆ create() [1/7]

◆ create() [2/7]

◆ create() [3/7]

◆ create() [4/7]

◆ create() [5/7]

◆ create() [6/7]

◆ create() [7/7]

◆ get_local_matrix()

◆ get_non_local_matrix()

◆ operator=() [1/2]

◆ operator=() [2/2]

◆ read_distributed() [1/4]

◆ read_distributed() [2/4]

◆ read_distributed() [3/4]

◆ read_distributed() [4/4]

◆ row_scale()

Matrix< ValueType, LocalIndexType, GlobalIndexType > Class Template Reference#