Collective communication interface and sequential default implementation. More...

#include <dune/common/parallel/collectivecommunication.hh>

Public Member Functions
	CollectiveCommunication ()
	Construct default object.

	CollectiveCommunication (const Communicator &)
	Constructor with a given communicator. More...

int	rank () const
	Return rank, is between 0 and size()-1.

int	size () const
	Number of processes in set, is greater than 0.

template<typename T >
T	sum (const T &in) const
	Compute the sum of the argument over all processes and return the result in every process. Assumes that T has an operator+.

template<typename T >
int	sum (T *inout, int len) const
	Compute the sum over all processes for each component of an array and return the result in every process. Assumes that T has an operator+. More...

template<typename T >
T	prod (const T &in) const
	Compute the product of the argument over all processes and return the result in every process. Assumes that T has an operator*.

template<typename T >
int	prod (T *inout, int len) const
	Compute the product over all processes for each component of an array and return the result in every process. Assumes that T has an operator*. More...

template<typename T >
T	min (const T &in) const
	Compute the minimum of the argument over all processes and return the result in every process. Assumes that T has an operator<.

template<typename T >
int	min (T *inout, int len) const
	Compute the minimum over all processes for each component of an array and return the result in every process. Assumes that T has an operator<. More...

template<typename T >
T	max (const T &in) const
	Compute the maximum of the argument over all processes and return the result in every process. Assumes that T has an operator<.

template<typename T >
int	max (T *inout, int len) const
	Compute the maximum over all processes for each component of an array and return the result in every process. Assumes that T has an operator<. More...

int	barrier () const
	Wait until all processes have arrived at this point in the program. More...

template<typename T >
int	broadcast (T *inout, int len, int root) const
	Distribute an array from the process with rank root to all other processes. More...

template<typename T >
int	gather (const T in, T out, int len, int root) const
	Gather arrays on root task. More...

template<typename T >
int	gatherv (const T in, int sendlen, T out, int recvlen, int displ, int root) const
	Gather arrays of variable size on root task. More...

template<typename T >
int	scatter (const T send, T recv, int len, int root) const
	Scatter array from a root to all other task. More...

template<typename T >
int	scatterv (const T send, int sendlen, int displ, T recv, int recvlen, int root) const
	Scatter arrays of variable length from a root to all other tasks. More...

template<typename T >
int	allgather (const T sbuf, int count, T rbuf) const
	Gathers data from all tasks and distribute it to all. More...

template<typename T >
int	allgatherv (const T in, int sendlen, T out, int recvlen, int displ) const
	Gathers data of variable length from all tasks and distribute it to all. More...

template<typename BinaryFunction , typename Type >
int	allreduce (Type *inout, int len) const
	Compute something over all processes for each component of an array and return the result in every process. More...

template<typename BinaryFunction , typename Type >
void	allreduce (const Type in, Type out, int len) const
	Compute something over all processes for each component of an array and return the result in every process. More...

Detailed Description

template<typename Communicator>
class Dune::CollectiveCommunication< Communicator >

Collective communication interface and sequential default implementation.

CollectiveCommunication offers an abstraction to the basic methods of parallel communication, following the message-passing paradigm. It allows one to switch parallel features on and off, without changing the code. Currently only MPI and sequential code are supported.

A CollectiveCommunication object is returned by all grids (also the sequential ones) in order to allow code to be written in a transparent way for sequential and parallel grids.

This class provides a default implementation for sequential grids. The number of processes involved is 1, any sum, maximum, etc. returns just its input argument and so on.

In specializations one can implement the real thing using appropriate communication functions, e.g. there exists an implementation using the Message Passing Interface (MPI), see Dune::CollectiveCommunication<MPI_Comm>.

Moreover, the communication subsystem used by an implementation is not visible in the interface, i.e. Dune grid implementations are not restricted to MPI.

Template Parameters

Communicator The communicator type used by your message-passing implementation. For MPI this will be MPI_Comm. For sequential codes there is the dummy communicator No_Comm. It is assumed that if you want to specialize the CollectiveCommunication class for a message-passing system other than MPI, that message-passing system will have something equivalent to MPI communicators.

Constructor & Destructor Documentation

◆ CollectiveCommunication()

template<typename Communicator >

Dune::CollectiveCommunication< Communicator >::CollectiveCommunication ( const Communicator & )

inline

Constructor with a given communicator.

As this is implementation for the sequential setting, the communicator is a dummy and simply discarded.

Member Function Documentation

◆ allgather()

template<typename Communicator >

template<typename T >

int Dune::CollectiveCommunication< Communicator >::allgather	(	const T *	sbuf,
		int	count,
		T *	rbuf
	)		const

