Irecv!(buf::MPIBuffertype{T}, count::Integer, datatype::Datatype,
       src::Integer, tag::Integer, comm::Comm) where T

Starts a nonblocking receive of up to count elements of type datatype into buf from MPI rank src of communicator comm using with the message tag tag

Returns the communication Request for the nonblocking receive.

Irecv!(buf::MPIBuffertype{T}, count::Integer, src::Integer, tag::Integer,
       comm::Comm) where T

Starts a nonblocking receive of up to count elements into buf from MPI rank src of communicator comm using with the message tag tag

Returns the communication Request for the nonblocking receive.

Irecv!(buf::Array{T}, src::Integer, tag::Integer, comm::Comm) where T

Starts a nonblocking receive into buf from MPI rank src of communicator comm using with the message tag tag

Returns the communication Request for the nonblocking receive.

Isend(buf::MPIBuffertype{T}, count::Integer, datatype::Datatype,
      dest::Integer, tag::Integer, comm::Comm) where T

Starts a nonblocking send of count elements of type datatype from buf to MPI rank dest of communicator comm using with the message tag tag

Returns the commication Request for the nonblocking send.

Isend(buf::MPIBuffertype{T}, count::Integer, dest::Integer, tag::Integer,
      comm::Comm) where T

Starts a nonblocking send of count elements of buf to MPI rank dest of communicator comm using with the message tag tag

Returns the commication Request for the nonblocking send.

Isend(buf::Array{T}, dest::Integer, tag::Integer, comm::Comm) where T

Starts a nonblocking send of buf to MPI rank dest of communicator comm using with the message tag tag

Returns the commication Request for the nonblocking send.

Isend(obj::T, dest::Integer, tag::Integer, comm::Comm) where T

Starts a nonblocking send of obj to MPI rank dest of communicator comm using with the message tag tag.

Returns the commication Request for the nonblocking send.

Recv!(buf::MPIBuffertype{T}, count::Integer, datatype::Datatype,
      src::Integer, tag::Integer, comm::Comm) where T

Completes a blocking receive of up to count elements of type datatype into buf from MPI rank src of communicator comm using with the message tag tag

Returns the Status of the receive

Recv!(buf::MPIBuffertype{T}, count::Integer, src::Integer, tag::Integer,
      comm::Comm) where T

Completes a blocking receive of up to count elements into buf from MPI rank src of communicator comm using with the message tag tag

Returns the Status of the receive

Recv!(buf::Array{T}, src::Integer, tag::Integer, comm::Comm) where T

Completes a blocking receive into buf from MPI rank src of communicator comm using with the message tag tag

Returns the Status of the receive

Send(buf::MPIBuffertype{T}, count::Integer, datatype::Datatype,
     dest::Integer, tag::Integer, comm::Comm) where T

Complete a blocking send of count elements of type datatype from buf to MPI rank dest of communicator comm using the message tag tag

Send(buf::MPIBuffertype{T}, count::Integer, dest::Integer, tag::Integer,
     comm::Comm) where T

Complete a blocking send of count elements of buf to MPI rank dest of communicator comm using with the message tag tag

Send(buf::AbstractArray{T}, dest::Integer, tag::Integer, comm::Comm) where T

Complete a blocking send of buf to MPI rank dest of communicator comm using with the message tag tag

Send(obj::T, dest::Integer, tag::Integer, comm::Comm) where T

Complete a blocking send of obj to MPI rank dest of communicator comm using with the message tag tag.

Wait!(req::Request)

Wait on the request req to be complete. Returns the Status of the request.

Waitall!(reqs::Vector{Request})

Wait on all the requests in the array reqs to be complete. Returns an arrays of the all the requests statuses.

Waitany!(reqs::Vector{Request})

Wait on any the requests in the array reqs to be complete. Returns the index of the completed request and its Status as a tuple.

Allgather!(sendbuf, recvbuf, count, comm)

Each process sends the first count elements of sendbuf to the other processes, who store the results in rank order into recvbuf.

If sendbuf==MPI.IN_PLACE the input data is assumed to be in the area of recvbuf where the process would receive it's own contribution.

Allgather!(buf, count, comm)

Equivalent to Allgather!(MPI.IN_PLACE, buf, count, comm).

Allgather(sendbuf[, count=length(sendbuf)], comm)

Each process sends the first count elements of sendbuf to the other processes, who store the results in rank order allocating the output buffer.

Allgatherv!(sendbuf, recvbuf, counts, comm)

Each process sends the first counts[rank] elements of the buffer sendbuf to all other process. Each process stores the received data in rank order in the buffer recvbuf.

if sendbuf==MPI.IN_PLACE every process takes the data to be sent is taken from the interval of recvbuf where it would store it's own data.

