|MPI_REDUCE_SCATTER_BLOCK( sendbuf, recvbuf, recvcount, datatype, op, comm)|
|IN sendbuf||starting address of send buffer (choice)|
|OUT recvbuf||starting address of receive buffer (choice)|
|IN recvcount||element count per block (non-negative integer)|
|IN datatype||data type of elements of send and receive buffers (handle)|
|IN op||operation (handle)|
|IN comm||communicator (handle)|
int MPI_Reduce_scatter_block(const void* sendbuf, void* recvbuf, int recvcount, MPI_Datatype datatype, MPI_Op op, MPI_Comm comm)
MPI_Reduce_scatter_block(sendbuf, recvbuf, recvcount, datatype, op, comm, ierror)
TYPE(*), DIMENSION(..), INTENT(IN) :: sendbuf
TYPE(*), DIMENSION(..) :: recvbuf
INTEGER, INTENT(IN) :: recvcount
TYPE(MPI_Datatype), INTENT(IN) :: datatype
TYPE(MPI_Op), INTENT(IN) :: op
TYPE(MPI_Comm), INTENT(IN) :: comm
INTEGER, OPTIONAL, INTENT(OUT) :: ierror
MPI_REDUCE_SCATTER_BLOCK(SENDBUF, RECVBUF, RECVCOUNT, DATATYPE, OP, COMM, IERROR)
<type> SENDBUF(*), RECVBUF(*)
INTEGER RECVCOUNT, DATATYPE, OP, COMM, IERROR
If comm is an intracommunicator, MPI_REDUCE_SCATTER_BLOCK first performs a global, element-wise reduction on vectors of count = n*recvcount elements in the send buffers defined by sendbuf, count and datatype, using the operation op, where n is the number of processes in the group of comm. The routine is called by all group members using the same arguments for recvcount, datatype, op and comm. The resulting vector is treated as n consecutive blocks of recvcount elements that are scattered to the processes of the group. The i-th block is sent to process i and stored in the receive buffer defined by recvbuf, recvcount, and datatype.
Advice to implementors.
The MPI_REDUCE_SCATTER_BLOCK routine is functionally equivalent to:
an MPI_REDUCE collective operation with count equal to recvcount* n,
followed by an MPI_SCATTER with sendcount equal to recvcount.
However, a direct implementation may run faster.
( End of advice to implementors.)
The ``in place'' option for intracommunicators is specified by passing MPI_IN_PLACE in the sendbuf argument on all processes. In this case, the input data is taken from the receive buffer.
If comm is an intercommunicator, then the result of the reduction of the data provided by processes in one group (group A) is scattered among processes in the other group (group B) and vice versa. Within each group, all processes provide the same value for the recvcount argument, and provide input vectors of count = n*recvcount elements stored in the send buffers, where n is the size of the group. The number of elements count must be the same for the two groups. The resulting vector from the other group is scattered in blocks of recvcount elements among the processes in the group.
The last restriction is needed so that the length of the send buffer of one group can be
determined by the local recvcount argument of the other group.
Otherwise, a communication is needed to figure out how many elements are reduced.
( End of rationale.)