MPI_Abort(MPI_Comm comm, int errorcode)

Terminates MPI execution environment.

MPI_Accumulate(void *origin_addr, int origin_count, MPI_Datatype origin_datatype, int target_rank, MPI_Aint target_disp, int target_count, MPI_Datatype target_datatype, MPI_Op op, MPI_Win win)

Combines the contents of the origin buffer with that of a target buffer.

MPI_Add_error_class(int *errorclass)

Creates a new, local error class.

MPI_Add_error_code(int errorclass, int *errorcode)

Creates a new error code and associates it with an error class.

MPI_Add_error_string(int *errorcode, char *string)

Creates an error string and associates it with an error code or an error class.

MPI_Address(void *location, MPI_Aint *address)

Deprecated: Use instead MPI_Get_address(). Gets the address of a location in memory.

MPI_Allgather(void *sendbuf, int sendcount, MPI_Datatype sendtype, void *recvbuf, int recvcount, MPI_Datatype recvtype, MPI_Comm comm)

Gathers data from all processes and distributes it to all.

MPI_Allgatherv(void *sendbuf, int sendcount, MPI_Datatype sendtype, void *recvbuf, int *recvcount, int *displs, MPI_Datatype recvtype, MPI_Comm comm)

Gathers data from all processes and delivers it to all. Each process can contribute a different amount of data.

MPI_Alloc_mem(MPI_Aint size, MPI_Info info, void *baseptr)

Allocates a specified memory segment.

MPI_Allreduce(void *sendbuf, void *recvbuf, int count, MPI_Datatype datatype, MPI_Op op, MPI_Comm comm)

Combines values from all processes and distributes the result back to all processes.

MPI_Alltoall(void *sendbuf, int sendcount, MPI_Datatype sendtype, void *recvbuf, int recvcount, MPI_Datatype recvtype, MPI_Comm comm)

All processes send data to, and receive data from, all processes.

MPI_Alltoallv(void *sendbuf, int *sendcounts, int *sdispls, MPI_Datatype sendtype, void *recvbuf, int *recvcounts, int *rdispls, MPI_Datatype recvtype, MPI_Comm comm)

All processes send data to, and receive data from, all processes, but user can specify different amounts of data to send and receive.

MPI_Alltoallw(void *sendbuf, int *sendcounts, int *sdispls, MPI_Datatype sendtypes, void *recvbuf, int *recvcounts, int *rdispls, MPI_Datatype recvtypes, MPI_Comm comm)

All processes send data to, and receive data from, all other processes, and user can specify database of individual datablocks of different types.

MPI_Attr_delete(MPI_Comm comm, int keyval)

Deprecated: Use instead MPI_Comm_delete_attr(). Deletes attribute value associated with a key.

MPI_Attr_get(MPI_Comm comm, int keyval, void *attribute_val, int *flag)

Deprecated: Use instead MPI_Comm_get_attr(). Retrieves attribute value by key.

MPI_Attr_put(MPI_Comm comm, int keyval, void *attribute_val)

Deprecated: Use instead MPI_Comm_set_attr(). Stores attribute value associated with a key.

MPI_Barrier(MPI_Comm comm)

Blocks until all processes have reached this routine.

MPI_Bcast(void *buffer, int count, MPI_Datatype datatype, int root, MPI_Comm comm)

Broadcasts a message from the process with rank root to all other processes of the group.

MPI_Bsend(void *buf, int count, MPI_Datatype datatype, int dest, int tag, MPI_Comm comm)

Basic send with user-specified buffering.

MPI_Bsend_init(void *buf, int count, MPI_Datatype datatype, int dest, int tag, MPI_Comm comm, MPI_Request *request)

Builds a handle for a buffered send.

MPI_Buffer_attach(void *buf, int size)

Attaches a user-defined buffer for sending.

MPI_Buffer_detach(void *buf, int *size)

Removes an existing buffer (for use in MPI_Bsend(), etc.).

MPI_Cancel(MPI_Request *request)

Cancels a communication request.

MPI_Cart_coords(MPI_Comm comm, int rank, int maxdims, int *coords)

Determines process coordinates in Cartesian topology given rank in group.

MPI_Cart_create(MPI_Comm comm_old, int ndims, int *dims, int *periods, int reorder, MPI_Comm *comm_cart)

Makes a new communicator to which Cartesian topology information has been attached.

MPI_Cart_get(MPI_Comm comm, int maxdims, int *dims, int *periods, int *coords)

Retrieves Cartesian topology information associated with a communicator.

MPI_Cart_map(MPI_Comm comm, int ndims, int *dims, int *periods, int *newrank)