Allgatherv(sendbuf, counts, comm)

Each process sends the first counts[rank] elements of the buffer sendbuf to all other process. Each process allocates an output buffer and stores the received data in rank order.

Allreduce!(sendbuf, recvbuf[, count=length(sendbuf)], op, comm)

Performs op reduction on the first count elements of the buffer sendbuf storing the result in the recvbuf of all processes in the group.

All-reduce is equivalent to a Reduce! operation followed by a Bcast!, but can lead to better performance.

If sendbuf==MPI.IN_PLACE the data is read from recvbuf and then overwritten with the results.

To handle allocation of the output buffer, see Allreduce.

Allreduce!(buf, op, comm)

Performs op reduction in place on the buffer sendbuf, overwriting it with the results on all the processes in the group.

Equivalent to calling Allreduce!(MPI.IN_PLACE, buf, op, comm)

Allreduce(sendbuf, op, comm)

Performs op reduction on the buffer sendbuf, allocating and returning the output buffer in all processes of the group.

To specify the output buffer or perform the operation in pace, see Allreduce!.

Alltoall!(sendbuf, recvbuf, count, comm)

Every process divides the buffer sendbuf into Comm_size(comm) chunks of length count, sending the j-th chunk to the j-th process. Every process stores the data received from the j-th process in the j-th chunk of the buffer recvbuf.

rank    send buf                        recv buf
----    --------                        --------
 0      a,b,c,d,e,f       Alltoall      a,b,A,B,α,β
 1      A,B,C,D,E,F  ---------------->  c,d,C,D,γ,ψ
 2      α,β,γ,ψ,η,ν                     e,f,E,F,η,ν

If sendbuf==MPI.IN_PLACE, data is sent from the recvbuf and then overwritten.

Alltoall(sendbuf, count, comm)

Every process divides the buffer sendbuf into Comm_size(comm) chunks of length count, sending the j-th chunk to the j-th process. Every process allocates the output buffer and stores the data received from the j-th process in the j-th chunk.

rank    send buf                        recv buf
----    --------                        --------
 0      a,b,c,d,e,f       Alltoall      a,b,A,B,α,β
 1      A,B,C,D,E,F  ---------------->  c,d,C,D,γ,ψ
 2      α,β,γ,ψ,η,ν                     e,f,E,F,η,ν

Alltoallv!(sendbuf::T, recvbuf::T, scounts, rcounts, comm)

MPI.IN_PLACE is not supported for this operation.

Barrier(comm::Comm)

Blocks until comm is synchronized.

If comm is an intracommunicator, then it blocks until all members of the group have called it.

If comm is an intercommunicator, then it blocks until all members of the other group have called it.

Bcast!(buf[, count=length(buf)], root, comm::Comm)

Broadcast the first count elements of the buffer buf from root to all processes.

Gather!(sendbuf, recvbuf, count, root, comm)

Each process sends the first count elements of the buffer sendbuf to the root process. The root process stores elements in rank order in the buffer buffer recvbuf.

count should be the same for all processes. If the number of elements varies between processes, use Gatherv! instead.

To perform the reduction in place refer to Gather_in_place!.

Gather(sendbuf[, count=length(sendbuf)], root, comm)

Each process sends the first count elements of the buffer sendbuf to the root process. The root allocates the output buffer and stores elements in rank order.

Gather_in_place!(buf, count, root, comm)

Each process sends the first count elements of the buffer buf to the root process. The root process stores elements in rank order in the buffer buffer buf, sending no data to itself.

This is functionally equivalent to calling

if root == MPI.Comm_rank(comm)
    Gather!(MPI.IN_PLACE, buf, count, root, comm)
else
    Gather!(buf, C_NULL, count, root, comm)
end

Gatherv!(sendbuf, recvbuf, counts, root, comm)

Each process sends the first counts[rank] elements of the buffer sendbuf to the root process. The root stores elements in rank order in the buffer recvbuf.

To perform the reduction in place refer to Gatherv_in_place!.

Gatherv(sendbuf, counts, root, comm)

Each process sends the first counts[rank] elements of the buffer sendbuf to the root process. The root allocates the output buffer and stores elements in rank order.

Gatherv_in_place!(buf, counts, root, comm)

Each process sends the first counts[rank] elements of the buffer buf to the root process. The root allocates the output buffer and stores elements in rank order.

This is functionally equivalent to calling

if root == MPI.Comm_rank(comm)
    Gatherv!(MPI.IN_PLACE, buf, counts, root, comm)
else
    Gatherv!(buf, C_NULL, counts, root, comm)
end

Reduce!(sendbuf, recvbuf[, count=length(sendbuf)], op, root, comm)