inline

Gathers data from all tasks and distribute it to all.

The block of data sent from the jth process is received by every process and placed in the jth block of the buffer recvbuf.

Parameters

[in]	sbuf	The buffer with the data to send. Has to be the same for each task.
[in]	count	The number of elements to send by any process.
[out]	rbuf	The receive buffer for the data. Has to be of size notasks*count, with notasks being the number of tasks in the communicator.

Returns: MPI_SUCCESS (==0) if successful, an MPI error code otherwise

◆ allgatherv()

template<typename Communicator >

template<typename T >

int Dune::CollectiveCommunication< Communicator >::allgatherv	(	const T *	in,
		int	sendlen,
		T *	out,
		int *	recvlen,
		int *	displ
	)		const

inline

Gathers data of variable length from all tasks and distribute it to all.

The block of data sent from the jth process is received by every process and placed in the jth block of the buffer out.

Parameters

[in]	in	The send buffer with the data to send.
[in]	sendlen	The number of elements to send on each task.
[out]	out	The buffer to store the received data in.
[in]	recvlen	An array with size equal to the number of processes containing the number of elements to receive from process i at position i, i.e. the number that is passed as sendlen argument to this function in process i.
[in]	displ	An array with size equal to the number of processes. Data received from process i will be written starting at out+displ[i].

Returns: MPI_SUCCESS (==0) if successful, an MPI error code otherwise

References DUNE_UNUSED_PARAMETER.

◆ allreduce() [1/2]

template<typename Communicator >

template<typename BinaryFunction , typename Type >

void Dune::CollectiveCommunication< Communicator >::allreduce	(	const Type *	in,
		Type *	out,
		int	len
	)		const

inline

Compute something over all processes for each component of an array and return the result in every process.

The template parameter BinaryFunction is the type of the binary function to use for the computation

Parameters

in	The array to compute on.
out	The array to store the results in.
len	The number of components in the array

Returns: MPI_SUCCESS (==0) if successful, an MPI error code otherwise

◆ allreduce() [2/2]

template<typename Communicator >

template<typename BinaryFunction , typename Type >

int Dune::CollectiveCommunication< Communicator >::allreduce	(	Type *	inout,
		int	len
	)		const

inline

Compute something over all processes for each component of an array and return the result in every process.

The template parameter BinaryFunction is the type of the binary function to use for the computation

Parameters

inout	The array to compute on.
len	The number of components in the array

Returns: MPI_SUCCESS (==0) if successful, an MPI error code otherwise

References DUNE_UNUSED_PARAMETER.

◆ barrier()

template<typename Communicator >

int Dune::CollectiveCommunication< Communicator >::barrier ( ) const

inline

Wait until all processes have arrived at this point in the program.

Returns: MPI_SUCCESS (==0) if successful, an MPI error code otherwise

◆ broadcast()

template<typename Communicator >

template<typename T >

int Dune::CollectiveCommunication< Communicator >::broadcast	(	T *	inout,
		int	len,
		int	root
	)		const

inline

Distribute an array from the process with rank root to all other processes.

Returns: MPI_SUCCESS (==0) if successful, an MPI error code otherwise

References DUNE_UNUSED_PARAMETER.

◆ gather()

template<typename Communicator >

template<typename T >

int Dune::CollectiveCommunication< Communicator >::gather	(	const T *	in,
		T *	out,
		int	len,
		int	root
	)		const

inline

Gather arrays on root task.

Each process sends its in array of length len to the root process (including the root itself). In the root process these arrays are stored in rank order in the out array which must have size len * number of processes.

Parameters

[in]	in	The send buffer with the data to send.
[out]	out	The buffer to store the received data in. Might have length zero on non-root tasks.
[in]	len	The number of elements to send on each task.
[in]	root	The root task that gathers the data.

Returns: MPI_SUCCESS (==0) if successful, an MPI error code otherwise

References DUNE_UNUSED_PARAMETER.

◆ gatherv()

template<typename Communicator >

template<typename T >

int Dune::CollectiveCommunication< Communicator >::gatherv	(	const T *	in,
		int	sendlen,
		T *	out,
		int *	recvlen,
		int *	displ,
		int	root
	)		const

inline

Gather arrays of variable size on root task.

Each process sends its in array of length sendlen to the root process (including the root itself). In the root process these arrays are stored in rank order in the out array.

Parameters