Maps process to Cartesian topology information.

MPI_Cart_rank(MPI_Comm comm, int *coords, int *rank)

Determines process rank in communicator given Cartesian location.

MPI_Cart_shift(MPI_Comm comm, int direction, int disp, int *rank_source, int *rank_dest)

Returns the shifted source and destination ranks, given a shift direction and amount.

MPI_Cart_sub(MPI_Comm comm, int *remain_dims, MPI_Comm *comm_new)

Partitions a communicator into subcommunicators that form lower-dimensional Cartesian subgrids.

MPI_Cartdim_get(MPI_Comm comm, int *ndims)

Retrieves Cartesian topology information associated with a communicator.

MPI_Close_port(char *port_name)

Releases the specified network address.

MPI_Comm_accept(char *port_name, MPI_Info info, int root, MPI_Comm comm, MPI_Comm *newcomm)

Establishes communication with a client (collective).

MPI_Comm_c2f(MPI_Comm comm)

Translates a C handle into a Fortran handle.

MPI_Comm_compare(MPI_Comm comm1, MPI_Comm comm2, int *result)

Compares two communicators.

MPI_Comm_connect(char *port_name, MPI_Info info, int root, MPI_Comm comm, MPI_Comm *newcomm)

Establishes communication with a server (collective).

MPI_Comm_create(MPI_Comm comm, MPI_Group group, MPI_Comm *newcomm)

Creates a new communicator from a group.

MPI_Comm_create_errhandler(

MPI_Comm_errhandler_fn *function,

MPI_Errhandler *errhandler)

Creates an error handler that can be attached to communicators.

MPI_Comm_create_keyval(

MPI_Comm_copy_attr_function *comm_copy_attr_fn, MPI_Comm_delete_attr_function *comm_delete_attr_fn, int *comm_keyval, void *extra_state)

Generates a new attribute key.

MPI_Comm_delete_attr(MPI_Comm comm, int comm_keyval)

Deletes attribute value associated with a key.

MPI_Comm_disconnect(MPI_Comm *comm)

De-allocates communicator object and sets handle to MPI_COMM_NULL (collective).

MPI_Comm_dup(MPI_Comm comm, MPI_Comm *newcomm)

Duplicates an existing communicator with all its cached information.

MPI_Comm_f2c(MPI_Fint comm)

Translates a Fortran handle into a C handle.

MPI_Comm_free(MPI_Comm *comm)

Marks the communicator object for de-allocation.

MPI_Comm_free_keyval(int *comm_keyval)

Frees attribute key for communicator cache attribute.

MPI_Comm_get_attr(MPI_Comm comm, int comm_keyval, void *attribute_val, int *flag)

Retrieves attribute value by key.

MPI_Comm_get_errhandler(MPI_Comm comm, MPI_Errhandler *errhandler)

Retrieves error handler associated with a communicator.

MPI_Comm_get_name(MPI_Comm comm, char *comm_name, int *resultlen)

Returns the name that was most recently associated with a communicator.

MPI_Comm_get_parent(MPI_Comm *parent)

Returns the parent intercommunicator of current spawned process.

MPI_Comm_group(MPI_Comm comm, MPI_Group *group)

Accesses the group associated with a communicator.

MPI_Comm_join(int fd, MPI_Comm *intercomm)

Creates an intercommunicator from the union of two MPI processes connected by a socket.

MPI_Comm_rank(MPI_Comm comm, int *rank)

Determines the rank of the calling process in a communicator.

MPI_Comm_remote_group(MPI_Comm comm, MPI_Group *group)

Accesses the remote group associated with an intercommunicator.

MPI_Comm_remote_size(MPI_Comm comm, int size)

Determines the size of the remote group associated with an intercommunicator.

MPI_Comm_set_attr(MPI_Comm comm, int comm_keyval, void *attribute_val)

Stores attribute value associated with a key.

MPI_Comm_set_errhandler(MPI_Comm comm, MPI_Errhandler *errhandler)

Attaches a new error handler to a communicator.

MPI_Comm_set_name(MPI_Comm comm, char *comm_name)

Associates a name with a communicator.

MPI_Comm_size(MPI_Comm comm, int *size)

Determines the size of the group associated with a communicator.

MPI_Comm_spawn(char *command, char *argv[ ], int maxprocs, MPI_Info info, int root, MPI_Comm comm, MPI_Comm *intercomm, int array_of_errcodes[ ])

Spawns a number of identical binaries.