Performs op reduction on the first count elements of the buffer sendbuf and stores the result in recvbuf on the process of rank root.

On non-root processes recvbuf is ignored.

To perform the reduction in place, see Reduce_in_place!.

To handle allocation of the output buffer, see Reduce.

Reduce(sendbuf, count, op, root, comm)

Performs op reduction on the buffer sendbuf and stores the result in an output buffer allocated on the process of rank root. An empty array will be returned on all other processes.

To specify the output buffer, see Reduce!.

To perform the reduction in place, see Reduce_in_place!.

Reduce_in_place!(buf, count, op, root, comm)

Performs op reduction on the first count elements of the buffer buf and stores the result on buf of the root process in the group.

This is equivalent to calling

if root == MPI.Comm_rank(comm)
    Reduce!(MPI.IN_PLACE, buf, count, root, comm)
else
    Reduce!(buf, C_NULL, count, root, comm)
end

To handle allocation of the output buffer, see Reduce.

To specify a separate output buffer, see Reduce!.

Scatter!(sendbuf, recvbuf, count, root, comm)

Splits the buffer sendbuf in the root process into Comm_size(comm) chunks and sends the j-th chunk to the process of rank j into the recvbuf buffer, which must be of length at least count.

count should be the same for all processes. If the number of elements varies between processes, use Scatter! instead.

To perform the reduction in place, see Scatter_in_place!.

To handle allocation of the output buffer, see Scatter.

Scatter(sendbuf, count, root, comm)

Splits the buffer sendbuf in the root process into Comm_size(comm) chunks and sends the j-th chunk to the process of rank j, allocating the output buffer.

Scatter_in_place!(buf, count, root, comm)

Splits the buffer buf in the root process into Comm_size(comm) chunks and sends the j-th chunk to the process of rank j. No data is sent to the root process.

This is functionally equivalent to calling

if root == MPI.Comm_rank(comm)
    Scatter!(buf, MPI.IN_PLACE, count, root, comm)
else
    Scatter!(C_NULL, buf, count, root, comm)
end

To specify a separate output buffer, see Scatter!.

To handle allocation of the output buffer, see Scatter.

Scatterv!(sendbuf, recvbuf, counts, root, comm)

Splits the buffer sendbuf in the root process into Comm_size(comm) chunks of length counts[j] and sends the j-th chunk to the process of rank j into the recvbuf buffer, which must be of length at least count.

To perform the reduction in place refer to Scatterv_in_place!.

Scatterv(sendbuf, counts, root, comm)

Splits the buffer sendbuf in the root process into Comm_size(comm) chunks of length counts[j] and sends the j-th chunk to the process of rank j, which allocates the output buffer

Scatterv_in_place(buf, counts, root, comm)

Splits the buffer buf in the root process into Comm_size(comm) chunks of length counts[j] and sends the j-th chunk to the process of rank j into the buf buffer, which must be of length at least count. The root process sends nothing to itself.

This is functionally equivalent to calling

if root == MPI.Comm_rank(comm)
    Scatterv!(buf, MPI.IN_PLACE, counts, root, comm)
else
    Scatterv!(C_NULL, buf, counts, root, comm)
end

MPI.Win_create(base::Array, comm::Comm; infokws...)

Create a window over the array base, returning a Win object used by these processes to perform RMA operations

This is a collective call over comm.

infokws are info keys providing optimization hints.

MPI.free should be called on the Win object once operations have been completed.

MPI.Win_create_dynamic(comm::Comm; infokws...)

Create a dynamic window returning a Win object used by these processes to perform RMA operations

This is a collective call over comm.

infokws are info keys providing optimization hints.

MPI.free should be called on the Win object once operations have been completed.

(win, ptr) = MPI.Win_allocate_shared(T, len, comm::Comm; infokws...)

Create and allocate a shared memory window for objects of type T of length len, returning a Win and a Ptr{T} object used by these processes to perform RMA operations

This is a collective call over comm.

infokws are info keys providing optimization hints.

MPI.free should be called on the Win object once operations have been completed.

Info <: AbstractDict{Symbol,String}

MPI.Info objects store key-value pairs, and are typically used for passing optional arguments to MPI functions.

Usage

These will typically be hidden from user-facing APIs by splatting keywords, e.g.

function f(args...; kwargs...)
    info = Info(kwargs...)
    # pass `info` object to `ccall`
end

For manual usage, Info objects act like Julia Dict objects:

info = Info(init=true) # keyword argument is required
info[key] = value
x = info[key]
delete!(info, key)

If init=false is used in the costructor (the default), a "null" Info object will be returned: no keys can be added to such an object.

infoval(x)

Convert Julia object x to a string representation for storing in an Info object.

The MPI specification allows passing strings, Boolean values, integers, and lists.