[in]	in	The send buffer with the data to be sent
[in]	sendlen	The number of elements to send on each task
[out]	out	The buffer to store the received data in. May have length zero on non-root tasks.
[in]	recvlen	An array with size equal to the number of processes containing the number of elements to receive from process i at position i, i.e. the number that is passed as sendlen argument to this function in process i. May have length zero on non-root tasks.
[out]	displ	An array with size equal to the number of processes. Data received from process i will be written starting at out+displ[i] on the root process. May have length zero on non-root tasks.
[in]	root	The root task that gathers the data.

Returns: MPI_SUCCESS (==0) if successful, an MPI error code otherwise

References DUNE_UNUSED_PARAMETER.

◆ max()

template<typename Communicator >

template<typename T >

int Dune::CollectiveCommunication< Communicator >::max	(	T *	inout,
		int	len
	)		const

inline

Compute the maximum over all processes for each component of an array and return the result in every process. Assumes that T has an operator<.

Returns: MPI_SUCCESS (==0) if successful, an MPI error code otherwise

References DUNE_UNUSED_PARAMETER.

◆ min()

template<typename Communicator >

template<typename T >

int Dune::CollectiveCommunication< Communicator >::min	(	T *	inout,
		int	len
	)		const

inline

Compute the minimum over all processes for each component of an array and return the result in every process. Assumes that T has an operator<.

Returns: MPI_SUCCESS (==0) if successful, an MPI error code otherwise

References DUNE_UNUSED_PARAMETER.

◆ prod()

template<typename Communicator >

template<typename T >

int Dune::CollectiveCommunication< Communicator >::prod	(	T *	inout,
		int	len
	)		const

inline

Compute the product over all processes for each component of an array and return the result in every process. Assumes that T has an operator*.

Returns: MPI_SUCCESS (==0) if successful, an MPI error code otherwise

References DUNE_UNUSED_PARAMETER.

◆ scatter()

template<typename Communicator >

template<typename T >

int Dune::CollectiveCommunication< Communicator >::scatter	(	const T *	send,
		T *	recv,
		int	len,
		int	root
	)		const

inline

Scatter array from a root to all other task.

The root process sends the elements with index from k*len to (k+1)*len-1 in its array to task k, which stores it at index 0 to len-1.

Parameters

[in]	send	The array to scatter. Might have length zero on non-root tasks.
[out]	recv	The buffer to store the received data in. Upon completion of the method each task will have same data stored there as the one in send buffer of the root task before.
[in]	len	The number of elements in the recv buffer.
[in]	root	The root task that gathers the data.

Returns: MPI_SUCCESS (==0) if successful, an MPI error code otherwise

References DUNE_UNUSED_PARAMETER.

◆ scatterv()

template<typename Communicator >

template<typename T >

int Dune::CollectiveCommunication< Communicator >::scatterv	(	const T *	send,
		int *	sendlen,
		int *	displ,
		T *	recv,
		int	recvlen,
		int	root
	)		const

inline

Scatter arrays of variable length from a root to all other tasks.

The root process sends the elements with index from send+displ[k] to send+displ[k]-1 in its array to task k, which stores it at index 0 to recvlen-1.

Parameters

[in]	send	The array to scatter. May have length zero on non-root tasks.
[in]	sendlen	An array with size equal to the number of processes containing the number of elements to scatter to process i at position i, i.e. the number that is passed as recvlen argument to this function in process i.
[in]	displ	An array with size equal to the number of processes. Data scattered to process i will be read starting at send+displ[i] on root the process.
[out]	recv	The buffer to store the received data in. Upon completion of the method each task will have the same data stored there as the one in send buffer of the root task before.
[in]	recvlen	The number of elements in the recv buffer.
[in]	root	The root task that gathers the data.

Returns: MPI_SUCCESS (==0) if successful, an MPI error code otherwise

References DUNE_UNUSED_PARAMETER.

◆ sum()

template<typename Communicator >

template<typename T >

int Dune::CollectiveCommunication< Communicator >::sum	(	T *	inout,
		int	len
	)		const

inline

Compute the sum over all processes for each component of an array and return the result in every process. Assumes that T has an operator+.

Returns: MPI_SUCCESS (==0) if successful, an MPI error code otherwise

References DUNE_UNUSED_PARAMETER.

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

dune/common/parallel/collectivecommunication.hh

DUNE Distributed and Unified Numerics Environment

Dune Core Modules (2.6.0)

Public Member Functions

Detailed Description

Constructor & Destructor Documentation

◆ CollectiveCommunication()

Member Function Documentation

◆ allgather()

◆ allgatherv()

◆ allreduce() [1/2]

◆ allreduce() [2/2]

◆ barrier()

◆ broadcast()

◆ gather()

◆ gatherv()

◆ max()

◆ min()

◆ prod()

◆ scatter()

◆ scatterv()

◆ sum()