MPI_Comm_spawn_multiple(int count, char *array_of_commands[ ], char **array_of_argv[ ], int array_of_maxprocs[ ], MPI_Info array_of_info[ ], int root, MPI_Comm comm, MPI_Comm *intercomm, int array_of_errcodes[ ])

Spawns multiple binaries, or the same binary with multiple sets of arguments.

MPI_Comm_split(MPI_Comm comm, int color, int key, MPI_Comm *newcomm)

Creates new communicators based on colors and keys.

MPI_Comm_test_inter(MPI_Comm comm, int *flag)

Tests whether a communicator is an intercommunicator.

MPI_Dims_create(int nnodes, int ndims, int *dims)

Creates a division of processors in a Cartesian grid.

MPI_Errhandler_create(

MPI_Handler_function *function, MPI_Errhandler *errhandler)

Deprecated: Use instead MPI_Comm_create_errhandler
(). Creates an MPI error handler.

MPI_Errhandler_free(MPI_Errhandler *errhandler)

Frees an MPI error handler.

MPI_Errhandler_get(MPI_Comm comm, MPI_Errhandler *errhandler)

Deprecated: Use instead MPI_Comm_get_errhandler(). Gets the error handler for a communicator.

MPI_Errhandler_set(MPI_Comm comm, MPI_Errhandler errhandler)

Deprecated: Use instead MPI_Comm_set_errhandler(). Sets the error handler for a communicator.

MPI_Error_class(int errorcode, int *errorclass)

Converts an error code into an error class.

MPI_Error_string(int errorcode, char *string, int *resultlen)

Returns a string for a given error code.

MPI_Exscan(void *sendbuf, void *recvbuf, int count, MPI_Datatype datatype, MPI_Op op, MPI_Comm, comm)

Performs an exclusive prefix reduction on data distributed across the calling processes.

MPI_Finalize( )

Terminates MPI execution environment.

MPI_Finalized(int *flag)

Checks whether MPI_Finalize() has completed.

MPI_Free_mem(void *base)

Frees memory that has been allocated using MPI_Alloc_mem.

MPI_Gather(void *sendbuf, int *sendcount, MPI_Datatype sendtype, void *recvbuf, int recvcount, MPI_Datatype recvtype, int root, MPI_Comm comm)

Gathers values from a group of processes.

MPI_Gatherv(void *sendbuf, int sendcount, MPI_Datatype sendtype, void *recvbuf, int *recvcounts, int *displs, MPI_Datatype recvtype, int root, MPI_Comm comm)

Gathers into specified locations from all processes in a group. Each process can contribute a different amount of data.

MPI_Get(void *origin_addr, int origin_count, MPI_Datatype origin_datatype, int target_rank, MPI_Aint target_disp, int target_count, MPI_Datatype target_datatype, MPI_Win win)

Copies data from the target memory to the origin.

MPI_Get_address(void *location, MPI_Aint *address)

Gets the address of a location in memory.

MPI_Get_count(MPI_Status *status, MPI_Datatype datatype, int *count)

Gets the number of top-level elements received.

MPI_Get_elements(MPI_Status *status, MPI_Datatype datatype, int *count)

Returns the number of basic elements in a data type.

MPI_Get_processor_name(char *name, int *resultlen)

Gets the name of the processor.

MPI_Get_version(int *version, int *subversion)

Returns the version of the standard corresponding to the current implementation.

MPI_Graph_create(MPI_Comm comm_old, int nnodes, int *index, int *edges, int reorder, MPI_Comm *comm_graph)

Makes a new communicator to which graph topology information has been attached.

MPI_Graph_get(MPI_Comm comm, int maxindex, int maxedges, int *index, int *edges)

Retrieves graph topology information associated with a communicator.

MPI_Graph_map(MPI_Comm comm, int nnodes, int *index, int *edges, int *newrank)

Maps process to graph topology information.

MPI_Graph_neighbors(MPI_Comm comm, int rank, int maxneighbors, int *neighbors)

Returns the neighbors of a node associated with a graph topology.

MPI_Graph_neighbors_count(MPI_Comm comm, int rank, int *nneighbors)

Returns the number of neighbors of a node associated with a graph topology.

MPI_Graphdims_get(MPI_Comm comm, int *nnodes, int *nedges)

Retrieves graph topology information associated with a communicator.

MPI_Grequest_complete(MPI_Request request)

Reports that a generalized request is complete.

MPI_Grequest_start(

MPI_Grequest_query_function *query_fn, MPI_Grequest_free_function *free_fn, MPI_Grequest_cancel_function *cancel_fn, void *extra_state, MPI_Request *request)

