Dune Core Modules (2.4.2)
Specialization of CollectiveCommunication for MPI. More...
#include <dune/common/parallel/mpicollectivecommunication.hh>
Public Member Functions  
CollectiveCommunication (const MPI_Comm &c=MPI_COMM_WORLD)  
Instantiation using a MPI communicator.  
int  rank () const 
Return rank, is between 0 and size()1. More...  
int  size () const 
Number of processes in set, is greater than 0. More...  
template<typename T >  
T  sum (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+. More...  
template<typename T >  
int  sum (T *inout, int len) const 
Compute the sum of the argument over all processes and return the result in every process. Assumes that T has an operator+. More...  
template<typename T >  
T  prod (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*. More...  
template<typename T >  
int  prod (T *inout, int len) const 
Compute the product of the argument over all processes and return the result in every process. Assumes that T has an operator*. More...  
template<typename T >  
T  min (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<. More...  
template<typename T >  
int  min (T *inout, int len) const 
Compute the minimum of the argument over all processes and return the result in every process. Assumes that T has an operator<. More...  
template<typename T >  
T  max (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<. More...  
template<typename T >  
int  max (T *inout, int len) const 
Compute the maximum of the argument over all processes 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 (T *in, T *out, int len, int root) const 
Gather arrays on root task. More...  
template<typename T >  
int  gatherv (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 (T *send, T *recv, int len, int root) const 
Scatter array from a root to all other task. More...  
template<typename T >  
int  scatterv (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 , typename T1 >  
int  allgather (T *sbuf, int count, T1 *rbuf) const 
Gathers data from all tasks and distribute it to all. More...  
template<typename T >  
int  allgatherv (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 >  
int  allreduce (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
Specialization of CollectiveCommunication for MPI.
Member Function Documentation
◆ allgather()

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.
◆ allgatherv()

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 recieve 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 recieved from process i will be written starting at out+displ[i].
◆ allreduce() [1/2]

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
◆ allreduce() [2/2]

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
◆ barrier()

inline 
Wait until all processes have arrived at this point in the program.
Referenced by Dune::graphRepartition().
◆ broadcast()

inline 
Distribute an array from the process with rank root to all other processes.
◆ gather()

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 nonroot tasks. [in] len The number of elements to send on each task. [in] root The root task that gathers the data.
 Note
 out must have space for P*len elements
◆ gatherv()

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 nonroot 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 nonroot 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 nonroot tasks. [in] root The root task that gathers the data.
◆ max() [1/2]

inline 
Compute the maximum of the argument over all processes and return the result in every process. Assumes that T has an operator<.
◆ max() [2/2]

inline 
Compute the maximum of the argument over all processes and return the result in every process. Assumes that T has an operator<.
◆ min() [1/2]

inline 
Compute the minimum of the argument over all processes and return the result in every process. Assumes that T has an operator<.
◆ min() [2/2]

inline 
Compute the minimum of the argument over all processes and return the result in every process. Assumes that T has an operator<.
◆ prod() [1/2]

inline 
Compute the product of the argument over all processes and return the result in every process. Assumes that T has an operator*.
◆ prod() [2/2]

inline 
Compute the product of the argument over all processes and return the result in every process. Assumes that T has an operator*.
◆ rank()

inline 
Return rank, is between 0 and size()1.
Referenced by Dune::graphRepartition(), and Dune::storeMatrixMarket().
◆ scatter()

inline 
Scatter array from a root to all other task.
The root process sends the elements with index from k*len to (k+1)*len1 in its array to task k, which stores it at index 0 to len1.
 Parameters

[in] send The array to scatter. Might have length zero on nonroot 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.
 Note
 out must have space for P*len elements
◆ scatterv()

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 recvlen1.
 Parameters

[in] send The array to scatter. May have length zero on nonroot 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.
◆ size()

inline 
Number of processes in set, is greater than 0.
Referenced by Dune::graphRepartition().
◆ sum() [1/2]

inline 
Compute the sum of the argument over all processes and return the result in every process. Assumes that T has an operator+.
Referenced by Dune::OwnerOverlapCopyCommunication< GlobalIdType, LocalIdType >::dot(), and Dune::OwnerOverlapCopyCommunication< GlobalIdType, LocalIdType >::norm().
◆ sum() [2/2]

inline 
Compute the sum of the argument over all processes and return the result in every process. Assumes that T has an operator+.
The documentation for this class was generated from the following file:
 dune/common/parallel/mpicollectivecommunication.hh