| MPI_ALLTOALL(sendbuf, sendcount, sendtype, recvbuf, recvcount, recvtype, comm) | |
| IN sendbuf | starting address of send buffer (choice) |
| IN sendcount | number of elements sent to each process (non-negative integer) |
| IN sendtype | data type of send buffer elements (handle) |
| OUT recvbuf | address of receive buffer (choice) |
| IN recvcount | number of elements received from any process (non-negative integer) |
| IN recvtype | data type of receive buffer elements (handle) |
| IN comm | communicator (handle) |
int MPI_Alltoall(void* sendbuf, int sendcount, MPI_Datatype sendtype, void* recvbuf, int recvcount, MPI_Datatype recvtype, MPI_Comm comm)
MPI_ALLTOALL(SENDBUF, SENDCOUNT, SENDTYPE, RECVBUF, RECVCOUNT, RECVTYPE, COMM, IERROR)
MPI_ALLTOALL is an extension of MPI_ALLGATHER to the case
where each process sends distinct data to each of the receivers.
The
j-th
block sent from process i is received by process j
and is placed in the
i-th
block of recvbuf.
The type signature associated with sendcount, sendtype,
at a process must be equal to the type signature associated with
recvcount, recvtype at any other process.
This implies that the amount of data sent must be equal to the
amount of data received, pairwise between every pair of processes.
As usual, however, the type maps may be different.
If comm is an intracommunicator,
the outcome is as if each process executed a send to each
process (itself included)
with a call to,
MPI_Send(sendbuf+i· sendcount·
extent(sendtype),sendcount,sendtype,i, ...),
and a receive from every other process
with a call to,
All arguments
on all processes are significant. The argument comm
must have identical values on all processes.
No ``in place'' option is supported.
If comm is an intercommunicator, then the outcome is as if
each process in group A sends a message to each process in group B,
and vice versa. The j-th send buffer of process i in group A should
be consistent with the i-th receive buffer of process j in group B,
and vice versa.
When all-to-all is executed on an intercommunication domain, then
the number of data items sent from processes in group A to processes
in group B need not equal the number of items sent in the reverse
direction. In particular, one can have unidirectional communication
by specifying sendcount = 0 in the reverse direction.
( End of advice to users.)
int MPI_Alltoallv(void* sendbuf, int *sendcounts, int *sdispls, MPI_Datatype sendtype, void* recvbuf, int *recvcounts, int *rdispls, MPI_Datatype recvtype, MPI_Comm comm)
MPI_ALLTOALLV(SENDBUF, SENDCOUNTS, SDISPLS, SENDTYPE, RECVBUF, RECVCOUNTS, RDISPLS, RECVTYPE, COMM, IERROR)
MPI_ALLTOALLV adds flexibility to MPI_ALLTOALL in that
the location of data for the send is specified by sdispls
and the location of the placement of the data on the receive side
is specified by rdispls.
If comm is an intracommunicator, then
the
j-th
block sent from process i is received by process j
and is placed in the
i-th
block of recvbuf. These blocks need not all have the same size.
The type signature associated with
sendcount[j], sendtype at process i must be equal
to the type signature
associated with recvcount[i], recvtype at process j.
This implies that the amount of data sent must be equal to the
amount of data received, pairwise between every pair of processes.
Distinct type maps between sender and receiver are still allowed.
The outcome is as if each process sent a message to every other process
with,
MPI_Send(sendbuf+displs[i]· extent(sendtype),sendcounts[i],sendtype,i,...),
and received a message from every other process with
a call to
MPI_Recv(recvbuf+displs[i]· extent(recvtype),recvcounts[i],recvtype,i,...).
All arguments
on all processes are significant. The argument comm
must have identical values on all processes.
No ``in place'' option is supported.
If comm is an intercommunicator, then the outcome is as if
each process in group A sends a message to each process in group B,
and vice versa. The j-th send buffer of process i in group A should
be consistent with the i-th receive buffer of process j in group B,
and vice versa.
The definitions of MPI_ALLTOALL and MPI_ALLTOALLV give as much
flexibility as one would achieve by specifying n independent,
point-to-point communications, with two exceptions: all messages use the same
datatype, and messages are scattered from (or gathered to) sequential
storage.
( End of rationale.)
Although the discussion of collective communication in terms of
point-to-point operation implies that each message is transferred directly
from sender to receiver, implementations may use a tree communication
pattern. Messages can be forwarded by intermediate nodes where they
are split (for scatter) or concatenated (for gather), if this
is more efficient.
( End of advice to implementors.)
int MPI_Alltoallw(void *sendbuf, int sendcounts[], int sdispls[], MPI_Datatype sendtypes[], void *recvbuf, int recvcounts[], int rdispls[], MPI_Datatype recvtypes[], MPI_Comm comm)
MPI_ALLTOALLW(SENDBUF, SENDCOUNTS, SDISPLS, SENDTYPES, RECVBUF, RECVCOUNTS, RDISPLS, RECVTYPES, COMM, IERROR)
void MPI::Comm::Alltoallw(const void* sendbuf, const int sendcounts[], const int sdispls[], const MPI::Datatype sendtypes[], void* recvbuf, const int recvcounts[], const int rdispls[], const MPI::Datatype recvtypes[]) const = 0
MPI_ALLTOALLW
is the most general form of All-to-all.
Like MPI_TYPE_CREATE_STRUCT, the most general type constructor,
MPI_ALLTOALLW allows separate specification of count,
displacement and datatype. In addition, to allow maximum flexibility,
the displacement of blocks within the send and receive buffers is
specified in bytes.
If comm is an intracommunicator, then
the j-th block sent from process i is received by process
j and is placed in the i-th block of recvbuf.
These blocks need not all have the same size.
The type signature associated with
sendcounts[j], sendtypes[j] at process i must be equal
to the type signature
associated with recvcounts[i], recvtypes[i] at process j.
This implies that the amount of data sent must be equal to the
amount of data received, pairwise between every pair of processes.
Distinct type maps between sender and receiver are still allowed.
The outcome is as if each process sent a message to every other process with
MPI_Send(sendbuf+sdispls[i],sendcounts[i],sendtypes[i] ,i,...),
and received a message from every other process with a call to
MPI_Recv(recvbuf+rdispls[i],recvcounts[i],recvtypes[i] ,i,...).
All arguments on all processes are significant. The argument
comm must describe the same communicator on all processes.
No ``in place'' option is supported.
If comm is an intercommunicator, then the outcome is as if
each process in group A sends a message to each process in group B,
and vice versa. The j-th send buffer of process i in group A should
be consistent with the i-th receive buffer of process j in group B,
and vice versa.
The MPI_ALLTOALLW function generalizes several MPI functions by
carefully selecting the input arguments. For example, by making all but one
process have sendcounts[i] = 0, this achieves an MPI_SCATTERW
function.
( End of rationale.)
<type> SENDBUF(*), RECVBUF(*)
INTEGER SENDCOUNT, SENDTYPE, RECVCOUNT, RECVTYPE, COMM, IERROR
void MPI::Comm::Alltoall(const void* sendbuf, int sendcount, const MPI::Datatype& sendtype, void* recvbuf, int recvcount, const MPI::Datatype& recvtype) const = 0
Advice to users.
MPI_ALLTOALLV(sendbuf, sendcounts, sdispls, sendtype,
recvbuf, recvcounts, rdispls, recvtype, comm) IN sendbuf starting address of send buffer (choice) IN sendcounts non-negative
integer array equal to the group size
specifying the number of elements to send to each processor IN sdispls integer array (of length group size). Entry
j specifies the displacement (relative to sendbuf from
which to take the outgoing data destined for process j IN sendtype data type of send buffer elements (handle) OUT recvbuf address of receive buffer (choice) IN recvcounts non-negative
integer array equal to the group size
specifying the number of elements that can be received from
each processor IN rdispls integer array (of length group size). Entry
i specifies the displacement (relative to recvbuf at
which to place the incoming data from process i IN recvtype data type of receive buffer elements (handle) IN comm communicator (handle)
<type> SENDBUF(*), RECVBUF(*)
INTEGER SENDCOUNTS(*), SDISPLS(*), SENDTYPE, RECVCOUNTS(*), RDISPLS(*), RECVTYPE, COMM, IERROR
void MPI::Comm::Alltoallv(const void* sendbuf, const int sendcounts[], const int sdispls[], const MPI::Datatype& sendtype, void* recvbuf, const int recvcounts[], const int rdispls[], const MPI::Datatype& recvtype) const = 0
Rationale.
Advice
to implementors.
MPI_ALLTOALLW(sendbuf, sendcounts, sdispls, sendtypes,
recvbuf, recvcounts, rdispls, recvtypes, comm) IN sendbuf starting address of send buffer (choice) IN sendcounts integer array equal to the group size specifying the
number of elements to send to each processor (array of
non-negative
integers) IN sdispls integer array (of length group size). Entry j specifies
the displacement in bytes (relative to sendbuf) from which to take
the outgoing data destined for process j (array of integers) IN sendtypes array of datatypes (of length group size). Entry j
specifies the type of data to send to process j (array of handles) OUT recvbuf address of receive buffer (choice) IN recvcounts integer array equal to the group size specifying the
number of elements that can be received from each processor (array of
non-negative
integers) IN rdispls integer array (of length group size). Entry i specifies
the displacement in bytes (relative to recvbuf) at which to place the
incoming data from process i (array of integers) IN recvtypes array of datatypes (of length group size). Entry i
specifies the type of data received from process i (array of handles) IN comm communicator (handle)
<type> SENDBUF(*), RECVBUF(*)
INTEGER SENDCOUNTS(*), SDISPLS(*), SENDTYPES(*), RECVCOUNTS(*), RDISPLS(*), RECVTYPES(*), COMM, IERROR
Rationale.
Up: Contents
Next: Global Reduction Operations
Previous: Examples using MPI_ALLGATHER, MPI_ALLGATHERV
Return to MPI-2.1 Standard Index
Return to MPI Forum Home Page
MPI-2.0 of July 1, 2008
HTML Generated on July 6, 2008