Starts a generalized request and returns a handle to it.

MPI_Group_c2f(MPI_Group group)

Translates a C handle into a Fortran handle.

MPI_Group_compare(MPI_Group group1, MPI_Group group2, int *result)

Compares two groups.

MPI_Group_difference(MPI_Group group1, MPI_Group group2, MPI_Group *group_out)

Makes a group from the difference of two groups.

MPI_Group_excl(MPI_Group group, int n, int *ranks, MPI_Group *newgroup)

Produces a group by reordering an existing group and taking only unlisted members.

MPI_Group_f2c(MPI_Fint group)

Translates a Fortran handle into a C handle.

MPI_Group_free(MPI_Group *group)

Frees a group.

MPI_Group_incl(MPI_Group group, int n, int *ranks, MPI_Group *group_out)

Produces a group by reordering an existing group and taking only listed members.

MPI_Group_intersection(MPI_Group group1, MPI_Group group2, MPI_Group *group_out)

Produces a group at the intersection of two existing groups.

MPI_Group_range_excl(MPI_Group group, int n, int ranges[ ][3], MPI_Group *newgroup)

Produces a group by excluding ranges of processes from an existing group.

MPI_Group_range_incl(MPI_Group group, int n, int ranges[ ][3], MPI_Group *newgroup)

Creates a new group from ranges of ranks in an existing group.

MPI_Group_rank(MPI_Group group, int *rank)

Returns the rank of this process in the given group.

MPI_Group_size(MPI_Group group, int *size)

Returns the size of a group.

MPI_Group_translate_ranks(MPI_Group group1, int n, int *ranks1, MPI_Group group2, int *ranks2)

Translates the ranks of processes in one group to those in another group.

MPI_Group_union(MPI_Group group1, MPI_Group group2, MPI_Group *group_out)

Produces a group by combining two groups.

MPI_Ibsend(void *buf, int count, MPI_Datatype datatype, int dest, int tag, MPI_Comm comm, MPI_Request *request)

Starts a nonblocking buffered send.

MPI_Info_c2f(MPI_Info info)

Translates a C handle into a Fortran handle.

MPI_Info_create(MPI_Info *info)

Creates a new info object.

MPI_Info_delete(MPI_Info *info, char *key, char *value)

Deletes a key/value pair from info.

MPI_Info_dup(MPI_Info info, MPI_Info *newinfo)

Duplicates an info object.

MPI_Info_f2c(MPI_Fint info)

Translates a Fortran handle into a C handle.

MPI_Info_free(MPI_Info *info)

Frees info and sets it to MPI_INFO_NULL.

MPI_Info_get(MPI_Info *info, char *key, char *value)

Retrieves key value for an info object.

MPI_Info_get_nkeys(MPI_Info info, int *nkeys)

Returns the number of currently defined keys in info.

MPI_Info_get_nthkey(MPI_Info info, int n, char *key)

Returns the nth defined key in info.

MPI_Info_get_valuelen(MPI_Info info, char *key, int *valuelen, int *flag)

Retrieves the length of the key value associated with an info object.

MPI_Info_set(MPI_Info *info, char *key, char *value)

Adds a key/value pair to info.

MPI_Init(int *argc, char ***argv)

Initializes the MPI execution environment.

MPI_Initialized(int *flag)

Indicates whether MPI_Init() has been called.

MPI_Init_thread(int *argc, char ***argv, int required, int *provided)

Initializes the MPI execution environment with a predetermined level of thread support. Thread that calls this function becomes the main thread. Call instead of MPI_Init(), not in addition to.

MPI_Intercomm_create(MPI_Comm local_comm, int local_leader, MPI_Comm peer_comm, int remote_leader, int tag, MPI_Comm *newintercomm)

Creates an intercommunicator.

MPI_Intercomm_merge(MPI_Comm intercomm, int high, MPI_Comm *newintracomm

Creates an intracommunicator from an intercommunicator.

MPI_Iprobe(int source, int tag, MPI_Comm comm, int *flag, MPI_Status *status)

Nonblocking test for a message.

MPI_Irecv(void *buf, int count, MPI_Datatype datatype, int source, int tag, MPI_Comm comm, MPI_Request *request)

Begins a nonblocking receive.

MPI_Irsend(void *buf, int count, MPI_Datatype datatype, int dest, int tag, MPI_Comm comm, MPI_Request *request)

Begins a nonblocking ready send.

MPI_Isend(void *buf, int count, MPI_Datatype datatype, int dest, int tag, MPI_Comm comm, MPI_Request *request)

Begins a nonblocking send.

MPI_Issend(void *buf, int count, MPI_Datatype datatype, int dest, int tag, MPI_Comm comm, MPI_Request *request)

Begins a nonblocking synchronous send.

MPI_Is_thread_main(int *flag)

Called by a thread to determine whether it is the main thread. See MPI_Init_thread().

MPI_Keyval_create(MPI_Copy_function *copy_fn, MPI_Delete_function *delete_fn, int *keyval, void *extra_state)

Deprecated: Use instead MPI_Comm_create_keyval(). Generates a new attribute key.

MPI_Keyval_free(int *keyval)

Deprecated: Use instead MPI_Comm_free_keyval(). Frees attribute key for communicator cache attribute.

MPI_Lookup_name (char *service-name, MPI_Info info, char *port-name)

Retrieves the port name associated with a service-name published by MPI_Publish_name().

MPI_Op_c2f(MPI_Op op)

Translates a C handle into a Fortran handle.

MPI_Op_create(MPI_User_function *function, int commute, MPI_Op *op)

Creates a user-defined combination function handle.

MPI_Op_f2c(MPI_Fint op)

Translates a Fortran handle into a C handle.

MPI_Op_free(MPI_Op *op)

Frees a user-defined combination function handle.

MPI_Open_port(MPI_Info info, char *port_name)

Establishes a network address for a server to accept connections from clients.

MPI_Pack(void *inbuf, int incount, MPI_Datatype datatype, void *outbuf, int outsize, int *position, MPI_Comm comm)

Packs data of a given data type into contiguous memory.

MPI_Pack_external(char *datarep, void *inbuf, int incount, MPI_Datatype datatype, void *outbuf, MPI_Aint outsize, MPI_Aint *position)

Packs data into the external32 format, used to exchange data between MPI implementations, or when writing data to a file.

MPI_Pack_external_size(char *datarep int incount, MPI_Datatype datatype, MPI_Aint *size)

Returns the upper bound on the amount of space necessary to pack a message in the external32 format.

MPI_Pack_size(int incount, MPI_Datatype datatype, MPI_Comm comm, int *size)

Returns the upper bound on the amount of space necessary to pack a message.

MPI_Pcontrol(int level, ...)

Controls profiling.

MPI_Probe(int source, int tag, MPI_Comm comm, MPI_Status *status)

Blocking test for a message.

MPI_Publish_name (char *service-name, MPI_Info info, char *port-name)

Publishes the pair (service-name, port-name) so that applications can use MPI_Lookup_name() to find port-name.

MPI_Put(void *origin_addr, int origin_count, MPI_Datatype origin_datatype, int target_rank, MPI_Aint target_disp, int target_count, MPI_Datatype target_datatype, MPI_Win win)

Copies data from the origin memory to the target.

MPI_Query_thread(int *provided)

Returns the current level of thread support.

MPI_Recv(void *buf, int count, MPI_Datatype datatype, int source, int tag, MPI_Comm comm, MPI_Status *status)

Performs a standard receive.

MPI_Recv_init(void *buf, int count, MPI_Datatype datatype, int source, int tag, MPI_Comm comm, MPI_Request *request)

Builds a persistent receive request handle.

MPI_Reduce(void *sendbuf, void *recvbuf, int count, MPI_Datatype datatype, MPI_Op op, int root, MPI_Comm comm)

Reduces values on all processes to a single value.

MPI_Reduce_scatter(void *sendbuf, void *recvbuf, int *recvcounts, MPI_Datatype datatype, MPI_Op op, MPI_Comm comm)

Combines values and scatters the results.

MPI_Request_c2f(MPI_Request request)

Translates a C handle into a Fortran handle.

MPI_Request_f2c(MPI_Fint request)

Translates a Fortran handle into a C handle.

MPI_Request_free(MPI_Request *request)

Frees a communication request object.

MPI_Request_get_status(MPI_Request request, int *flag, MPI_Status *status)

Accesses information associated with a request without freeing the request.

MPI_Rsend(void *buf, int count, MPI_Datatype datatype, int dest, int tag, MPI_Comm comm)

Performs a ready send.

MPI_Rsend_init(void *buf, int count, MPI_Datatype datatype, int dest, int tag, MPI_Comm comm, MPI_Request *request)

Builds a persistent ready send request handle.

MPI_Scan(void *sendbuf, void *recvbuf, int count, MPI_Datatype datatype, MPI_Op op, MPI_Comm comm)

Computes the scan (partial reductions) of data on a collection of processes.

MPI_Scatter(void *sendbuf, int sendcount, MPI_Datatype sendtype, void *recvbuf, int recvcount, MPI_Datatype recvtype, int root, MPI_Comm comm)

Sends data from one job to all other processes in a group.

MPI_Scatterv(void *sendbuf, int *sendcounts, int *displs, MPI_Datatype sendtype, void *recvbuf, int recvcount, MPI_Datatype recvtype, int root, MPI_Comm comm)

Scatters a buffer in parts to all processes in a group.

MPI_Send(int *buf, int count, MPI_Datatype datatype, int dest, int tag, MPI_Comm comm)

Performs a standard send.

MPI_Send_init(void *buf, int count, MPI_Datatype datatype, int dest, int tag, MPI_Comm comm, MPI_Request *request)

Builds a persistent send request handle.

MPI_Sendrecv(void *sendbuf, int sendcount, MPI_Datatype sendtype, int dest, int sendtag, void *recvbuf, int recvcount, MPI_Datatype recvtype, int source, int recvtag, MPI_Comm comm, MPI_Status *status)

Sends and receives two messages at the same time.

MPI_Sendrecv_replace(void *buf, int count, MPI_Datatype datatype, int dest, int sendtag, int source, int recvtag, MPI_Comm comm, MPI_Status *status)

Sends and receives using a single buffer.

MPI_Size_of(x, size, ierror)

Fortran only. Returns the size, in bytes, of the datatype of variable x.

MPI_Ssend(void *buf, int count, MPI_Datatype datatype, int dest, int tag, MPI_Comm comm)

Performs a synchronous send.

MPI_Ssend_init(void *buf, int count, MPI_Datatype datatype, int dest, int tag, MPI_Comm comm, MPI_Request *request)

Builds a persistent synchronous send request handle.

MPI_Start(MPI_Request *request)

Initiates a communication using a persistent request handle.

MPI_Startall(int count, MPI_Request array_of_requests[ ])

Starts a collection of requests.

MPI_Status_c2f(MPI_Status *c_status, MPI_Fint *f_status)

Translates a C status into a Fortran status.

MPI_Status_f2c(MPI_Fint *f_status, MPI_Status *c_status)

Translates a Fortran status into a C status.

MPI_Status_set_cancelled(MPI_Status *status, int flag)

Sets status to indicate that a request has been cancelled.

MPI_Status_set_elements(MPI_Status *status, MPI_Datatype datatype, int count)

Modifies opaque part of status to enable MPI_Get_elements() to return count.

MPI_Test(MPI_Request *request, int *flag, MPI_Status *status)

Tests for the completion of a send or receive.

MPI_Test_cancelled(MPI_Status *status, int *flag)

Tests whether a request was canceled.

MPI_Testall(int count, MPI_Request array_of_requests, int *flag, MPI_Status *array_of_statuses)

Tests for the completion of all the given communications.

MPI_Testany(int count, MPI_Request array_of_requests[ ], int *index, int *flag, MPI_Status status)

Tests for completion of any of the given communications.

MPI_Testsome(int incount, MPI_Request array_of_requests[ ], int *outcount, int *array_of_indices, MPI_Status *array_of_statuses)

Tests for some given communications to complete.

MPI_Topo_test(MPI_Comm comm, int *top_type)

Determines the type of topology (if any) associated with a communicator.

MPI_Type_c2f(MPI_Datatype datatype)

Translates a C handle into a Fortran handle.

MPI_Type_commit(MPI_Datatype *datatype)

Commits a data type.

MPI_Type_contiguous(int count, MPI_Datatype oldtype, MPI_Datatype *newtype)

Creates a contiguous data type.

MPI_Type_create_darray(int size, int rank, int ndims, int array_of_gsizes[ ], int array_of_distribs[ ], int array_of_dargs[ ], int array_of_psizes[ ], int order, MPI_Datatype oldtype, MPI_Datatype *newtype)

Creates an array of data types.

MPI_Type_create_f90_complex(int p, int r, MPI_Datatype *newtype)

Returns a bounded MPI complex datatype.

MPI_Type_create_f90_integer(int r, MPI_Datatype *newtype)

Returns a bounded MPI integer datatype.

MPI_Type_create_f90_complex(int p, int r, MPI_Datatype *newtype)

Returns a bounded MPI real datatype.

MPI_Type_create_hindexed(int count, int array_of_blocklengths, MPI_Aint array_of_displacements[ ], MPI_Datatype oldtype, MPI_Datatype *newtype)

Creates an indexed data type with offsets in bytes.

MPI_Type_create_hvector(int count, int blocklength, MPI_Aint stride, MPI_Datatype oldtype, MPI_Datatype *newtype)

Creates a vector (strided) data type with offset in bytes.

MPI_Type_create_indexed_block(int count, int blocklength, int array_of_displacements[ ], MPI_Datatype oldtype, MPI_Datatype *newtype)

Creates an indexed block.

MPI_Type_create_keyval(

MPI_Type_copy_attr_function *type_copy_attr_fn, MPI_Type_delete_attr_function *type_delete_attr_fn, int *type_keyval, void *extra_state)

Generates a new attribute key.

MPI_Type_create_resized(MPI_Datatype oldtype, MPI_Aint lb, MPI_Aint extent, MPI_Datatype *newtype)

Returns a new data type with new extent and upper and lower bounds.

MPI_Type_create_struct(int count, int array_of_blocklengths[ ], MPI_Aint array_of_displacements[ ], MPI_Datatype array_of_types[ ], MPI_Datatype *newtype)

Creates a struct data type.

MPI_Type_create_subarray(int ndims, int array_of_sizes[ ], int array_of_subsizes[ ], int array_of_starts[ ], int order, MPI_Datatype oldtype, MPI_Datatype *newtype)

Creates a data type describing a subarray of an array.

MPI_Type_delete_attr(MPI_Datatype type, int type_keyval)

Deletes attribute value associated with a key.

MPI_Type_dup(MPI_Datatype type, MPI_Datatype *newtype)

Duplicates a data type with associated key values.

MPI_Type_extent(MPI_Datatype datatype, MPI_Aint *extent)

Deprecated: Use instead MPI_Type_get_extent(). Returns the extent of a data type, the difference between the upper and lower bounds of the data type.

MPI_Type_f2c(MPI_Fint datatype)

Translates a Fortran handle into a C handle.

MPI_Type_free(MPI_Datatype *datatype)

Frees a data type.

MPI_Type_free_keyval(int *type_keyval)

Frees an attribute key.

MPI_Type_get_attr(MPI_Datatype type, int type_keyval, void *attribute_val, int *flag)

Returns the attribute associated with a data type.

MPI_Type_get_contents(MPI_Datatype datatype, int max_integers, int max_addresses, int max_datatypes, int array_of_integers[ ], MPI_Aint array_of_addresses[ ], MPI_Datatype array_of_datatypes[ ])

Returns information about arguments used in creation of a data type.

MPI_Type_get_envelope(MPI_Datatype datatype, int *num_integers, int *num_addresses, int *num_datatypes, int *combiner)

Returns information about input arguments associated with a data type.

MPI_Type_get_extent(MPI_Datatype datatype, MPI_Aint *lb, MPI_Aint *extent)

Returns the lower bound and extent of a data type.

MPI_Type_get_name(MPI_Datatype type, char *type_name, int *resultlen)

Gets the name of a data type.

MPI_Type_get_true_extent(MPI_Datatype datatype, MPI_Aint *true_lb, MPI_Aint *true_extent)

Returns the true lower bound and extent of a data type's corresponding type map, ignoring MPI_UB and MPI_LB markers.

MPI_Type_hindexed(int count, int *array_of_blocklengths, MPI_Aint *array_of_displacements, MPI_Datatype oldtype, MPI_Datatype *newtype)

Deprecated: Use instead MPI_Type_create_hindexed(). Creates an indexed data type with offsets in bytes.

MPI_Type_hvector(int count, int blocklength, MPI_Aint stride, MPI_Datatype oldtype, MPI_Datatype *newtype)

Deprecated: Use instead MPI_Type_create_hvector(). Creates a vector (strided) data type with offset in bytes.

MPI_Type_indexed(int count, int *array_of_blocklengths, int *array_of_displacements, MPI_Datatype oldtype, MPI_Datatype *newtype)

Creates an indexed data type.

MPI_Type_lb(MPI_Datatype datatype, MPI_Aint *displacement)

Deprecated: Use instead MPI_Type_get_extent(). Returns the lower bound of a data type.

MPI_Type_match_size(int typeclass, int size, MPI_Datatype *type)

Returns an MPI data type of a given type and size.

MPI_Type_set_attr(MPI_Datatype type, int type_keyval, void *attribute_val)

Stores attribute value associated with a key.

MPI_Type_set_name(MPI_Comm comm, char *type_name)

Sets the name of a data type.

MPI_Type_size(MPI_Datatype datatype, int *size)

Returns the number of bytes occupied by entries in the data type.

MPI_Type_struct(int count, int *array_of_blocklengths, MPI_Aint *array_of_displacements, MPI_Datatype *array_of_types, MPI_Datatype *newtype)

Deprecated: Use instead MPI_Type_create_struct(). Creates a struct data type.

MPI_Type_ub(MPI_Datatype datatype, MPI_Aint *displacement)

Deprecated: Use instead MPI_Type_get_extent(). Returns the upper bound of a data type.

MPI_Type_vector(int count, int blocklength, int stride, MPI_Datatype oldtype, MPI_Datatype *newtype)

Creates a vector (strided) data type.

MPI_Unpack(void *inbuf, int insize, int *position, void *outbuf, int outcount, MPI_Datatype datatype, MPI_Comm comm)

Unpacks a data type into contiguous memory.

MPI_Unpack_external(void *inbuf, int insize, int *position, void *outbuf, int outcount, MPI_Datatype datatype, MPI_Comm comm)

Unpacks into contiguous memory a data type packed in the external32 format.

MPI_Unpublish_name (char *service-name, MPI_Info info, char *port-name)

Removes the pair (service-name, port-name) published by MPI_Publish_name(), so that applications can no longer use MPI_Lookup_name() to find port-name.

MPI_Wait(MPI_Request *request, MPI_Status *status)

Waits for an MPI send or receive to complete.

MPI_Waitall(int count, MPI_Request array_of_requests[ ], MPI_Status array_of_statuses[ ])

Waits for all of the given communications to complete.

MPI_Waitany(int count, MPI_Request array_of_requests[ ], int *index, MPI_Status *status)

Waits for any of the given communications to complete.

MPI_Waitsome(int incount, MPI_Request array_of_requests[ ], int *outcount, int array_of_indices[ ], MPI_Status array_of_statuses[ ])

Waits for some given communications to complete.

MPI_Win_c2f(MPI_Win win)

Translates a C handle into a Fortran handle.

MPI_Win_create(void *base, MPI_Aint size, int disp_unit, MPI_Info info, MPI_Comm comm, MPI_Win *win)

Opens a communication window in memory.

MPI_Win_create_errhandler(MPI_Win_
errhandler_fn *function, MPI_Errhandler *errhandler)

Creates an error handler that can be attached to windows.

MPI_Win_create_keyval(MPI_Win_copy_attr_
function *win_copy_attr_fn, MPI_Win_delete_attr_function *win_delete_attr_fn, int *win_keyval, void *extra_state)

Creates a caching attribute that can be associated with a window.

MPI_Win_delete_attr(MPI_Win win, int win_keyval)

Deletes the attribute created with MPI_Win_create_keyval.

MPI_Win_f2c(MPI_Fint win)

Translates a Fortran handle into a C handle.

MPI_Win_fence(int assert, MPI_Win win)

Synchronizes RMA calls on a window.

MPI_Win_free(MPI_Win *win)

Frees the window object and returns a null handle.

MPI_Win_free_keyval(int *win_keyval)

Releases a window attribute.

MPI_Win_get_attr(MPI_Win win, int win_keyval, void *attribute_val, int *flag)

Obtains the value of a window attribute.

MPI_Win_get_errhandler(MPI_Win win, MPI_Errhandler *errhandler)

Retrieves the error handler currently associated with a window.

MPI_Win_get_group(MPI_Win win, MPI_Group *group)

Returns a duplicate of the group of the communicator used to create the window.

MPI_Win_get_name(MPI_Win win, char *win_name, int *resultlen)

Returns the last name associated with a window object.

MPI_Win_lock(int lock_type, int rank, int assert, MPI_Win win)

Starts an RMA access epoch, during which only the window at the process with the specified rank can be accessed.

MPI_Win_post(MPI_Group group, int assert, MPI_Win win)

Starts an RMA exposure epoch for the local window associated with win.

MPI_Win_set_attr(MPI_Win win, int win_keyval, void *attribute_val)

Associates an attribute with a window.

MPI_Win_test(MPI_Win win, int *flag)

Attempts to complete an RMA exposure epoch; a nonblocking version of MPI_Win_wait.

MPI_Win_set_errhandler(MPI_Win win, MPI_Errhandler errhandler)

Attaches a new error handler to a window.

MPI_Win_set_name(MPI_Win win, char *win_name)

Assigns a name to a window.

MPI_Win_start(MPI_Group group, int assert, MPI_Win win)

Starts an RMA access epoch for win.

MPI_Win_unlock(int rank, MPI_Win win)

Completes an RMA access epoch started by a call to MPI_Win_lock().

double MPI_Wtick( )

Returns the resolution of MPI_Wtime().

double MPI_Wtime( )

Returns an elapsed time on the calling processor.