tools/pldt/org.eclipse.ptp.pldt.mpi.core/mpiref.xml

<?xml version="1.0"?>
<allFunctions>
<function>
<cname>MPI_Abort</cname>
<cppname>MPI::Comm::Abort</cppname>
<fname>MPI_ABORT</fname>
<namespace></namespace>
<description>Forces all tasks of an MPI job to terminate.</description>
<prototype>
<returnType>int</returnType>
<name>MPI_Abort</name>
<arguments>MPI_Comm, int</arguments>
</prototype>
</function>

<function>
<cname>MPI_Accumulate</cname>
<cppname>MPI::Win::Accumulate</cppname>
<fname>MPI_ACCUMULATE</fname>
<namespace></namespace>
<description>Accumulates, according to the specified reduction operation, the contents of the origin buffer to the specified target buffer.</description>
<prototype>
<returnType>int</returnType>
<name>MPI_Accumulate</name>
<arguments>void *, int, MPI_Datatype, int, MPI_Aint, int, MPI_Datatype,  MPI_Op, MPI_Win</arguments>
</prototype>
</function>

<function>
<cname>MPI_Add_error_class</cname>
<cppname>MPI::Add_error_class</cppname>
<fname>MPI_ADD_ERROR_CLASS</fname>
<namespace></namespace>
<description>Creates a new error class and returns the value for it.</description>
<prototype>
<returnType>int</returnType>
<name>MPI_Add_error_class</name>
<arguments>int *</arguments>
</prototype>
</function>

<function>
<cname>MPI_Add_error_code</cname>
<cppname>MPI::Add_error_code</cppname>
<fname>MPI_ADD_ERROR_CODE</fname>
<namespace></namespace>
<description>Creates a new error code and returns the value for it.</description>
<prototype>
<returnType>int</returnType>
<name>MPI_Add_error_code</name>
<arguments>int, int *</arguments>
</prototype>
</function>

<function>
<cname>MPI_Add_error_string</cname>
<cppname>MPI::Add_error_string</cppname>
<fname>MPI_ADD_ERROR_STRING</fname>
<namespace></namespace>
<description>Associates an error string with an error code or class.</description>
<prototype>
<returnType>int</returnType>
<name>MPI_Add_error_string</name>
<arguments>int, char *</arguments>
</prototype>
</function>

<function>
<cname>MPI_Address</cname>
<cppname>(none)</cppname>
<fname>MPI_ADDRESS</fname>
<namespace></namespace>
<description>Returns the address of a location in memory.</description>
<prototype>
<returnType>int</returnType>
<name>MPI_Address</name>
<arguments>void*, MPI_Aint *</arguments>
</prototype>
</function>

<function>
<cname>MPI_Allgather</cname>
<cppname>MPI::Comm::Allgather</cppname>
<fname>MPI_ALLGATHER</fname>
<namespace></namespace>
<description>Collects messages from each task and distributes the resulting message to each.</description>
<prototype>
<returnType>int</returnType>
<name>MPI_Allgather</name>
<arguments>void* , int, MPI_Datatype, void*, int, MPI_Datatype, MPI_Comm</arguments>
</prototype>
</function>

<function>
<cname>MPI_Allgatherv</cname>
<cppname>MPI::Comm::Allgatherv</cppname>
<fname>MPI_ALLGATHERV</fname>
<namespace></namespace>
<description>Collects messages from each task and distributes the resulting message to all tasks. Messages can have variable sizes and displacements.</description>
<prototype>
<returnType>int</returnType>
<name>MPI_Allgatherv</name>
<arguments>void* , int, MPI_Datatype, void*, int *, int *, MPI_Datatype, MPI_Comm</arguments>
</prototype>
</function>

<function>
<cname>MPI_Alloc_mem</cname>
<cppname>MPI::Alloc_mem</cppname>
<fname>MPI_ALLOC_MEM</fname>
<namespace></namespace>
<description>Allocates storage and returns a pointer to it.</description>
<prototype>
<returnType>int</returnType>
<name>MPI_Alloc_mem</name>
<arguments>MPI_Aint, MPI_Info info, void *baseptr</arguments>
</prototype>
</function>

<function>
<cname>MPI_Allreduce</cname>
<cppname>MPI::Comm::Allreduce</cppname>
<fname>MPI_ALLREDUCE</fname>
<namespace></namespace>
<description>Applies a reduction operation.</description>
<prototype>
<returnType>int</returnType>
<name>MPI_Allreduce</name>
<arguments>void* , void*, int, MPI_Datatype, MPI_Op, MPI_Comm</arguments>
</prototype>
</function>

<function>
<cname>MPI_Alltoall</cname>
<cppname>MPI::Comm::Alltoall</cppname>
<fname>MPI_ALLTOALL</fname>
<namespace></namespace>
<description>Sends a distinct message from each task to every task.</description>
<prototype>
<returnType>int</returnType>
<name>MPI_Alltoall</name>
<arguments>void* , int, MPI_Datatype, void*, int, MPI_Datatype, MPI_Comm</arguments>
</prototype>
</function>

<function>
<cname>MPI_Alltoallv</cname>
<cppname>MPI::Comm::Alltoallv</cppname>
<fname>MPI_ALLTOALLV</fname>
<namespace></namespace>
<description>Sends a distinct message from each task to every task. Messages can have different sizes and displacements.</description>
<prototype>
<returnType>int</returnType>
<name>MPI_Alltoallv</name>
<arguments>void* , int *, int *, MPI_Datatype, void*, int *, int *, MPI_Datatype, MPI_Comm</arguments>
</prototype>
</function>

<function>
<cname>MPI_Alltoallw</cname>
<cppname>MPI::Comm::Alltoallw</cppname>
<fname>MPI_ALLTOALLW</fname>
<namespace></namespace>
<description>Sends a distinct message from each task to every task. Messages can have different datatypes, sizes, and displacements.</description>
<prototype>
<returnType>int</returnType>
<name>MPI_Alltoallw</name>
<arguments>void *, int [], int [], MPI_Datatype [], void *, int [], int [], MPI_Datatype [], MPI_Comm</arguments>
</prototype>
</function>

<function>
<cname>MPI_Attr_delete</cname>
<cppname>(none)</cppname>
<fname>MPI_ATTR_DELETE</fname>
<namespace></namespace>
<description>Removes an attribute value from a communicator.</description>
<prototype>
<returnType>int</returnType>
<name>MPI_Attr_delete</name>
<arguments>MPI_Comm, int</arguments>
</prototype>
</function>

<function>
<cname>MPI_Attr_get</cname>
<cppname>(none)</cppname>
<fname>MPI_ATTR_GET</fname>
<namespace></namespace>
<description>Retrieves an attribute value from a communicator.</description>
<prototype>
<returnType>int</returnType>
<name>MPI_Attr_get</name>
<arguments>MPI_Comm, int, void *, int *</arguments>
</prototype>
</function>

<function>
<cname>MPI_Attr_put</cname>
<cppname>(none)</cppname>
<fname>MPI_ATTR_PUT</fname>
<namespace></namespace>
<description>Associates an attribute value with a communicator.</description>
<prototype>
<returnType>int</returnType>
<name>MPI_Attr_put</name>
<arguments>MPI_Comm, int, void*</arguments>
</prototype>
</function>

<function>
<cname>MPI_Barrier</cname>
<cppname>MPI::Comm::Barrier</cppname>
<fname>MPI_BARRIER</fname>
<namespace></namespace>
<description>Blocks each task until all tasks have called it.</description>
<prototype>
<returnType>int</returnType>
<name>MPI_Barrier</name>
<arguments>MPI_Comm </arguments>
</prototype>
</function>

<function>
<cname>MPI_Bcast</cname>
<cppname>MPI::Comm::Bcast</cppname>
<fname>MPI_BCAST</fname>
<namespace></namespace>
<description>Broadcasts a message from root to all tasks in the group.</description>
<prototype>
<returnType>int</returnType>
<name>MPI_Bcast</name>
<arguments>void*, int, MPI_Datatype, int, MPI_Comm </arguments>
</prototype>
</function>

<function>
<cname>MPI_Bsend</cname>
<cppname>MPI::Comm::Bsend</cppname>
<fname>MPI_BSEND</fname>
<namespace></namespace>
<description>Performs a blocking buffered mode send operation.</description>
<prototype>
<returnType>int</returnType>
<name>MPI_Bsend</name>
<arguments>void*, int, MPI_Datatype, int, int, MPI_Comm</arguments>
</prototype>
</function>

<function>
<cname>MPI_Bsend_init</cname>
<cppname>MPI::Comm::Bsend_init</cppname>
<fname>MPI_BSEND_INIT</fname>
<namespace></namespace>
<description>Creates a persistent buffered mode send request.</description>
<prototype>
<returnType>int</returnType>
<name>MPI_Bsend_init</name>
<arguments>void*, int, MPI_Datatype, int,int, MPI_Comm, MPI_Request *</arguments>
</prototype>
</function>

<function>
<cname>MPI_Buffer_attach</cname>
<cppname>MPI::Attach_buffer</cppname>
<fname>MPI_BUFFER_ATTACH</fname>
<namespace></namespace>
<description>Provides MPI with a message buffer for sending.</description>
<prototype>
<returnType>int</returnType>
<name>MPI_Buffer_attach</name>
<arguments> void*, int</arguments>
</prototype>
</function>

<function>
<cname>MPI_Buffer_detach</cname>
<cppname>MPI::Detach_buffer</cppname>
<fname>MPI_BUFFER_DETACH</fname>
<namespace></namespace>
<description>Detaches the current buffer.</description>
<prototype>
<returnType>int</returnType>
<name>MPI_Buffer_detach</name>
<arguments> void*, int *</arguments>
</prototype>
</function>

<function>
<cname>MPI_Cancel</cname>
<cppname>MPI::Request::Cancel</cppname>
<fname>MPI_CANCEL</fname>
<namespace></namespace>
<description>Marks a non-blocking operation for cancellation.</description>
<prototype>
<returnType>int</returnType>
<name>MPI_Cancel</name>
<arguments>MPI_Request *</arguments>
</prototype>
</function>

<function>
<cname>MPI_Cart_coords</cname>
<cppname>MPI::Cartcomm::Get_coords</cppname>
<fname>MPI_CART_COORDS</fname>
<namespace></namespace>
<description>Translates task rank in a communicator into Cartesian task coordinates.</description>
<prototype>
<returnType>int</returnType>
<name>MPI_Cart_coords</name>
<arguments>MPI_Comm, int, int, int *</arguments>
</prototype>
</function>

<function>
<cname>MPI_Cart_create</cname>
<cppname>MPI::Intracomm::Create_cart</cppname>
<fname>MPI_CART_CREATE</fname>
<namespace></namespace>
<description>Creates a communicator containing topology information.</description>
<prototype>
<returnType>int</returnType>
<name>MPI_Cart_create</name>
<arguments>MPI_Comm, int, int *, int *, int, MPI_Comm *</arguments>
</prototype>
</function>

<function>
<cname>MPI_Cart_get</cname>
<cppname>MPI::Cartcomm::Get_topo</cppname>
<fname>MPI_CART_GET</fname>
<namespace></namespace>
<description>Retrieves Cartesian topology information from a communicator.</description>
<prototype>
<returnType>int</returnType>
<name>MPI_Cart_get</name>
<arguments>MPI_Comm, int, int *, int *, int *</arguments>
</prototype>
</function>

<function>
<cname>MPI_Cart_map</cname>
<cppname>MPI::Cartcomm::Map</cppname>
<fname>MPI_CART_MAP</fname>
<namespace></namespace>
<description>Computes placement of tasks on the physical processor.</description>
<prototype>
<returnType>int</returnType>
<name>MPI_Cart_map</name>
<arguments>MPI_Comm, int, int *, int *, int *</arguments>
</prototype>
</function>

<function>
<cname>MPI_Cart_rank</cname>
<cppname>MPI::Cartcomm::Get_cart_rank</cppname>
<fname>MPI_CART_RANK</fname>
<namespace></namespace>
<description>Translates task coordinates into a task rank.</description>
<prototype>
<returnType>int</returnType>
<name>MPI_Cart_rank</name>
<arguments>MPI_Comm, int *, int *</arguments>
</prototype>
</function>

<function>
<cname>MPI_Cart_shift</cname>
<cppname>MPI::Cartcomm::Shift</cppname>
<fname>MPI_CART_SHIFT</fname>
<namespace></namespace>
<description>Returns shifted source and destination ranks for a task.</description>
<prototype>
<returnType>int</returnType>
<name>MPI_Cart_shift</name>
<arguments>MPI_Comm, int, int, int *, int *</arguments>
</prototype>
</function>

<function>
<cname>MPI_Cart_sub</cname>
<cppname>MPI::Cartcomm::Sub</cppname>
<fname>MPI_CART_SUB</fname>
<namespace></namespace>
<description>Partitions a Cartesian communicator into lower-dimensional subgroups.</description>
<prototype>
<returnType>int</returnType>
<name>MPI_Cart_sub</name>
<arguments>MPI_Comm, int *, MPI_Comm *</arguments>
</prototype>
</function>

<function>
<cname>MPI_Cartdim_get</cname>
<cppname>MPI::Cartcomm::Get_dim</cppname>
<fname>MPI_CARTDIM_GET</fname>
<namespace></namespace>
<description>Retrieves the number of Cartesian dimensions from a communicator.</description>
<prototype>
<returnType>int</returnType>
<name>MPI_Cartdim_get</name>
<arguments>MPI_Comm, int *</arguments>
</prototype>
</function>

<function>
<cname>MPI_Close_port</cname>
<cppname>MPI::Close_port</cppname>
<fname>MPI_CLOSE_PORT</fname>
<namespace></namespace>
<description>Releases the specified network address.</description>
<prototype>
<returnType>int</returnType>
<name>MPI_Close_port</name>
<arguments>char *</arguments>
</prototype>
</function>

<function>
<cname>MPI_Comm_accept</cname>
<cppname>MPI::Intracomm::Accept</cppname>
<fname>MPI_COMM_ACCEPT</fname>
<namespace></namespace>
<description>Establishes communication with a client.</description>
<prototype>
<returnType>int</returnType>
<name>MPI_Comm_accept</name>
<arguments>char *, MPI_Info, int, MPI_Comm, MPI_Comm *</arguments>
</prototype>
</function>

<function>
<cname>MPI_Comm_connect</cname>
<cppname>MPI::Intracomm::Connect</cppname>
<fname>MPI_COMM_CONNECT</fname>
<namespace></namespace>
<description>Establishes communication with a server.</description>
<prototype>
<returnType>int</returnType>
<name>MPI_Comm_connect</name>
<arguments>char *, MPI_Info, int, MPI_Comm, MPI_Comm *</arguments>
</prototype>
</function>

<function>
<cname>MPI_Comm_c2f</cname>
<cppname>(none)</cppname>
<fname>(none)</fname>
<namespace></namespace>
<description>Translates a C communicator handle into a FORTRAN handle to the same communicator.</description>
<prototype>
<returnType>MPI_Fint</returnType>
<name>MPI_Comm_c2f</name>
<arguments>MPI_Comm</arguments>
</prototype>
</function>

<function>
<cname>MPI_Comm_call_errhandler</cname>
<cppname>MPI::Comm::Call_errhandler</cppname>
<fname>MPI_COMM_CALL_ERRHANDLER</fname>
<namespace></namespace>
<description>Calls the error handler assigned to the communicator with the error code supplied.</description>
<prototype>
<returnType>int</returnType>
<name>MPI_Comm_call_errhandler</name>
<arguments>MPI_Comm, int</arguments>
</prototype>
</function>

<function>
<cname>MPI_Comm_compare</cname>
<cppname>MPI::Comm::Compare</cppname>
<fname>MPI_COMM_COMPARE</fname>
<namespace></namespace>
<description>Compares the groups and contexts of two communicators.</description>
<prototype>
<returnType>int</returnType>
<name>MPI_Comm_compare</name>
<arguments>MPI_Comm, MPI_Comm, int *</arguments>
</prototype>
</function>

<function>
<cname>MPI_Comm_create</cname>
<cppname>MPI::Intercomm::Create,</cppname>
<fname>MPI::Intracomm::Create</fname>
<namespace></namespace>
<description>Creates a new communicator with a given group.</description>
<prototype>
<returnType>int</returnType>
<name>MPI_Comm_create</name>
<arguments>MPI_Comm, MPI_Group, MPI_Comm *</arguments>
</prototype>
</function>

<function>
<cname>MPI_Comm_create_errhandler</cname>
<cppname>MPI::Comm::Create_errhandler</cppname>
<fname>MPI_COMM_CREATE_ERRHANDLER</fname>
<namespace></namespace>
<description>Creates an error handler that can be attached to communicators.</description>
<prototype>
<returnType>int</returnType>
<name>MPI_Comm_create_errhandler</name>
<arguments>MPI_Comm_errhandler_fn *, MPI_Errhandler *</arguments>
</prototype>
</function>

<function>
<cname>MPI_Comm_create_keyval</cname>
<cppname>MPI::Comm::Create_keyval</cppname>
<fname>MPI_COMM_CREATE_KEYVAL</fname>
<namespace></namespace>
<description>Generates a new communicator attribute key.</description>
<prototype>
<returnType>int</returnType>
<name>MPI_Comm_create_keyval</name>
<arguments>MPI_Comm_copy_attr_function *, MPI_Comm_delete_attr_function *, int *, void *</arguments>
</prototype>
</function>

<function>
<cname>MPI_Comm_delete_attr</cname>
<cppname>MPI::Comm::Delete_attr</cppname>
<fname>MPI_COMM_DELETE_ATTR</fname>
<namespace></namespace>
<description>Removes an attribute value from a communicator.</description>
<prototype>
<returnType>int</returnType>
<name>MPI_Comm_delete_attr</name>
<arguments>MPI_Comm, int</arguments>
</prototype>
</function>

<function>
<cname>MPI_Comm_disconnect</cname>
<cppname>MPI::Comm::Disconnect</cppname>
<fname>MPI_COMM_DISCONNECT</fname>
<namespace></namespace>
<description>Deallocates communicator object and sets handle to MPI_COMM_NULL.</description>
<prototype>
<returnType>int</returnType>
<name>MPI_Comm_disconnect</name>
<arguments>MPI_Comm *</arguments>
</prototype>
</function>

<function>
<cname>MPI_Comm_dup</cname>
<cppname>MPI::Cartcomm::Dup,</cppname>
<fname>MPI::Graphcomm::Dup,</fname>
<namespace></namespace>
<description>Creates a new communicator that is a duplicate of an existing communicator.</description>
<prototype>
<returnType>int</returnType>
<name>MPI_Comm_dup</name>
<arguments>MPI_Comm, MPI_Comm *</arguments>
</prototype>
</function>

<function>
<cname>MPI_Comm_f2c</cname>
<cppname>(none)</cppname>
<fname>(none)</fname>
<namespace></namespace>
<description>Returns a C handle to a communicator.</description>
<prototype>
<returnType>MPI_Comm</returnType>
<name>MPI_Comm_f2c</name>
<arguments>MPI_Fint</arguments>
</prototype>
</function>

<function>
<cname>MPI_Comm_free</cname>
<cppname>MPI::Comm::Free</cppname>
<fname>MPI_COMM_FREE</fname>
<namespace></namespace>
<description>Marks a communicator for deallocation.</description>
<prototype>
<returnType>int</returnType>
<name>MPI_Comm_free</name>
<arguments>MPI_Comm *</arguments>
</prototype>
</function>

<function>
<cname>MPI_Comm_free_keyval</cname>
<cppname>MPI::Comm::Free_keyval</cppname>
<fname>MPI_COMM_FREE_KEYVAL</fname>
<namespace></namespace>
<description>Marks a communicator attribute key for deallocation.</description>
<prototype>
<returnType>int</returnType>
<name>MPI_Comm_free_keyval</name>
<arguments>int *</arguments>
</prototype>
</function>

<function>
<cname>MPI_Comm_get_attr</cname>
<cppname>MPI::Comm::Get_attr</cppname>
<fname>MPI_COMM_GET_ATTR</fname>
<namespace></namespace>
<description>Retrieves the communicator attribute value identified by the key.</description>
<prototype>
<returnType>int</returnType>
<name>MPI_Comm_get_attr</name>
<arguments>MPI_Comm, int, void *, int *</arguments>
</prototype>
</function>

<function>
<cname>MPI_Comm_get_errhandler</cname>
<cppname>MPI::Comm::Get_errhandler</cppname>
<fname>MPI_COMM_GET_ERRHANDLER</fname>
<namespace></namespace>
<description>Retrieves the error handler currently associated with a communicator.</description>
<prototype>
<returnType>int</returnType>
<name>MPI_Comm_get_errhandler</name>
<arguments>MPI_Comm, MPI_Errhandler *</arguments>
</prototype>
</function>

<function>
<cname>MPI_Comm_get_name</cname>
<cppname>MPI::Comm::Get_name</cppname>
<fname>MPI_COMM_GET_NAME</fname>
<namespace></namespace>
<description>Returns the name that was last associated with a communicator.</description>
<prototype>
<returnType>int</returnType>
<name>MPI_Comm_get_name</name>
<arguments>MPI_Comm, char *, int *</arguments>
</prototype>
</function>

<function>
<cname>MPI_Comm_get_parent</cname>
<cppname>MPI::Comm::Get_parent</cppname>
<fname>MPI_COMM_GET_PARENT</fname>
<namespace></namespace>
<description>Returns the parent intercommunicator of current spawned process.</description>
<prototype>
<returnType>int</returnType>
<name>MPI_Comm_get_parent</name>
<arguments>MPI_Comm *</arguments>
</prototype>
</function>

<function>
<cname>MPI_Comm_group</cname>
<cppname>MPI::Comm::Get_group</cppname>
<fname>MPI_COMM_GROUP</fname>
<namespace></namespace>
<description>Returns the group handle associated with a communicator.</description>
<prototype>
<returnType>int</returnType>
<name>MPI_Comm_group</name>
<arguments>MPI_Comm, MPI_Group *</arguments>
</prototype>
</function>

<function>
<cname>MPI_Comm_join</cname>
<cppname>MPI::Comm::Join</cppname>
<fname>MPI_COMM_JOIN</fname>
<namespace></namespace>
<description>Establishes communication between MPI jobs.</description>
<prototype>
<returnType>int</returnType>
<name>MPI_Comm_join</name>
<arguments>int, MPI_Comm *</arguments>
</prototype>
</function>

<function>
<cname>MPI_Comm_rank</cname>
<cppname>MPI::Comm::Get_rank</cppname>
<fname>MPI_COMM_RANK</fname>
<namespace></namespace>
<description>Returns the rank of the local task in the group associated with a communicator.</description>
<prototype>
<returnType>int</returnType>
<name>MPI_Comm_rank</name>
<arguments>MPI_Comm, int *</arguments>
</prototype>
</function>

<function>
<cname>MPI_Comm_remote_group</cname>
<cppname>MPI::Intercomm::Get_remote_group</cppname>
<fname>MPI_COMM_REMOTE_GROUP</fname>
<namespace></namespace>
<description>Returns the handle of the remote group of an inter-communicator.</description>
<prototype>
<returnType>int</returnType>
<name>MPI_Comm_remote_group</name>
<arguments>MPI_Comm, MPI_Group *</arguments>
</prototype>
</function>

<function>
<cname>MPI_Comm_remote_size</cname>
<cppname>MPI::Intercomm::Get_remote_size</cppname>
<fname>MPI_COMM_REMOTE_SIZE</fname>
<namespace></namespace>
<description>Returns the size of the remote group of an inter-communicator.</description>
<prototype>
<returnType>int</returnType>
<name>MPI_Comm_remote_size</name>
<arguments>MPI_Comm, int *</arguments>
</prototype>
</function>

<function>
<cname>MPI_Comm_set_attr</cname>
<cppname>MPI::Comm::Set_attr</cppname>
<fname>MPI_COMM_SET_ATTR</fname>
<namespace></namespace>
<description>Attaches the communicator attribute value to the communicator and associates it with the key.</description>
<prototype>
<returnType>int</returnType>
<name>MPI_Comm_set_attr</name>
<arguments>MPI_Comm, int, void *</arguments>
</prototype>
</function>

<function>
<cname>MPI_Comm_set_errhandler</cname>
<cppname>MPI::Comm::Set_errhandler</cppname>
<fname>MPI_COMM_SET_ERRHANDLER</fname>
<namespace></namespace>
<description>Attaches a new error handler to a communicator.</description>
<prototype>
<returnType>int</returnType>
<name>MPI_Comm_set_errhandler</name>
<arguments>MPI_Comm, MPI_Errhandler</arguments>
</prototype>
</function>

<function>
<cname>MPI_Comm_set_name</cname>
<cppname>MPI::Comm::Set_name</cppname>
<fname>MPI_COMM_SET_NAME</fname>
<namespace></namespace>
<description>Associates a name string with a communicator.</description>
<prototype>
<returnType>int</returnType>
<name>MPI_Comm_set_name</name>
<arguments>MPI_Comm, char *</arguments>
</prototype>
</function>

<function>
<cname>MPI_Comm_size</cname>
<cppname>MPI::Comm::Get_size</cppname>
<fname>MPI_COMM_SIZE</fname>
<namespace></namespace>
<description>Returns the size of the group associated with a communicator.</description>
<prototype>
<returnType>int</returnType>
<name>MPI_Comm_size</name>
<arguments>MPI_Comm, int *</arguments>
</prototype>
</function>

<function>
<cname>MPI_Comm_spawn</cname>
<cppname>MPI::Intracomm::Spawn,</cppname>
<fname>MPI_COMM_SPAWN</fname>
<namespace></namespace>
<description>Spawns a number of identical binaries.</description>
<prototype>
<returnType>int</returnType>
<name>MPI_Comm_spawn</name>
<arguments>char *, char **, int, MPI_Info, int, MPI_Comm, MPI_Comm *, int[]</arguments>
</prototype>
</function>

<function>
<cname>MPI_Comm_spawn_multiple</cname>
<cppname>MPI::Intracomm::Spawn_multiple</cppname>
<fname>MPI_COMM_SPAWN_MULTIPLE</fname>
<namespace></namespace>
<description>Spawns multiple binaries, or the same binary with multiple sets of arguments.</description>
<prototype>
<returnType>int</returnType>
<name>MPI_Comm_spawn_multiple</name>
<arguments>int, char *[], char **[], int[], MPI_Info[], int, MPI_Comm, MPI_Comm *, int[]</arguments>
</prototype>
</function>

<function>
<cname>MPI_Comm_split</cname>
<cppname>MPI::Intercomm::Split,</cppname>
<fname>MPI_COMM_SPLIT</fname>
<namespace></namespace>
<description>Splits a communicator into multiple communicators based on color and key.</description>
<prototype>
<returnType>int</returnType>
<name>MPI_Comm_split</name>
<arguments>MPI_Comm, int, int, MPI_Comm *</arguments>
</prototype>
</function>

<function>
<cname>MPI_Comm_test_inter</cname>
<cppname>MPI::Comm::Is_inter</cppname>
<fname>MPI_COMM_TEST_INTER</fname>
<namespace></namespace>
<description>Returns the type of a communicator (intra-communicator or inter-communicator).</description>
<prototype>
<returnType>int</returnType>
<name>MPI_Comm_test_inter</name>
<arguments>MPI_Comm, int *</arguments>
</prototype>
</function>

<function>
<cname>MPI_Dims_create</cname>
<cppname>MPI::Compute_dims</cppname>
<fname>MPI_DIMS_CREATE</fname>
<namespace></namespace>
<description>Defines a Cartesian grid to balance tasks.</description>
<prototype>
<returnType>int</returnType>
<name>MPI_Dims_create</name>
<arguments>int, int, int *</arguments>
</prototype>
</function>

<function>
<cname>MPI_Dist_graph_create</cname>
<cppname>MPI::Intracomm::Dist_graph_create</cppname>
<fname>MPI_DIST_GRAPH_CREATE</fname>
<namespace></namespace>
<description>Makes a new communicator to which distributed graph topology information has been attached.</description>
<prototype>
<returnType>int</returnType>
<name>MPI_Dist_graph_create</name>
<arguments>MPI_Comm, int, int[], int[], int[], int[], MPI_Info, int, MPI_Comm *</arguments>
</prototype>
</function>

<function>
<cname>MPI_Dist_graph_create_adjacent</cname>
<cppname>MPI::Intracomm::Dist_graph_create_adjacent</cppname>
<fname>MPI_DIST_GRAPH_CREATE_ADJACENT</fname>
<namespace></namespace>
<description>Makes a new communicator to which distributed graph topology information has been attached.</description>
<prototype>
<returnType>int</returnType>
<name>MPI_Dist_graph_create_adjacent</name>
<arguments>MPI_Comm, int, int[], int[], int, int[], int[], MPI_Info, int, MPI_Comm *</arguments>
</prototype>
</function>

<function>
<cname>MPI_Dist_graph_neighbors</cname>
<cppname>MPI::Distgraphcomm::Get_dist_neighbors</cppname>
<fname>MPI_DIST_GRAPH_NEIGHBORS</fname>
<namespace></namespace>
<description>Provides information about adjacency in a distributed graph topology.</description>
<prototype>
<returnType>int</returnType>
<name>MPI_Dist_graph_neighbors</name>
<arguments>MPI_Comm, int, int[], int[], int, int[], int[]</arguments>
</prototype>
</function>

<function>
<cname>MPI_Dist_graph_neighbors_count</cname>
<cppname>MPI::Distgraphcomm::Get_dist_neighbors_count</cppname>
<fname>MPI_DIST_GRAPH_NEIGHBORS_COUNT</fname>
<namespace></namespace>
<description>Provides information about adjacency in a distributed graph topology.</description>
<prototype>
<returnType>int</returnType>
<name>MPI_Dist_graph_neighbors_count</name>
<arguments>MPI_Comm, int *, int *, int *</arguments>
</prototype>
</function>

<function>
<cname>MPI_Errhandler_c2f</cname>
<cppname>(none)</cppname>
<fname>(none)</fname>
<namespace></namespace>
<description>Translates a C error handler into a FORTRAN error handler.</description>
<prototype>
<returnType>MPI_Fint</returnType>
<name>MPI_Errhandler_c2f</name>
<arguments>MPI_Errhandler</arguments>
</prototype>
</function>

<function>
<cname>MPI_Errhandler_create</cname>
<cppname>(none)</cppname>
<fname>MPI_ERRHANDLER_CREATE</fname>
<namespace></namespace>
<description>Registers a user-defined error handler.</description>
<prototype>
<returnType>int</returnType>
<name>MPI_Errhandler_create</name>
<arguments>MPI_Handler_function *, MPI_Errhandler *</arguments>
</prototype>
</function>

<function>
<cname>MPI_Errhandler_f2c</cname>
<cppname>(none)</cppname>
<fname>(none)</fname>
<namespace></namespace>
<description>Translates a FORTRAN error handler into a C error handler.</description>
<prototype>
<returnType>MPI_Errhandler</returnType>
<name>MPI_Errhandler_f2c</name>
<arguments>MPI_Fint</arguments>
</prototype>
</function>

<function>
<cname>MPI_Errhandler_free</cname>
<cppname>MPI::Errhandler::Free</cppname>
<fname>MPI_ERRHANDLER_FREE</fname>
<namespace></namespace>
<description>Marks an error handler for deallocation.</description>
<prototype>
<returnType>int</returnType>
<name>MPI_Errhandler_free</name>
<arguments>MPI_Errhandler *</arguments>
</prototype>
</function>

<function>
<cname>MPI_Errhandler_get</cname>
<cppname>(none)</cppname>
<fname>MPI_ERRHANDLER_GET</fname>
<namespace></namespace>
<description>Gets an error handler associated with a communicator.</description>
<prototype>
<returnType>int</returnType>
<name>MPI_Errhandler_get</name>
<arguments>MPI_Comm, MPI_Errhandler *</arguments>
</prototype>
</function>

<function>
<cname>MPI_Errhandler_set</cname>
<cppname>(none)</cppname>
<fname>MPI_ERRHANDLER_SET</fname>
<namespace></namespace>
<description>Associates a new error handler with a communicator.</description>
<prototype>
<returnType>int</returnType>
<name>MPI_Errhandler_set</name>
<arguments>MPI_Comm, MPI_Errhandler</arguments>
</prototype>
</function>

<function>
<cname>MPI_Error_class</cname>
<cppname>MPI::Get_error_class</cppname>
<fname>MPI_ERROR_CLASS</fname>
<namespace></namespace>
<description>Returns the error class for the corresponding error code.</description>
<prototype>
<returnType>int</returnType>
<name>MPI_Error_class</name>
<arguments>int, int *</arguments>
</prototype>
</function>

<function>
<cname>MPI_Error_string</cname>
<cppname>MPI::Get_error_string</cppname>
<fname>MPI_ERROR_STRING</fname>
<namespace></namespace>
<description>Returns the error string for a given error code.</description>
<prototype>
<returnType>int</returnType>
<name>MPI_Error_string</name>
<arguments>int, char *, int *</arguments>
</prototype>
</function>

<function>
<cname>MPI_Exscan</cname>
<cppname>MPI::Intracomm::Exscan</cppname>
<fname>MPI_EXSCAN</fname>
<namespace></namespace>
<description>Performs a prefix reduction on data distributed across the group.</description>
<prototype>
<returnType>int</returnType>
<name>MPI_Exscan</name>
<arguments>void *, void *, int, MPI_Datatype, MPI_Op, MPI_Comm</arguments>
</prototype>
</function>

<function>
<cname>MPI_File_c2f</cname>
<cppname>(none)</cppname>
<fname>(none)</fname>
<namespace></namespace>
<description>Translates a C file handle into a FORTRAN handle to the same file.</description>
<prototype>
<returnType>MPI_Fint</returnType>
<name>MPI_File_c2f</name>
<arguments>MPI_File</arguments>
</prototype>
</function>

<function>
<cname>MPI_File_call_errhandler</cname>
<cppname>MPI::File::Call_errhandler</cppname>
<fname>MPI_FILE_CALL_ERRHANDLER</fname>
<namespace></namespace>
<description>Calls the error handler assigned to the file with the error code supplied.</description>
<prototype>
<returnType>int</returnType>
<name>MPI_File_call_errhandler</name>
<arguments>MPI_File, int</arguments>
</prototype>
</function>

<function>
<cname>MPI_File_create_errhandler</cname>
<cppname>MPI::File::Create_errhandler</cppname>
<fname>MPI_FILE_CREATE_ERRHANDLER</fname>
<namespace></namespace>
<description>Registers a user-defined error handler that you can associate with an open file.</description>
<prototype>
<returnType>int</returnType>
<name>MPI_File_create_errhandler</name>
<arguments>MPI_File_errhandler_fn *, MPI_Errhandler *</arguments>
</prototype>
</function>

<function>
<cname>MPI_File_f2c</cname>
<cppname>(none)</cppname>
<fname>(none)</fname>
<namespace></namespace>
<description>Returns a C handle to a file.</description>
<prototype>
<returnType>MPI_File</returnType>
<name>MPI_File_f2c</name>
<arguments>MPI_Fint</arguments>
</prototype>
</function>

<function>
<cname>MPI_File_get_errhandler</cname>
<cppname>MPI::File::Get_errhandler</cppname>
<fname>MPI_FILE_GET_ERRHANDLER</fname>
<namespace></namespace>
<description>Retrieves the error handler currently associated with a file handle.</description>
<prototype>
<returnType>int</returnType>
<name>MPI_File_get_errhandler</name>
<arguments>MPI_File, MPI_Errhandler *</arguments>
</prototype>
</function>

<function>
<cname>MPI_File_set_errhandler</cname>
<cppname>MPI::File::Set_errhandler</cppname>
<fname>MPI_FILE_SET_ERRHANDLER</fname>
<namespace></namespace>
<description>Associates a new error handler with a file.</description>
<prototype>
<returnType>int</returnType>
<name>MPI_File_set_errhandler</name>
<arguments>MPI_File, MPI_Errhandler</arguments>
</prototype>
</function>

<function>
<cname>MPI_Finalize</cname>
<cppname>MPI::Finalize</cppname>
<fname>MPI_FINALIZE</fname>
<namespace></namespace>
<description>Terminates all MPI processing.</description>
<prototype>
<returnType>int</returnType>
<name>MPI_Finalize</name>
<arguments>void</arguments>
</prototype>
</function>

<function>
<cname>MPI_File_close</cname>
<cppname>MPI::File::Close()</cppname>
<fname>MPI_FILE_CLOSE</fname>
<namespace></namespace>
<description>Closes a file (collective)</description>
<prototype>
<returnType>int</returnType>
<name>MPI_File_close</name>
<arguments>MPI_File</arguments>
</prototype>
</function>

<function>
<cname>MPI_File_delete</cname>
<cppname>MPI::File::Delete</cppname>
<fname>MPI_FILE_DELETE</fname>
<namespace></namespace>
<description>Deletes a file.</description>
<prototype>
<returnType>int</returnType>
<name>MPI_File_delete</name>
<arguments>char*filename, MPI_Info info</arguments>
</prototype>
</function>

<function>
<cname>MPI_File_get_amode</cname>
<cppname>MPI::File::Get_amode()</cppname>
<fname>MPI_FILE_GET_AMODE</fname>
<namespace></namespace>
<description>Returns access mode associated with an open file.</description>
<prototype>
<returnType>int</returnType>
<name>MPI_File_get_amode</name>
<arguments>MPI_File fh, int *amode</arguments>
</prototype>
</function>

<function>
<cname>MPI_File_get_atomicity</cname>
<cppname>MPI::File::Get_atomicity</cppname>
<fname>MPI_FILE_GET_ATOMICITY</fname>
<namespace></namespace>
<description>Returns current consistency semantics for data-access operations.</description>

<prototype>
<returnType>int</returnType>
<name>MPI_File_get_atomicity</name>
<arguments>MPI_File fh, int *flag</arguments>
</prototype>
</function>

<function>
<cname>MPI_File_get_byte_offset</cname>
<cppname>MPI::File::Get_byte_offset</cppname>
<fname>MPI_FILE_GET_BYTE_OFFSET</fname>
<namespace></namespace>
<description>Converts a view-relative offset into an absolute byte position.</description>

<prototype>
<returnType>int</returnType>
<name>MPI_get_byte_offset</name>
<arguments>MPI_File fh, MPI_Offset offset,MPI_Offset *disp</arguments>
</prototype>
</function>

<function>
<cname>MPI_File_get_group</cname>
<cppname>MPI::File::Get_group</cppname>
<fname>MPI_FILE_GET_GROUP</fname>
<namespace></namespace>
<description>Returns a duplicate of the process group of a file.</description>

<prototype>
<returnType>int</returnType>
<name>MPI_get_group</name>
<arguments>MPI_File fh, MPI_Group *group</arguments>
</prototype>
</function>

<function>
<cname>MPI_File_get_info</cname>
<cppname>MPI::File::Get_info</cppname>
<fname>MPI_FILE_GET_INFO</fname>
<namespace></namespace>
<description>Returns a new info object containing values for current hints associated with a file.</description>

<prototype>
<returnType>int</returnType>
<name>MPI_File_get_info</name>
<arguments>MPI_File fh, MPI_Info *info_used</arguments>
</prototype>
</function>

<function>
<cname>MPI_File_get_position</cname>
<cppname>MPI::File::get_position</cppname>
<fname>MPI_FILE_GET_POSITION</fname>
<namespace></namespace>
<description>Returns the current position of the individual file pointer.</description>

<prototype>
<returnType>int</returnType>
<name>MPI_File_get_position</name>
<arguments>MPI_File fh, MPI_Offset *offset</arguments>
</prototype>
</function>

<function>
<cname>MPI_File_get_position_shared</cname>
<cppname>MPI::File::Get_position_shared</cppname>
<fname>MPI_FILE_GET_POSITION_SHARED</fname>
<namespace></namespace>
<description>Returns the current position of the shared file
pointer.</description>

<prototype>
<returnType>int</returnType>
<name>MPI_get_position_shared</name>
<arguments>MPI_File fh, MPI_Offset *offset</arguments>
</prototype>
</function>

<function>
<cname>MPI_File_get_size</cname>
<cppname>MPI::File::Get_size</cppname>
<fname>MPI_FILE_GET_SIZE</fname>
<namespace></namespace>
<description>Returns the current size of the file.</description>

<prototype>
<returnType>int</returnType>
<name>MPI_File_get_size</name>
<arguments>MPI_File fh, MPI_Offset *offset</arguments>
</prototype>
</function>

<function>
<cname>MPI_File_get_type_extent</cname>
<cppname>MPI::File::Get_type_extent</cppname>
<fname>MPI_FILE_GET_TYPE_EXTENT</fname>
<namespace></namespace>
<description>Returns the extent of the data type in a file.</description>

<prototype>
<returnType>int</returnType>
<name>MPI_File_get_type_extent</name>
<arguments>MPI_File fh, MPI_Datatype datatype, MPI_Aint *extent</arguments>
</prototype>
</function>

<function>
<cname>MPI_File_get_view</cname>
<cppname>MPI::File::Get_view</cppname>
<fname>MPI_FILE_GET_VIEW</fname>
<namespace></namespace>
<description>Returns the process's view of data in the file.</description>

<prototype>
<returnType>int</returnType>
<name>MPI_File_get_view</name>
<arguments>MPI_File fh, MPI_Offset *disp, MPI_Datatype *etype,MPI_Datatype *filetype, char *datarep</arguments>
</prototype>
</function>

<function>
<cname>MPI_File_iread</cname>
<cppname>MPI::File::IRead</cppname>
<fname>MPI_FILE_IREAD</fname>
<namespace></namespace>
<description>Reads a file starting at the location specified by the individual file pointer (nonblocking, noncollective).</description>

<prototype>
<returnType>int</returnType>
<name>MPI_File_iread</name>
<arguments>MPI_File fh, void *buf, int count,MPI_Datatype datatype, MPI_Request *request</arguments>
</prototype>
</function>

<function>
<cname>MPI_File_iread_at</cname>
<cppname>MPI::File::IRead_at</cppname>
<fname>MPI_FILE_IREAD_AT</fname>
<namespace></namespace>
<description>Reads a file at an explicitly specified offset (nonblocking, noncollective).</description>

<prototype>
<returnType>int</returnType>
<name>MPI_File_iread_at</name>
<arguments>MPI_File fh, MPI_Offset offset, void *buf, int count,MPI_Datatype datatype, MPI_Request *request</arguments>
</prototype>
</function>

<function>
<cname>MPI_File_iread_shared</cname>
<cppname>MPI::File::IRead_shared</cppname>
<fname>MPI_FILE_IREAD_SHARED</fname>
<namespace></namespace>
<description>Reads a file using the shared file pointer (nonblocking, noncollective).</description>

<prototype>
<returnType>int</returnType>
<name>MPI_File_iread_shared</name>
<arguments>MPI_File fh, void *buf, int count,MPI_Datatype datatype, MPI_Request *request</arguments>
</prototype>
</function>

<function>
<cname>MPI_File_iwrite</cname>
<cppname>MPI::File::Iwrite</cppname>
<fname>MPI_FILE_IWRITE</fname>
<namespace></namespace>
<description>Writes a file starting at the location specified by the individual file pointer (nonblocking, noncollective).</description>

<prototype>
<returnType>int</returnType>
<name>MPI_File_iwrite</name>
<arguments>MPI_File fh, void *buf, int count,MPI_Datatype datatype, MPI_Request *request</arguments>
</prototype>
</function>

<function>
<cname>MPI_File_iwrite_at</cname>
<cppname>MPI::File::Iwrite_at</cppname>
<fname>MPI_FILE_IWRITE_AT</fname>
<namespace></namespace>
<description>Writes a file at an explicitly specified offset (nonblocking, noncollective).</description>

<prototype>
<returnType>int</returnType>
<name>MPI_File_iwrite_at</name>
<arguments>MPI_File fh, MPI_Offset offset, void *buf,int count, MPI_Datatype datatype, MPI_Request *request</arguments>
</prototype>
</function>
<function>
<cname>MPI_File_iwrite_shared</cname>
<cppname>MPI::File::Iwrite_shared</cppname>
<fname>MPI_FILE_IWRITE_SHARED</fname>
<namespace></namespace>
<description>Writes a file using the shared file pointer (nonblocking, noncollective).</description>

<prototype>
<returnType>int</returnType>
<name>MPI_File_iwrite_shared</name>
<arguments>MPI_File fh, void *buf, int count,MPI_Datatype datatype, MPI_Request *requestMPI_File fh, void *buf, int count,MPI_Datatype datatype, MPI_Request *request</arguments>
</prototype>
</function>

<function>
<cname>MPI_File_open</cname>
<cppname>MPI::File::Open</cppname>
<fname>MPI_FILE_OPEN</fname>
<namespace></namespace>
<description>Opens a file (collective).</description>

<prototype>
<returnType>int</returnType>
<name>MPI_File_open</name>
<arguments>fixme MPI_Comm, int</arguments>
</prototype>
</function>

<function>
<cname>MPI_File_preallocate</cname>
<cppname>MPI::File::Preallocate</cppname>
<fname>MPI_FILE_PREALLOCATE</fname>
<namespace></namespace>
<description>Preallocates a specified amount of storage space at the beginning of a file (collective).</description>

<prototype>
<returnType>int</returnType>
<name>MPI_File_preallocate</name>
<arguments>MPI_file fh, MPI_Offset size</arguments>
</prototype>
</function>

<function>
<cname>MPI_File_read</cname>
<cppname>MPI::File::Read</cppname>
<fname>MPI_FILE_READ</fname>
<namespace></namespace>
<description>Reads a file starting at the location specified by
the individual file pointer (blocking, noncollective).</description>

<prototype>
<returnType>int</returnType>
<name>MPI_File_read</name>
<arguments>MPI_File fh, void *buf, int count, MPI_Datatype datatype,MPI_Status *status</arguments>
</prototype>
</function>

<function>
<cname>MPI_File_read_all</cname>
<cppname>MPI::File::Read_all</cppname>
<fname>MPI_FILE_READ_ALL</fname>
<namespace></namespace>
<description>Reads a file starting at the locations specified by individual file pointers (blocking, collective).</description>

<prototype>
<returnType>int</returnType>
<name>MPI_File_read_all</name>
<arguments>MPI_File fh, void *buf, int count,MPI_Datatype datatype, MPI_Status *status</arguments>
</prototype>
</function>

<function>
<cname>MPI_File_read_all_begin</cname>
<cppname>MPI::File::Read_all_begin</cppname>
<fname>MPI_FILE_READ_ALL_BEGIN</fname>
<namespace></namespace>
<description>Reads a file starting at the locations specified by
individual file pointers; beginning part of a split
collective routine (nonblocking).</description>

<prototype>
<returnType>int</returnType>
<name>MPI_File_read_all_begin</name>
<arguments>MPI_File fh, void *buf, int count,MPI_Datatype datatype</arguments>
</prototype>
</function>
 
<function>
<cname>MPI_File_read_all_end</cname>
<cppname>MPI::File::Read_all_end</cppname>
<fname>MPI_FILE_READ_ALL_END</fname>
<namespace></namespace>
<description>Reads a file starting at the locations specified by individual file pointers; ending part of a split collective routine (blocking).</description>

<prototype>
<returnType>int</returnType>
<name>MPI_File_read_all_end</name>
<arguments>MPI_File fh, void *buf, MPI_Status *status</arguments>
</prototype>
</function>

<function>
<cname>MPI_File_read_at</cname>
<cppname>MPI::File::read_at</cppname>
<fname>MPI_FILE_READ_AT</fname>
<namespace></namespace>
<description>Reads a file at an explicitly specified offset
(blocking, noncollective).</description>

<prototype>
<returnType>int</returnType>
<name>MPI_File_read_at</name>
<arguments>MPI_File fh, MPI_Offset offset, void *buf, int count,MPI_Datatype datatype, MPI_Status *status</arguments>
</prototype>
</function>
<function>
<cname>MPI_File_read_at_all</cname>
<cppname>MPI::File::read_at_all</cppname>
<fname>MPI_FILE_READ_AT_ALL</fname>
<namespace></namespace>
<description>Reads a file at explicitly specified offsets (blocking, collective).</description>

<prototype>
<returnType>int</returnType>
<name>MPI_File_read_at_all</name>
<arguments>(MPI_File fh, MPI_Offset offset, void *buf,int count, MPI_Datatype datatype, MPI_Status *status</arguments>
</prototype>
</function>

<function>
<cname>MPI_File_read_at_all_begin</cname>
<cppname>MPI::File::read_at_all_begin</cppname>
<fname>MPI_FILE_READ_AT_ALL_BEGIN</fname>
<namespace></namespace>
<description>Reads a file at explicitly specified offsets;
beginning part of a split collective routine
(nonblocking).</description>

<prototype>
<returnType>int</returnType>
<name>MPI_File_read_at_all_begin</name>
<arguments>MPI_File fh, MPI_Offset offset, void *buf,int count, MPI_Datatype datatype</arguments>
</prototype>
</function>

<function>
<cname>MPI_File_read_at_all_end</cname>
<cppname>MPI::File::read_at_all_end</cppname>
<fname>MPI_FILE_READ_AT_ALL_END</fname>
<namespace></namespace>
<description>Reads a file at explicitly specified offsets; ending
part of a split collective routine (blocking).</description>

<prototype>
<returnType>int</returnType>
<name>MPI_File_read_at_all_end</name>
<arguments>MPI_File fh, void *buf, MPI_Status *status</arguments>
</prototype>
</function>

<function>
<cname>MPI_File_read_ordered</cname>
<cppname>MPI::File::read_ordered</cppname>
<fname>MPI_FILE_READ_ORDERED</fname>
<namespace></namespace>
<description>Reads a file at a location specified by a shared
file pointer (blocking, collective).</description>

<prototype>
<returnType>int</returnType>
<name>MPI_File_read_ordered</name>
<arguments>MPI_File fh, void *buf, int count,MPI_Datatype datatype, MPI_Status *status</arguments>
</prototype>
</function>

<function>
<cname>MPI_File_read_ordered_begin</cname>
<cppname>MPI::File::read_ordered_begin</cppname>
<fname>MPI_FILE_READ_ORDERED_BEGIN</fname>
<namespace></namespace>
<description>Reads a file at a location specified by a shared file pointer; beginning part of a split collective routine (nonblocking).</description>

<prototype>
<returnType>int</returnType>
<name>MPI_File_read_ordered_begin</name>
<arguments>MPI_File fh, void *buf, int count,MPI_Datatype datatype</arguments>
</prototype>
</function>

<function>
<cname>MPI_File_read_ordered_end</cname>
<cppname>MPI::File::read_ordered_end</cppname>
<fname>MPI_FILE_READ_ORDERED_END</fname>
<namespace></namespace>
<description>Reads a file at a location specified by a shared file pointer; ending part of a split collective routine (blocking).</description>

<prototype>
<returnType>int</returnType>
<name>MPI_File_read_ordered_end</name>
<arguments>MPI_File fh, void *buf, MPI_Status *status</arguments>
</prototype>
</function>

<function>
<cname>MPI_File_read_shared</cname>
<cppname>MPI::File::read_shared</cppname>
<fname>MPI_FILE_READ_SHARED</fname>
<namespace></namespace>
<description>Reads a file using the shared file pointer (blocking, noncollective).</description>

<prototype>
<returnType>int</returnType>
<name>MPI_File_read_shared</name>
<arguments>MPI_File fh, void *buf, int count,MPI_Datatype datatype, MPI_Status *status</arguments>
</prototype>
</function>

<function>
<cname>MPI_File_seek</cname>
<cppname>MPI::File::Seek</cppname>
<fname>MPI_FILE_SEEK</fname>
<namespace></namespace>
<description>Updates individual file pointers (noncollective).</description>

<prototype>
<returnType>int</returnType>
<name>MPI_File_seek</name>
<arguments>MPI_File fh, MPI_Offset offset, int whence</arguments>
</prototype>
</function>

<function>
<cname>MPI_File_seek_shared</cname>
<cppname>MPI::File::Seek_Shared</cppname>
<fname>MPI_FILE_SEEK_SHARED</fname>
<namespace></namespace>
<description>Updates the global shared file pointer (collective).</description>

<prototype>
<returnType>int</returnType>
<name>MPI_File_seek_shared</name>
<arguments>MPI_File fh, MPI_Offset offset, int whence</arguments>
</prototype>
</function>

<function>
<cname>MPI_File_set_atomicity</cname>
<cppname>MPI::File::Set_Atomicity</cppname>
<fname>MPI_FILE_SET_ATOMICITY</fname>
<namespace></namespace>
<description>Sets consistency semantics for data-access operations (collective).</description>

<prototype>
<returnType>int</returnType>
<name>MPI_File_set_atomicity</name>
<arguments>MPI_File fh, int flag</arguments>
</prototype>
</function>

<function>
<cname>MPI_File_set_info</cname>
<cppname>MPI::File::Set_Info</cppname>
<fname>MPI_FILE_SET_INFO</fname>
<namespace></namespace>
<description>Sets new values for hints (collective).</description>

<prototype>
<returnType>int</returnType>
<name>MPI_File_set_info</name>
<arguments>MPI_File fh, MPI_Info info</arguments>
</prototype>
</function>

<function>
<cname>MPI_File_set_size</cname>
<cppname>MPI::File::Set_Size</cppname>
<fname>MPI_FILE_SET_SIZE</fname>
<namespace></namespace>
<description>Resizes a file (collective).</description>

<prototype>
<returnType>int</returnType>
<name>MPI_File_set_size</name>
<arguments>MPI_File fh, MPI_Offset size</arguments>
</prototype>
</function>

<function>
<cname>MPI_File_set_view</cname>
<cppname>MPI::File::Set_View</cppname>
<fname>MPI_FILE_SET_VIEW</fname>
<namespace></namespace>
<description>Changes process's view of data in file
(collective).</description>

<prototype>
<returnType>int</returnType>
<name>MPI_File_set_view</name>
<arguments>MPI_File fh, MPI_Offset disp, MPI_Datatype etype,MPI_Datatype filetype, char *datarep, MPI_Info info</arguments>
</prototype>
</function>

<function>
<cname>MPI_File_sync</cname>
<cppname>MPI::File::Sync</cppname>
<fname>MPI_FILE_SYNC</fname>
<namespace></namespace>
<description>Makes semantics consistent for data-access operations (collective).</description>

<prototype>
<returnType>int</returnType>
<name>MPI_File_sync</name>
<arguments>MPI_File fh</arguments>
</prototype>
</function>

<function>
<cname>MPI_File_write</cname>
<cppname>MPI::File::Write</cppname>
<fname>MPI_FILE_WRITE</fname>
<namespace></namespace>
<description>Writes a file starting at the location specified by the individual file pointer (blocking, noncollective).</description>

<prototype>
<returnType>int</returnType>
<name>MPI_File_write</name>
<arguments>MPI_File fh, void *buf, int count, MPI_Datatype datatype,MPI_Status *status</arguments>
</prototype>
</function>

<function>
<cname>MPI_File_write_all</cname>
<cppname>MPI::File::Write_all</cppname>
<fname>MPI_FILE_WRITE_ALL</fname>
<namespace></namespace>
<description>Writes a file starting at the locations specified by
individual file pointers (blocking, collective).</description>

<prototype>
<returnType>int</returnType>
<name>MPI_File_write_all</name>
<arguments>MPI_File fh, void *buf, int count,MPI_Datatype datatype, MPI_Status *status</arguments>
</prototype>
</function>

<function>
<cname>MPI_File_write_all_begin</cname>
<cppname>MPI::File::Write_all_begin</cppname>
<fname>MPI_FILE_WRITE_ALL_BEGIN</fname>
<namespace></namespace>
<description>Writes a file starting at the locations specified by individual file pointers; beginning part of a split collective routine (nonblocking).</description>

<prototype>
<returnType>int</returnType>
<name>MPI_File_write_all_begin</name>
<arguments>MPI_File fh, void *buf, int count,MPI_Datatype datatype</arguments>
</prototype>
</function>

<function>
<cname>MPI_File_write_all_end</cname>
<cppname>MPI::File::Write_all_end</cppname>
<fname>MPI_FILE_WRITE_ALL_END</fname>
<namespace></namespace>
<description>Writes a file starting at the locations specified by individual file pointers; ending part of a split collective routine (blocking).</description>

<prototype>
<returnType>int</returnType>
<name>MPI_File_write_all_end</name>
<arguments>MPI_File fh, void *buf, MPI_Status *status</arguments>
</prototype>
</function>

<function>
<cname>MPI_File_write_at</cname>
<cppname>MPI::File::write_at</cppname>
<fname>MPI_FILE_WRITE_AT</fname>
<namespace></namespace>
<description>Writes a file at an explicitly specified offset (blocking, noncollective).</description>

<prototype>
<returnType>int</returnType>
<name>MPI_File_write_at</name>
<arguments>MPI_File fh, MPI_Offset offset, void *buf, int count,MPI_Datatype datatype, MPI_Status *status</arguments>
</prototype>
</function>

<function>
<cname>MPI_File_write_at_all</cname>
<cppname>MPI::File::write_at_all</cppname>
<fname>MPI_FILE_WRITE_AT_ALL</fname>
<namespace></namespace>
<description>Writes a file at explicitly specified offsets (blocking, collective).</description>

<prototype>
<returnType>int</returnType>
<name>MPI_File_write_at_all</name>
<arguments>(MPI_File fh, MPI_Offset offset, void *buf,int count, MPI_Datatype datatype, MPI_Status *status</arguments>
</prototype>
</function>

<function>
<cname>MPI_File_write_at_all_begin</cname>
<cppname>MPI::File::write_at_all_begin</cppname>
<fname>MPI_FILE_WRITE_AT_ALL_BEGIN</fname>
<namespace></namespace>
<description>Writes a file at explicitly specified offsets; beginning part of a split collective routine (nonblocking).</description>

<prototype>
<returnType>int</returnType>
<name>MPI_File_write_at_all_begin</name>
<arguments>MPI_File fh, MPI_Offset offset, void *buf,int count, MPI_Datatype datatype</arguments>
</prototype>
</function>

<function>
<cname>MPI_File_write_at_all_end</cname>
<cppname>MPI::File::write_at_all_end</cppname>
<fname>MPI_FILE_WRITE_AT_ALL_END</fname>
<namespace></namespace>
<description>Writes a file at explicitly specified offsets;
ending part of a split collective routine (blocking).</description>

<prototype>
<returnType>int</returnType>
<name>MPI_File_write_at_all_end</name>
<arguments>MPI_File fh, void *buf, MPI_Status *status</arguments>
</prototype>
</function>

<function>
<cname>MPI_File_write_ordered</cname>
<cppname>MPI::File::write_ordered</cppname>
<fname>MPI_FILE_WRITE_ORDERED</fname>
<namespace></namespace>
<description>Writes a file at a location specified by a shared file pointer (blocking, collective).</description>

<prototype>
<returnType>int</returnType>
<name>MPI_File_write_ordered</name>
<arguments>MPI_File fh, void *buf, int count,MPI_Datatype datatype, MPI_Status *status</arguments>
</prototype>
</function>

<function>
<cname>MPI_File_write_ordered_begin</cname>
<cppname>MPI::File::write_ordered_begin</cppname>
<fname>MPI_FILE_WRITE_ORDERED_BEGIN</fname>
<namespace></namespace>
<description>Writes a file at a location specified by a shared file pointer; beginning part of a split collective routine (nonblocking).</description>

<prototype>
<returnType>int</returnType>
<name>MPI_File_write_ordered_begin</name>
<arguments>MPI_File fh, void *buf, int count,MPI_Datatype datatype</arguments>
</prototype>
</function>

<function>
<cname>MPI_File_write_ordered_end</cname>
<cppname>MPI::File::write_ordered_end</cppname>
<fname>MPI_FILE_WRITE_ORDERED_END</fname>
<namespace></namespace>
<description>Writes a file at a location specified by a shared file pointer; ending part of a split collective routine (blocking).</description>

<prototype>
<returnType>int</returnType>
<name>MPI_File_write_ordered_end</name>
<arguments>MPI_File fh, void *buf, MPI_Status *status</arguments>
</prototype>
</function>

<function>
<cname>MPI_File_write_shared</cname>
<cppname>MPI::File::write_shared</cppname>
<fname>MPI_FILE_WRITE_SHARED</fname>
<namespace></namespace>
<description>Writes a file using the shared file pointer
(blocking, noncollective).</description>

<prototype>
<returnType>int</returnType>
<name>MPI_File_write_shared</name>
<arguments>MPI_File fh, void *buf, int count,MPI_Datatype datatype, MPI_Status *status</arguments>
</prototype>
</function>

<function>
<cname>MPI_Register_datarep</cname>
<cppname>(none)</cppname>
<fname>MPI_REGISTER_DATAREP</fname>
<namespace></namespace>
<description>Defines data representation.</description>

<prototype>
<returnType>int</returnType>
<name>MPI_Register_datarep</name>
<arguments>char *datarep,MPI_Datarep_conversion_function *read_conversion_fn,MPI_Datarep_conversion_function *write_conversion_fn,MPI_Datarep_extent_function *dtype_file_extent_fn,void *extra_state</arguments>
</prototype>
</function>

<function>
<cname>MPI_Finalized</cname>
<cppname>MPI::Is_finalized</cppname>
<fname>MPI_FINALIZED</fname>
<namespace></namespace>
<description>Returns true if MPI_FINALIZE has completed.</description>
<prototype>
<returnType>int</returnType>
<name>MPI_Finalized</name>
<arguments>int *</arguments>
</prototype>
</function>

<function>
<cname>MPI_Free_mem</cname>
<cppname>MPI::Free_mem</cppname>
<fname>MPI_FREE_MEM</fname>
<namespace></namespace>
<description>Frees a block of storage.</description>
<prototype>
<returnType>int</returnType>
<name>MPI_Free_mem</name>
<arguments>void *</arguments>
</prototype>
</function>

<function>
<cname>MPI_Gather</cname>
<cppname>MPI::Comm::Gather</cppname>
<fname>MPI_GATHER</fname>
<namespace></namespace>
<description>Collects individual messages from each task in a group at the root task.</description>
<prototype>
<returnType>int</returnType>
<name>MPI_Gather</name>
<arguments>void* , int, MPI_Datatype, void*, int, MPI_Datatype, int, MPI_Comm</arguments>
</prototype>
</function>

<function>
<cname>MPI_Gatherv</cname>
<cppname>MPI::Comm::Gatherv</cppname>
<fname>MPI_GATHERV</fname>
<namespace></namespace>
<description>Collects individual messages from each task incomm at the root task. Messages can have different sizes and displacements.</description>
<prototype>
<returnType>int</returnType>
<name>MPI_Gatherv</name>
<arguments>void* , int, MPI_Datatype, void*, int *, int *, MPI_Datatype, int, MPI_Comm</arguments>
</prototype>
</function>

<function>
<cname>MPI_Get</cname>
<cppname>MPI::Win::Get</cppname>
<fname>MPI_GET</fname>
<namespace></namespace>
<description>Transfers data from a window at the target task to the origin task.</description>
<prototype>
<returnType>int</returnType>
<name>MPI_Get</name>
<arguments>void *, int, MPI_Datatype, int, MPI_Aint, int, MPI_Datatype, MPI_Win</arguments>
</prototype>
</function>

<function>
<cname>MPI_Get_address</cname>
<cppname>MPI::Get_address</cppname>
<fname>MPI_GET_ADDRESS</fname>
<namespace></namespace>
<description>Returns the address of a location in memory.</description>
<prototype>
<returnType>int</returnType>
<name>MPI_Get_address</name>
<arguments>void *, MPI_Aint *</arguments>
</prototype>
</function>

<function>
<cname>MPI_Get_count</cname>
<cppname>MPI::Status::Get_count</cppname>
<fname>MPI_GET_COUNT</fname>
<namespace></namespace>
<description>Returns the number of elements in a message.</description>
<prototype>
<returnType>int</returnType>
<name>MPI_Get_count</name>
<arguments>MPI_Status *, MPI_Datatype, int *</arguments>
</prototype>
</function>

<function>
<cname>MPI_Get_elements</cname>
<cppname>MPI::Status::Get_elements</cppname>
<fname>MPI_GET_ELEMENTS</fname>
<namespace></namespace>
<description>Returns the number of basic elements in a message.</description>
<prototype>
<returnType>int</returnType>
<name>MPI_Get_elements</name>
<arguments>MPI_Status *, MPI_Datatype, int *</arguments>
</prototype>
</function>

<function>
<cname>MPI_Get_processor_name</cname>
<cppname>MPI::Get_processor_name</cppname>
<fname>MPI_GET_PROCESSOR_NAME</fname>
<namespace></namespace>
<description>Returns the name of the local processor.</description>
<prototype>
<returnType>int</returnType>
<name>MPI_Get_processor_name</name>
<arguments>char *, int *</arguments>
</prototype>
</function>

<function>
<cname>MPI_Get_version</cname>
<cppname>MPI::Get_version</cppname>
<fname>MPI_GET_VERSION</fname>
<namespace></namespace>
<description>Returns the version of the MPI standard supported.</description>
<prototype>
<returnType>int</returnType>
<name>MPI_Get_version</name>
<arguments>int *, int *</arguments>
</prototype>
</function>

<function>
<cname>MPI_Graph_create</cname>
<cppname>MPI::Intracomm::Create_graph</cppname>
<fname>MPI_GRAPH_CREATE</fname>
<namespace></namespace>
<description>Creates a new communicator containing graph topology information.</description>
<prototype>
<returnType>int</returnType>
<name>MPI_Graph_create</name>
<arguments>MPI_Comm, int, int *, int *, int, MPI_Comm *</arguments>
</prototype>
</function>

<function>
<cname>MPI_Graph_get</cname>
<cppname>MPI::Graphcomm::Get_topo</cppname>
<fname>MPI_GRAPH_GET</fname>
<namespace></namespace>
<description>Retrieves graph topology information from a communicator.</description>
<prototype>
<returnType>int</returnType>
<name>MPI_Graph_get</name>
<arguments>MPI_Comm, int, int, int *, int *</arguments>
</prototype>
</function>

<function>
<cname>MPI_Graph_map</cname>
<cppname>MPI::Graphcomm::Map</cppname>
<fname>MPI_GRAPH_MAP</fname>
<namespace></namespace>
<description>Computes placement of tasks on the physical processor.</description>
<prototype>
<returnType>int</returnType>
<name>MPI_Graph_map</name>
<arguments>MPI_Comm, int, int *, int *, int *</arguments>
</prototype>
</function>

<function>
<cname>MPI_Graph_neighbors</cname>
<cppname>MPI::Graphcomm::Get_neighbors</cppname>
<fname>MPI_GRAPH_NEIGHBORS</fname>
<namespace></namespace>
<description>Returns the neighbors of the given task.</description>
<prototype>
<returnType>int</returnType>
<name>MPI_Graph_neighbors</name>
<arguments>MPI_Comm, int, int, int *</arguments>
</prototype>
</function>

<function>
<cname>MPI_Graph_neighbors_count</cname>
<cppname>MPI::Graphcomm::Get_neighbors_count</cppname>
<fname>MPI_GRAPH_NEIGHBORS_COUNT</fname>
<namespace></namespace>
<description>Returns the number of neighbors of the given task.</description>
<prototype>
<returnType>int</returnType>
<name>MPI_Graph_neighbors_count</name>
<arguments>MPI_Comm, int, int *</arguments>
</prototype>
</function>

<function>
<cname>MPI_Graphdims_get</cname>
<cppname>MPI::Graphcomm::Get_dims</cppname>
<fname>MPI_GRAPHDIMS_GET</fname>
<namespace></namespace>
<description>Retrieves graph topology information from a communicator.</description>
<prototype>
<returnType>int</returnType>
<name>MPI_Graphdims_get</name>
<arguments>MPI_Comm, int *, int *</arguments>
</prototype>
</function>

<function>
<cname>MPI_Grequest_complete</cname>
<cppname>MPI::Grequest::Complete</cppname>
<fname>MPI_GREQUEST_COMPLETE</fname>
<namespace></namespace>
<description>Marks the generalized request complete.</description>
<prototype>
<returnType>int</returnType>
<name>MPI_Grequest_complete</name>
<arguments>MPI_Request</arguments>
</prototype>
</function>

<function>
<cname>MPI_Grequest_start</cname>
<cppname>MPI::Grequest::Start</cppname>
<fname>MPI_GREQUEST_START</fname>
<namespace></namespace>
<description>Initializes a generalized request.</description>
<prototype>
<returnType>int</returnType>
<name>MPI_Grequest_start</name>
<arguments>MPI_Grequest_query_function *, MPI_Grequest_free_function *,MPI_Grequest_cancel_function *, void *, MPI_Request *</arguments>
</prototype>
</function>

<function>
<cname>MPI_Group_c2f</cname>
<cppname>(none)</cppname>
<fname>(none)</fname>
<namespace></namespace>
<description>Translates a C group handle into a FORTRAN handle to the same group.</description>
<prototype>
<returnType>MPI_Fint</returnType>
<name>MPI_Group_c2f</name>
<arguments>MPI_Group</arguments>
</prototype>
</function>

<function>
<cname>MPI_Group_compare</cname>
<cppname>MPI::Group::Compare</cppname>
<fname>MPI_GROUP_COMPARE</fname>
<namespace></namespace>
<description>Compares the contents of two task groups.</description>
<prototype>
<returnType>int</returnType>
<name>MPI_Group_compare</name>
<arguments>MPI_Group, MPI_Group, int *</arguments>
</prototype>
</function>

<function>
<cname>MPI_Group_difference</cname>
<cppname>MPI::Group::Difference</cppname>
<fname>MPI_GROUP_DIFFERENCE</fname>
<namespace></namespace>
<description>Creates a new group that is the difference of two existing groups.</description>
<prototype>
<returnType>int</returnType>
<name>MPI_Group_difference</name>
<arguments>MPI_Group, MPI_Group, MPI_Group *</arguments>
</prototype>
</function>

<function>
<cname>MPI_Group_excl</cname>
<cppname>MPI::Group::Excl</cppname>
<fname>MPI_GROUP_EXCL</fname>
<namespace></namespace>
<description>Removes selected tasks from an existing group to create a new group.</description>
<prototype>
<returnType>int</returnType>
<name>MPI_Group_excl</name>
<arguments>MPI_Group, int, int *, MPI_Group *</arguments>
</prototype>
</function>

<function>
<cname>MPI_Group_f2c</cname>
<cppname>(none)</cppname>
<fname>(none)</fname>
<namespace></namespace>
<description>Returns a C handle to a group.</description>
<prototype>
<returnType>MPI_Group</returnType>
<name>MPI_Group_f2c</name>
<arguments>MPI_Fint</arguments>
</prototype>
</function>

<function>
<cname>MPI_Group_free</cname>
<cppname>MPI::Group::Free</cppname>
<fname>MPI_GROUP_FREE</fname>
<namespace></namespace>
<description>Marks a group for deallocation.</description>
<prototype>
<returnType>int</returnType>
<name>MPI_Group_free</name>
<arguments>MPI_Group *</arguments>
</prototype>
</function>

<function>
<cname>MPI_Group_incl</cname>
<cppname>MPI::Group::Incl</cppname>
<fname>MPI_GROUP_INCL</fname>
<namespace></namespace>
<description>Creates a new group consisting of selected tasks from an existing group.</description>
<prototype>
<returnType>int</returnType>
<name>MPI_Group_incl</name>
<arguments>MPI_Group, int, int *, MPI_Group *</arguments>
</prototype>
</function>

<function>
<cname>MPI_Group_intersection</cname>
<cppname>MPI::Group::Intersect</cppname>
<fname>MPI_GROUP_INTERSECTION</fname>
<namespace></namespace>
<description>Creates a new group that is the intersection of two existing groups.</description>
<prototype>
<returnType>int</returnType>
<name>MPI_Group_intersection</name>
<arguments>MPI_Group, MPI_Group, MPI_Group *</arguments>
</prototype>
</function>

<function>
<cname>MPI_Group_range_excl</cname>
<cppname>MPI::Group::Range_excl</cppname>
<fname>MPI_GROUP_RANGE_EXCL</fname>
<namespace></namespace>
<description>Creates a new group by excluding selected tasks of an existing group.</description>
<prototype>
<returnType>int</returnType>
<name>MPI_Group_range_excl</name>
<arguments>MPI_Group, int, int [][3], MPI_Group *</arguments>
</prototype>
</function>

<function>
<cname>MPI_Group_range_incl</cname>
<cppname>MPI::Group::Range_incl</cppname>
<fname>MPI_GROUP_RANGE_INCL</fname>
<namespace></namespace>
<description>Creates a new group consisting of selected ranges of tasks from an existing group.</description>
<prototype>
<returnType>int</returnType>
<name>MPI_Group_range_incl</name>
<arguments>MPI_Group, int, int [][3], MPI_Group *</arguments>
</prototype>
</function>

<function>
<cname>MPI_Group_rank</cname>
<cppname>MPI::Group::Get_rank</cppname>
<fname>MPI_GROUP_RANK</fname>
<namespace></namespace>
<description>Returns the rank of the local task with respect to group.</description>
<prototype>
<returnType>int</returnType>
<name>MPI_Group_rank</name>
<arguments>MPI_Group, int *</arguments>
</prototype>
</function>

<function>
<cname>MPI_Group_translate_ranks</cname>
<cppname>MPI::Group::Translate_ranks</cppname>
<fname>MPI_GROUP_TRANSLATE_RANKS</fname>
<namespace></namespace>
<description>Translates the ranks of one group into those of another group.</description>
<prototype>
<returnType>int</returnType>
<name>MPI_Group_translate_ranks</name>
<arguments>MPI_Group, int, int *, MPI_Group, int *</arguments>
</prototype>
</function>

<function>
<cname>MPI_Group_size</cname>
<cppname>MPI::Group::Get_size</cppname>
<fname>MPI_GROUP_SIZE</fname>
<namespace></namespace>
<description>Returns the number of tasks in a group.</description>
<prototype>
<returnType>int</returnType>
<name>MPI_Group_size</name>
<arguments>MPI_Group, int *</arguments>
</prototype>
</function>

<function>
<cname>MPI_Group_union</cname>
<cppname>MPI::Group::Union</cppname>
<fname>MPI_GROUP_UNION</fname>
<namespace></namespace>
<description>Creates a new group that is the union of two existing groups.</description>
<prototype>
<returnType>int</returnType>
<name>MPI_Group_union</name>
<arguments>MPI_Group, MPI_Group, MPI_Group *</arguments>
</prototype>
</function>

<function>
<cname>MPI_Ibsend</cname>
<cppname>MPI::Comm::Ibsend</cppname>
<fname>MPI_IBSEND</fname>
<namespace></namespace>
<description>Performs a non-blocking buffered send.</description>
<prototype>
<returnType>int</returnType>
<name>MPI_Ibsend</name>
<arguments>void*, int, MPI_Datatype, int, int, MPI_Comm, MPI_Request *</arguments>
</prototype>
</function>

<function>
<cname>MPI_Info_c2f</cname>
<cppname>(none)</cppname>
<fname>(none)</fname>
<namespace></namespace>
<description>Translates a C Info object handle into a FORTRAN handle to the same Info object.</description>
<prototype>
<returnType>MPI_Fint</returnType>
<name>MPI_Info_c2f</name>
<arguments>MPI_Info</arguments>
</prototype>
</function>

<function>
<cname>MPI_Info_create</cname>
<cppname>MPI::Info::Create</cppname>
<fname>MPI_INFO_CREATE</fname>
<namespace></namespace>
<description>Creates a new, empty Info object.</description>
<prototype>
<returnType>int</returnType>
<name>MPI_Info_create</name>
<arguments>MPI_Info *</arguments>
</prototype>
</function>

<function>
<cname>MPI_Info_delete</cname>
<cppname>MPI::Info::Delete</cppname>
<fname>MPI_INFO_DELETE</fname>
<namespace></namespace>
<description>Deletes a (key, value) pair from an Info object.</description>
<prototype>
<returnType>int</returnType>
<name>MPI_Info_delete</name>
<arguments>MPI_Info, char *</arguments>
</prototype>
</function>

<function>
<cname>MPI_Info_dup</cname>
<cppname>MPI::Info::Dup</cppname>
<fname>MPI_INFO_DUP</fname>
<namespace></namespace>
<description>Duplicates an Info object.</description>
<prototype>
<returnType>int</returnType>
<name>MPI_Info_dup</name>
<arguments>MPI_Info, MPI_Info *</arguments>
</prototype>
</function>

<function>
<cname>MPI_Info_f2c</cname>
<cppname>(none)</cppname>
<fname>(none)</fname>
<namespace></namespace>
<description>Returns a C handle to an Info object.</description>
<prototype>
<returnType>MPI_Info</returnType>
<name>MPI_Info_f2c</name>
<arguments>MPI_Fint</arguments>
</prototype>
</function>

<function>
<cname>MPI_Info_free</cname>
<cppname>MPI::Info::Free</cppname>
<fname>MPI_INFO_FREE</fname>
<namespace></namespace>
<description>Frees an Info object and sets its handle to MPI_INFO_NULL.</description>
<prototype>
<returnType>int</returnType>
<name>MPI_Info_free</name>
<arguments>MPI_Info *info</arguments>
</prototype>
</function>

<function>
<cname>MPI_Info_get</cname>
<cppname>MPI::Info::Get</cppname>
<fname>MPI_INFO_GET</fname>
<namespace></namespace>
<description>Retrieves the value associated withkey in an Info object.</description>
<prototype>
<returnType>int</returnType>
<name>MPI_Info_get</name>
<arguments>MPI_Info, char *, int, char *, int *</arguments>
</prototype>
</function>

<function>
<cname>MPI_Info_get_nkeys</cname>
<cppname>MPI::Info::Get_nkeys</cppname>
<fname>MPI_INFO_GET_NKEYS</fname>
<namespace></namespace>
<description>Returns the number of keys defined in an Info object.</description>
<prototype>
<returnType>int</returnType>
<name>MPI_Info_get_nkeys</name>
<arguments>MPI_Info, int *</arguments>
</prototype>
</function>

<function>
<cname>MPI_Info_get_nthkey</cname>
<cppname>MPI::Info::Get_nthkey</cppname>
<fname>MPI_INFO_GET_NTHKEY</fname>
<namespace></namespace>
<description>Retrieves the nth key defined in an Info object.</description>
<prototype>
<returnType>int</returnType>
<name>MPI_Info_get_nthkey</name>
<arguments>MPI_Info, int, char *</arguments>
</prototype>
</function>

<function>
<cname>MPI_Info_get_valuelen</cname>
<cppname>MPI::Info::Get_valuelen</cppname>
<fname>MPI_INFO_GET_VALUELEN</fname>
<namespace></namespace>
<description>Retrieves the length of the value associated with a key of an Info object.</description>
<prototype>
<returnType>int</returnType>
<name>MPI_Info_get_valuelen</name>
<arguments>MPI_Info, char *, int *, int *</arguments>
</prototype>
</function>

<function>
<cname>MPI_Info_set</cname>
<cppname>MPI::Info::Set</cppname>
<fname>MPI_INFO_SET</fname>
<namespace></namespace>
<description>Adds a (key, value) pair to an Info object.</description>
<prototype>
<returnType>int</returnType>
<name>MPI_Info_set</name>
<arguments>MPI_Info, char *, char *</arguments>
</prototype>
</function>

<function>
<cname>MPI_Init</cname>
<cppname>MPI::Init</cppname>
<fname>MPI_INIT</fname>
<namespace></namespace>
<description>Initializes MPI.</description>
<prototype>
<returnType>int</returnType>
<name>MPI_Init</name>
<arguments>int *, char ***</arguments>
</prototype>
</function>

<function>
<cname>MPI_Init_thread</cname>
<cppname>MPI::Init_thread</cppname>
<fname>MPI_INIT_THREAD</fname>
<namespace></namespace>
<description>Initializes MPI and the MPI threads environment.</description>
<prototype>
<returnType>int</returnType>
<name>MPI_Init_thread</name>
<arguments>int *, char ***, int, int *</arguments>
</prototype>
</function>

<function>
<cname>MPI_Initialized</cname>
<cppname>MPI::Is_initialized</cppname>
<fname>MPI_INITIALIZED</fname>
<namespace></namespace>
<description>Determines if MPI is initialized.</description>
<prototype>
<returnType>int</returnType>
<name>MPI_Initialized</name>
<arguments>int *</arguments>
</prototype>
</function>

<function>
<cname>MPI_Intercomm_create</cname>
<cppname>MPI::Intracomm::Create_intercomm</cppname>
<fname>MPI_INTERCOMM_CREATE</fname>
<namespace></namespace>
<description>Creates an inter-communicator from two intra-communicators.</description>
<prototype>
<returnType>int</returnType>
<name>MPI_Intercomm_create</name>
<arguments>MPI_Comm, int, MPI_Comm, int, int, MPI_Comm * </arguments>
</prototype>
</function>

<function>
<cname>MPI_Intercomm_merge</cname>
<cppname>MPI::Intercomm::Merge</cppname>
<fname>MPI_INTERCOMM_MERGE</fname>
<namespace></namespace>
<description>Creates an intra-communicator by merging the local and remote groups of an inter-communicator.</description>
<prototype>
<returnType>int</returnType>
<name>MPI_Intercomm_merge</name>
<arguments>MPI_Comm, int, MPI_Comm *</arguments>
</prototype>
</function>

<function>
<cname>MPI_Iprobe</cname>
<cppname>MPI::Comm::Iprobe</cppname>
<fname>MPI_IPROBE</fname>
<namespace></namespace>
<description>Checks to see if a message matchingsource, tag, andcomm has arrived.</description>
<prototype>
<returnType>int</returnType>
<name>MPI_Iprobe</name>
<arguments>int, int, MPI_Comm, int *, MPI_Status *</arguments>
</prototype>
</function>

<function>
<cname>MPI_Irecv</cname>
<cppname>MPI::Comm::Irecv</cppname>
<fname>MPI_IRECV</fname>
<namespace></namespace>
<description>Performs a non-blocking receive operation.</description>
<prototype>
<returnType>int</returnType>
<name>MPI_Irecv</name>
<arguments>void*, int, MPI_Datatype, int, int, MPI_Comm, MPI_Request *</arguments>
</prototype>
</function>

<function>
<cname>MPI_Irsend</cname>
<cppname>MPI::Comm::Irsend</cppname>
<fname>MPI_IRSEND</fname>
<namespace></namespace>
<description>Performs a non-blocking ready send operation.</description>
<prototype>
<returnType>int</returnType>
<name>MPI_Irsend</name>
<arguments>void*, int, MPI_Datatype, int, int, MPI_Comm, MPI_Request *</arguments>
</prototype>
</function>

<function>
<cname>MPI_Is_thread_main</cname>
<cppname>MPI::Is_thread_main</cppname>
<fname>MPI_IS_THREAD_MAIN</fname>
<namespace></namespace>
<description>Determines whether the calling thread is the thread that called MPI_INIT or MPI_INIT_THREAD.</description>
<prototype>
<returnType>int</returnType>
<name>MPI_Is_thread_main</name>
<arguments>int *</arguments>
</prototype>
</function>

<function>
<cname>MPI_Isend</cname>
<cppname>MPI::Comm::Isend</cppname>
<fname>MPI_ISEND</fname>
<namespace></namespace>
<description>Performs a non-blocking standard mode send operation.</description>
<prototype>
<returnType>int</returnType>
<name>MPI_Isend</name>
<arguments>void*, int, MPI_Datatype, int, int, MPI_Comm, MPI_Request *</arguments>
</prototype>
</function>

<function>
<cname>MPI_Issend</cname>
<cppname>MPI::Comm::Issend</cppname>
<fname>MPI_ISSEND</fname>
<namespace></namespace>
<description>Performs a non-blocking synchronous mode send operation.</description>
<prototype>
<returnType>int</returnType>
<name>MPI_Issend</name>
<arguments>void*, int, MPI_Datatype, int, int, MPI_Comm, MPI_Request *</arguments>
</prototype>
</function>

<function>
<cname>MPI_Keyval_create</cname>
<cppname>(none)</cppname>
<fname>MPI_KEYVAL_CREATE</fname>
<namespace></namespace>
<description>Generates a new communicator attribute key.</description>
<prototype>
<returnType>int</returnType>
<name>MPI_Keyval_create</name>
<arguments>MPI_Copy_function *, MPI_Delete_function *, int *, void*</arguments>
</prototype>
</function>

<function>
<cname>MPI_Keyval_free</cname>
<cppname>(none)</cppname>
<fname>MPI_KEYVAL_FREE</fname>
<namespace></namespace>
<description>Marks a communicator attribute key for deallocation.</description>
<prototype>
<returnType>int</returnType>
<name>MPI_Keyval_free</name>
<arguments>int *</arguments>
</prototype>
</function>

<function>
<cname>MPI_Lookup_name</cname>
<cppname>MPI::Lookup_name</cppname>
<fname>MPI_LOOKUP_NAME</fname>
<namespace></namespace>
<description>Finds the port associated with a service name.</description>
<prototype>
<returnType>int</returnType>
<name>MPI_Lookup_name</name>
<arguments>char *, MPI_Info, char *</arguments>
</prototype>
</function>

<function>
<cname>MPI_Op_c2f</cname>
<cppname>(none)</cppname>
<fname>(none)</fname>
<namespace></namespace>
<description>Translates a C reduction operation handle into a FORTRAN handle to the same operation.</description>
<prototype>
<returnType>MPI_Fint</returnType>
<name>MPI_Op_c2f</name>
<arguments>MPI_Op</arguments>
</prototype>
</function>

<function>
<cname>MPI_Op_commutative</cname>
<cppname>MPI::Op::Is_commutative</cppname>
<fname>MPI_OP_COMMUTATIVE</fname>
<namespace></namespace>
<description>Queries a reduction operation for its commutativity.</description>
<prototype>
<returnType>int</returnType>
<name>MPI_Op_commutative</name>
<arguments>MPI_Op, int *</arguments>
</prototype>
</function>

<function>
<cname>MPI_Op_create</cname>
<cppname>MPI::Op::Init</cppname>
<fname>MPI_OP_CREATE</fname>
<namespace></namespace>
<description>Binds a user-defined reduction operation to anop handle.</description>
<prototype>
<returnType>int</returnType>
<name>MPI_Op_create</name>
<arguments>MPI_User_function *, int, MPI_Op *</arguments>
</prototype>
</function>

<function>
<cname>MPI_Op_f2c</cname>
<cppname>(none)</cppname>
<fname>(none)</fname>
<namespace></namespace>
<description>Returns a C reduction operation handle to an operation.</description>
<prototype>
<returnType>MPI_Op</returnType>
<name>MPI_Op_f2c</name>
<arguments>MPI_Fint</arguments>
</prototype>
</function>

<function>
<cname>MPI_Op_free</cname>
<cppname>MPI::Op::Free</cppname>
<fname>MPI_OP_FREE</fname>
<namespace></namespace>
<description>Marks a user-defined reduction operation for deallocation.</description>
<prototype>
<returnType>int</returnType>
<name>MPI_Op_free</name>
<arguments> MPI_Op *</arguments>
</prototype>
</function>

<function>
<cname>MPI_Open_port</cname>
<cppname>MPI::Open_port</cppname>
<fname>MPI_OPEN_PORT</fname>
<namespace></namespace>
<description>Establishes a network address for a server to accept connections from clients.</description>
<prototype>
<returnType>int</returnType>
<name>MPI_Open_port</name>
<arguments>MPI_Info, char *</arguments>
</prototype>
</function>

<function>
<cname>MPI_Pack</cname>
<cppname>MPI::Datatype::Pack</cppname>
<fname>MPI_PACK</fname>
<namespace></namespace>
<description>Packs the message in the specified send buffer into the specified buffer space.</description>
<prototype>
<returnType>int</returnType>
<name>MPI_Pack</name>
<arguments>void*, int, MPI_Datatype, void *, int, int *,  MPI_Comm</arguments>
</prototype>
</function>

<function>
<cname>MPI_Pack_external</cname>
<cppname>MPI::Datatype::Pack_external</cppname>
<fname>MPI_PACK_EXTERNAL</fname>
<namespace></namespace>
<description>Packs the message in the specified send buffer into the specified buffer space, using the external32 data format.</description>
<prototype>
<returnType>int</returnType>
<name>MPI_Pack_external</name>
<arguments>char *, void *, int, MPI_Datatype, void *, MPI_Aint, MPI_Aint *</arguments>
</prototype>
</function>

<function>
<cname>MPI_Pack_external_size</cname>
<cppname>MPI::Datatype::Pack_external_size</cppname>
<fname>MPI_PACK_EXTERNAL_SIZE</fname>
<namespace></namespace>
<description>Returns the number of bytes required to hold the data, using the external32 data format.</description>
<prototype>
<returnType>int</returnType>
<name>MPI_Pack_external_size</name>
<arguments>char *, int, MPI_Datatype, MPI_Aint *</arguments>
</prototype>
</function>

<function>
<cname>MPI_Pack_size</cname>
<cppname>MPI::Datatype::Pack_size</cppname>
<fname>MPI_PACK_SIZE</fname>
<namespace></namespace>
<description>Returns the number of bytes required to hold the data.</description>
<prototype>
<returnType>int</returnType>
<name>MPI_Pack_size</name>
<arguments>int, MPI_Datatype, MPI_Comm, int *</arguments>
</prototype>
</function>

<function>
<cname>MPI_Pcontrol</cname>
<cppname>MPI::Pcontrol</cppname>
<fname>MPI_PCONTROL</fname>
<namespace></namespace>
<description>Provides profile control.</description>
<prototype>
<returnType>int</returnType>
<name>MPI_Pcontrol</name>
<arguments>const int, ...</arguments>
</prototype>
</function>

<function>
<cname>MPI_Probe</cname>
<cppname>MPI::Comm::Probe</cppname>
<fname>MPI_PROBE</fname>
<namespace></namespace>
<description>Waits until a message matching source, tag, and comm arrives.</description>
<prototype>
<returnType>int</returnType>
<name>MPI_Probe</name>
<arguments>int, int, MPI_Comm, MPI_Status *</arguments>
</prototype>
</function>

<function>
<cname>MPI_Publish_name</cname>
<cppname>MPI::Publish_name</cppname>
<fname>MPI_PUBLISH_NAME</fname>
<namespace></namespace>
<description>Publishes a service name associated with a port.</description>
<prototype>
<returnType>int</returnType>
<name>MPI_Publish_name</name>
<arguments>char *, MPI_Info, char *</arguments>
</prototype>
</function>

<function>
<cname>MPI_Put</cname>
<cppname>MPI::Win::Put</cppname>
<fname>MPI_PUT</fname>
<namespace></namespace>
<description>Transfers data from the origin task to a window at the target task.</description>
<prototype>
<returnType>int</returnType>
<name>MPI_Put</name>
<arguments>void *, int, MPI_Datatype, int, MPI_Aint, int, MPI_Datatype, MPI_Win</arguments>
</prototype>
</function>

<function>
<cname>MPI_Query_thread</cname>
<cppname>MPI::Query_thread</cppname>
<fname>MPI_QUERY_THREAD</fname>
<namespace></namespace>
<description>Returns the current level of threads support.</description>
<prototype>
<returnType>int</returnType>
<name>MPI_Query_thread</name>
<arguments>int *</arguments>
</prototype>
</function>

<function>
<cname>MPI_Recv</cname>
<cppname>MPI::Comm::Recv</cppname>
<fname>MPI_RECV</fname>
<namespace></namespace>
<description>Performs a blocking receive operation.</description>
<prototype>
<returnType>int</returnType>
<name>MPI_Recv</name>
<arguments>void*, int, MPI_Datatype, int, int, MPI_Comm, MPI_Status *</arguments>
</prototype>
</function>

<function>
<cname>MPI_Recv_init</cname>
<cppname>MPI::Comm::Recv_init</cppname>
<fname>MPI_RECV_INIT</fname>
<namespace></namespace>
<description>Creates a persistent receive request.</description>
<prototype>
<returnType>int</returnType>
<name>MPI_Recv_init</name>
<arguments>void*, int, MPI_Datatype, int,int, MPI_Comm, MPI_Request *</arguments>
</prototype>
</function>

<function>
<cname>MPI_Reduce</cname>
<cppname>MPI::Comm::Reduce</cppname>
<fname>MPI_REDUCE</fname>
<namespace></namespace>
<description>Applies a reduction operation to the vectorsendbuf over the set of tasks specified bycomm and places the result in recvbuf on root.</description>
<prototype>
<returnType>int</returnType>
<name>MPI_Reduce</name>
<arguments>void* , void*, int, MPI_Datatype, MPI_Op, int, MPI_Comm</arguments>
</prototype>
</function>

<function>
<cname>MPI_Reduce_local</cname>
<cppname>MPI::Op::Reduce_local</cppname>
<fname>MPI_REDUCE_LOCAL</fname>
<namespace></namespace>
<description>Applies a reduction operation to local arguments.</description>
<prototype>
<returnType>int</returnType>
<name>MPI_Reduce_local</name>
<arguments>void* , void*, int, MPI_Datatype, MPI_Op, int</arguments>
</prototype>
</function>

<function>
<cname>MPI_Reduce_scatter</cname>
<cppname>MPI::Comm::Reduce_scatter</cppname>
<fname>MPI_REDUCE_SCATTER</fname>
<namespace></namespace>
<description>Applies a reduction operation to the vectorsendbuf over the set of tasks specified bycomm and scatters the result according to the values in recvcounts.</description>
<prototype>
<returnType>int</returnType>
<name>MPI_Reduce_scatter</name>
<arguments>void* , void*, int *, MPI_Datatype, MPI_Op, MPI_Comm</arguments>
</prototype>
</function>

<function>
<cname>MPI_Reduce_scatter_block</cname>
<cppname>MPI::Comm::Reduce_scatter_block</cppname>
<fname>MPI_REDUCE_SCATTER_BLOCK</fname>
<namespace></namespace>
<description>Applies a reduction operation and scatters the result in equal-sized blocks.</description>
<prototype>
<returnType>int</returnType>
<name>MPI_Reduce_scatter_block</name>
<arguments>void* , void*, int, MPI_Datatype, MPI_Op, MPI_Comm</arguments>
</prototype>
</function>

<function>
<cname>MPI_Request_c2f</cname>
<cppname>(none)</cppname>
<fname>(none)</fname>
<namespace></namespace>
<description>Translates a C request handle into a FORTRAN handle to the same request.</description>
<prototype>
<returnType>MPI_Fint</returnType>
<name>MPI_Request_c2f</name>
<arguments>MPI_Request</arguments>
</prototype>
</function>

<function>
<cname>MPI_Request_f2c</cname>
<cppname>(none)</cppname>
<fname>(none)</fname>
<namespace></namespace>
<description>Returns a C handle to a request.</description>
<prototype>
<returnType>MPI_Request</returnType>
<name>MPI_Request_f2c</name>
<arguments>MPI_Fint</arguments>
</prototype>
</function>

<function>
<cname>MPI_Request_free</cname>
<cppname>MPI::Request::Free</cppname>
<fname>MPI_REQUEST_FREE</fname>
<namespace></namespace>
<description>Marks a request for deallocation.</description>
<prototype>
<returnType>int</returnType>
<name>MPI_Request_free</name>
<arguments>MPI_Request *</arguments>
</prototype>
</function>

<function>
<cname>MPI_Request_get_status</cname>
<cppname>MPI::Request::Get_status</cppname>
<fname>MPI_REQUEST_GET_STATUS</fname>
<namespace></namespace>
<description>Accesses the information associated with a request, without freeing the request.</description>
<prototype>
<returnType>int</returnType>
<name>MPI_Request_get_status</name>
<arguments>MPI_Request, int *, MPI_Status *</arguments>
</prototype>
</function>

<function>
<cname>MPI_Rsend</cname>
<cppname>MPI::Comm::Rsend</cppname>
<fname>MPI_RSEND</fname>
<namespace></namespace>
<description>Performs a blocking ready mode send operation.</description>
<prototype>
<returnType>int</returnType>
<name>MPI_Rsend</name>
<arguments>void*, int, MPI_Datatype, int, int, MPI_Comm</arguments>
</prototype>
</function>

<function>
<cname>MPI_Rsend_init</cname>
<cppname>MPI::Comm::Rsend_init</cppname>
<fname>MPI_RSEND_INIT</fname>
<namespace></namespace>
<description>Creates a persistent ready mode send request.</description>
<prototype>
<returnType>int</returnType>
<name>MPI_Rsend_init</name>
<arguments>void*, int, MPI_Datatype, int,int, MPI_Comm, MPI_Request *</arguments>
</prototype>
</function>

<function>
<cname>MPI_Scan</cname>
<cppname>MPI::Intracomm::Scan</cppname>
<fname>MPI_SCAN</fname>
<namespace></namespace>
<description>Performs a parallel prefix reduction on data distributed across a group.</description>
<prototype>
<returnType>int</returnType>
<name>MPI_Scan</name>
<arguments>void* , void*, int, MPI_Datatype, MPI_Op, MPI_Comm </arguments>
</prototype>
</function>

<function>
<cname>MPI_Scatter</cname>
<cppname>MPI::Comm::Scatter</cppname>
<fname>MPI_SCATTER</fname>
<namespace></namespace>
<description>Distributes individual messages fromroot to each task in comm.</description>
<prototype>
<returnType>int</returnType>
<name>MPI_Scatter</name>
<arguments>void* , int, MPI_Datatype, void*, int, MPI_Datatype, int, MPI_Comm</arguments>
</prototype>
</function>

<function>
<cname>MPI_Scatterv</cname>
<cppname>MPI::Comm::Scatterv</cppname>
<fname>MPI_SCATTERV</fname>
<namespace></namespace>
<description>Distributes individual messages fromroot to each task in comm. Messages can have different sizes and displacements.</description>
<prototype>
<returnType>int</returnType>
<name>MPI_Scatterv</name>
<arguments>void* , int *, int *,  MPI_Datatype, void*, int, MPI_Datatype, int, MPI_Comm</arguments>
</prototype>
</function>

<function>
<cname>MPI_Send</cname>
<cppname>MPI::Comm::Send</cppname>
<fname>MPI_SEND</fname>
<namespace></namespace>
<description>Blocking standard mode send.</description>
<prototype>
<returnType>int</returnType>
<name>MPI_Send</name>
<arguments>void*, int, MPI_Datatype, int, int, MPI_Comm</arguments>
</prototype>
</function>

<function>
<cname>MPI_Send_init</cname>
<cppname>MPI::Comm::Send_init</cppname>
<fname>MPI_SEND_INIT</fname>
<namespace></namespace>
<description>Creates a persistent standard mode send request.</description>
<prototype>
<returnType>int</returnType>
<name>MPI_Send_init</name>
<arguments>void*, int, MPI_Datatype, int, int, MPI_Comm, MPI_Request *</arguments>
</prototype>
</function>

<function>
<cname>MPI_Sendrecv</cname>
<cppname>MPI::Comm::Sendrecv</cppname>
<fname>MPI_SENDRECV</fname>
<namespace></namespace>
<description>Performs a blocking send and receive operation.</description>
<prototype>
<returnType>int</returnType>
<name>MPI_Sendrecv</name>
<arguments>void *, int, MPI_Datatype,int, int, void *, int, MPI_Datatype, int, int, MPI_Comm, MPI_Status *</arguments>
</prototype>
</function>

<function>
<cname>MPI_Sendrecv_replace</cname>
<cppname>MPI::Comm::Sendrecv_replace</cppname>
<fname>MPI_SENDRECV_REPLACE</fname>
<namespace></namespace>
<description>Performs a blocking send and receive operation using a common buffer.</description>
<prototype>
<returnType>int</returnType>
<name>MPI_Sendrecv_replace</name>
<arguments>void*, int, MPI_Datatype, int, int, int, int, MPI_Comm, MPI_Status *</arguments>
</prototype>
</function>

<function>
<cname>MPI_Ssend</cname>
<cppname>MPI::Comm::Ssend</cppname>
<fname>MPI_SSEND</fname>
<namespace></namespace>
<description>Performs a blocking synchronous mode send operation.</description>
<prototype>
<returnType>int</returnType>
<name>MPI_Ssend</name>
<arguments>void*, int, MPI_Datatype, int, int, MPI_Comm</arguments>
</prototype>
</function>

<function>
<cname>MPI_Ssend_init</cname>
<cppname>MPI::Comm::Ssend_init</cppname>
<fname>MPI_SSEND_INIT</fname>
<namespace></namespace>
<description>Creates a persistent synchronous mode send request.</description>
<prototype>
<returnType>int</returnType>
<name>MPI_Ssend_init</name>
<arguments>void*, int, MPI_Datatype, int,int, MPI_Comm, MPI_Request *</arguments>
</prototype>
</function>

<function>
<cname>MPI_Start</cname>
<cppname>MPI::Prequest::Start</cppname>
<fname>MPI_START</fname>
<namespace></namespace>
<description>Activates a persistent request operation.</description>
<prototype>
<returnType>int</returnType>
<name>MPI_Start</name>
<arguments>MPI_Request *</arguments>
</prototype>
</function>

<function>
<cname>MPI_Startall</cname>
<cppname>MPI::Prequest::Startall</cppname>
<fname>MPI_STARTALL</fname>
<namespace></namespace>
<description>Activates a collection of persistent request operations.</description>
<prototype>
<returnType>int</returnType>
<name>MPI_Startall</name>
<arguments>int, MPI_Request *</arguments>
</prototype>
</function>

<function>
<cname>MPI_Status_c2f</cname>
<cppname>(none)</cppname>
<fname>(none)</fname>
<namespace></namespace>
<description>Translates a C status object into a FORTRAN status object.</description>
<prototype>
<returnType>int</returnType>
<name>MPI_Status_c2f</name>
<arguments>MPI_Status *, MPI_Fint *</arguments>
</prototype>
</function>

<function>
<cname>MPI_Status_f2c</cname>
<cppname>(none)</cppname>
<fname>(none)</fname>
<namespace></namespace>
<description>Converts a FORTRAN status object into a C status object.</description>
<prototype>
<returnType>int</returnType>
<name>MPI_Status_f2c</name>
<arguments>MPI_Fint *, MPI_Status *</arguments>
</prototype>
</function>

<function>
<cname>MPI_Status_set_cancelled</cname>
<cppname>MPI::Status::Set_cancelled</cppname>
<fname>MPI_STATUS_SET_CANCELLED</fname>
<namespace></namespace>
<description>Defines cancellation information for a request.</description>
<prototype>
<returnType>int</returnType>
<name>MPI_Status_set_cancelled</name>
<arguments>MPI_Status *, int</arguments>
</prototype>
</function>

<function>
<cname>MPI_Status_set_elements</cname>
<cppname>MPI::Status::Set_elements</cppname>
<fname>MPI_STATUS_SET_ELEMENTS</fname>
<namespace></namespace>
<description>Defines element information for a request.</description>
<prototype>
<returnType>int</returnType>
<name>MPI_Status_set_elements</name>
<arguments>MPI_Status *, MPI_Datatype, int</arguments>
</prototype>
</function>

<function>
<cname>MPI_Test</cname>
<cppname>MPI::Request::Test</cppname>
<fname>MPI_TEST</fname>
<namespace></namespace>
<description>Checks to see if a non-blocking operation has completed.</description>
<prototype>
<returnType>int</returnType>
<name>MPI_Test</name>
<arguments>MPI_Request *, int *, MPI_Status *</arguments>
</prototype>
</function>

<function>
<cname>MPI_Test_cancelled</cname>
<cppname>MPI::Status::Is_cancelled</cppname>
<fname>MPI_TEST_CANCELLED</fname>
<namespace></namespace>
<description>Tests whether a non-blocking operation was cancelled.</description>
<prototype>
<returnType>int</returnType>
<name>MPI_Test_cancelled</name>
<arguments>MPI_Status *, int *</arguments>
</prototype>
</function>

<function>
<cname>MPI_Testall</cname>
<cppname>MPI::Request::Testall</cppname>
<fname>MPI_TESTALL</fname>
<namespace></namespace>
<description>Tests a collection of non-blocking operations for completion.</description>
<prototype>
<returnType>int</returnType>
<name>MPI_Testall</name>
<arguments>int, MPI_Request *, int *, MPI_Status *</arguments>
</prototype>
</function>

<function>
<cname>MPI_Testany</cname>
<cppname>MPI::Request::Testany</cppname>
<fname>MPI_TESTANY</fname>
<namespace></namespace>
<description>Tests for the completion of any specified non-blocking operation.</description>
<prototype>
<returnType>int</returnType>
<name>MPI_Testany</name>
<arguments>int, MPI_Request *, int *, int *, MPI_Status *</arguments>
</prototype>
</function>

<function>
<cname>MPI_Testsome</cname>
<cppname>MPI::Request::Testsome</cppname>
<fname>MPI_TESTSOME</fname>
<namespace></namespace>
<description>Tests a collection of non-blocking operations for completion.</description>
<prototype>
<returnType>int</returnType>
<name>MPI_Testsome</name>
<arguments>int, MPI_Request *, int *, int *, MPI_Status *</arguments>
</prototype>
</function>

<function>
<cname>MPI_Topo_test</cname>
<cppname>MPI::Comm::Get_topology</cppname>
<fname>MPI_TOPO_TEST</fname>
<namespace></namespace>
<description>Returns the type of virtual topology associated with a communicator.</description>
<prototype>
<returnType>int</returnType>
<name>MPI_Topo_test</name>
<arguments>MPI_Comm, int *</arguments>
</prototype>
</function>

<function>
<cname>MPI_Type_c2f</cname>
<cppname>(none)</cppname>
<fname>(none)</fname>
<namespace></namespace>
<description>Translates a C datatype handle into a FORTRAN handle to the same datatype.</description>
<prototype>
<returnType>MPI_Fint</returnType>
<name>MPI_Type_c2f</name>
<arguments>MPI_Datatype</arguments>
</prototype>
</function>

<function>
<cname>MPI_Type_commit</cname>
<cppname>MPI::Datatype::Commit</cppname>
<fname>MPI_TYPE_COMMIT</fname>
<namespace></namespace>
<description>Makes a datatype ready for use in communication.</description>
<prototype>
<returnType>int</returnType>
<name>MPI_Type_commit</name>
<arguments>MPI_Datatype *</arguments>
</prototype>
</function>

<function>
<cname>MPI_Type_contiguous</cname>
<cppname>MPI::Datatype::Create_contiguous</cppname>
<fname>MPI_TYPE_CONTIGUOUS</fname>
<namespace></namespace>
<description>Returns a new datatype that represents the concatenation of count instances ofoldtype.</description>
<prototype>
<returnType>int</returnType>
<name>MPI_Type_contiguous</name>
<arguments>int, MPI_Datatype, MPI_Datatype *</arguments>
</prototype>
</function>

<function>
<cname>MPI_Type_create_darray</cname>
<cppname>MPI::Datatype::Create_darray</cppname>
<fname>MPI_TYPE_CREATE_DARRAY</fname>
<namespace></namespace>
<description>Generates the datatypes corresponding to an HPF-like distribution of an ndims-dimensional array of oldtype elements onto anndims-dimensional grid of logical tasks.</description>
<prototype>
<returnType>int</returnType>
<name>MPI_Type_create_darray</name>
<arguments>int, int, int, int [], int [], int [], int [], int,MPI_Datatype, MPI_Datatype *</arguments>
</prototype>
</function>

<function>
<cname>MPI_Type_create_f90_complex</cname>
<cppname>MPI::Datatype::Create_f90_complex</cppname>
<fname>MPI_TYPE_CREATE_F90_COMPLEX</fname>
<namespace></namespace>
<description>Returns a predefined MPI datatype that matches a COMPLEX variable of KIND selected_real_kind(p, r).</description>
<prototype>
<returnType>int</returnType>
<name>MPI_Type_create_f90_complex</name>
<arguments> int, int, MPI_Datatype * </arguments>
</prototype>
</function>

<function>
<cname>MPI_Type_create_f90_integer</cname>
<cppname>MPI::Datatype::Create_f90_integer</cppname>
<fname>MPI_TYPE_CREATE_F90_INTEGER</fname>
<namespace></namespace>
<description>Returns a predefined MPI datatype that matches an INTEGER variable of KIND selected_integer_kind(r).</description>
<prototype>
<returnType>int</returnType>
<name>MPI_Type_create_f90_integer</name>
<arguments> int, MPI_Datatype * </arguments>
</prototype>
</function>

<function>
<cname>MPI_Type_create_f90_real</cname>
<cppname>MPI::Datatype::Create_f90_real</cppname>
<fname>MPI_TYPE_CREATE_F90_REAL</fname>
<namespace></namespace>
<description>Returns a predefined MPI datatype that matches a REAL variable of KIND selected_real_kind(p, r).</description>
<prototype>
<returnType>int</returnType>
<name>MPI_Type_create_f90_real</name>
<arguments> int, int, MPI_Datatype * </arguments>
</prototype>
</function>

<function>
<cname>MPI_Type_create_hindexed</cname>
<cppname>MPI::Datatype::Create_hindexed</cppname>
<fname>MPI_TYPE_CREATE_HINDEXED</fname>
<namespace></namespace>
<description>Returns a new datatype that representscount blocks. Each block is defined by an entry in array_of_blocklengths andarray_of_displacements. Displacements are expressed in bytes.</description>
<prototype>
<returnType>int</returnType>
<name>MPI_Type_create_hindexed</name>
<arguments>int, int [], MPI_Aint [], MPI_Datatype, MPI_Datatype *</arguments>
</prototype>
</function>

<function>
<cname>MPI_Type_create_hvector</cname>
<cppname>MPI::Datatype::Create_hvector</cppname>
<fname>MPI_TYPE_CREATE_HVECTOR</fname>
<namespace></namespace>
<description>Returns a new datatype that represents equally-spaced blocks. The spacing between the start of each block is given in bytes.</description>
<prototype>
<returnType>int</returnType>
<name>MPI_Type_create_hvector</name>
<arguments>int, int, MPI_Aint, MPI_Datatype, MPI_Datatype *</arguments>
</prototype>
</function>

<function>
<cname>MPI_Type_create_indexed_block</cname>
<cppname>MPI::Datatype::Create_indexed_block</cppname>
<fname>MPI_TYPE_CREATE_INDEXED_BLOCK</fname>
<namespace></namespace>
<description>Returns a new datatype that representscount blocks.</description>
<prototype>
<returnType>int</returnType>
<name>MPI_Type_create_indexed_block</name>
<arguments>int, int, int [], MPI_Datatype, MPI_Datatype *</arguments>
</prototype>
</function>

<function>
<cname>MPI_Type_create_keyval</cname>
<cppname>MPI::Datatype::Create_keyval</cppname>
<fname>MPI_TYPE_CREATE_KEYVAL</fname>
<namespace></namespace>
<description>Generates a new attribute key for a datatype.</description>
<prototype>
<returnType>int</returnType>
<name>MPI_Type_create_keyval</name>
<arguments>MPI_Type_copy_attr_function *, MPI_Type_delete_attr_function *, int *, void *</arguments>
</prototype>
</function>

<function>
<cname>MPI_Type_create_resized</cname>
<cppname>MPI::Datatype::Create_resized</cppname>
<fname>MPI_TYPE_CREATE_RESIZED</fname>
<namespace></namespace>
<description>Duplicates a datatype and changes the upper bound, lower bound, and extent.</description>
<prototype>
<returnType>int</returnType>
<name>MPI_Type_create_resized</name>
<arguments>MPI_Datatype, MPI_Aint, MPI_Aint, MPI_Datatype *</arguments>
</prototype>
</function>

<function>
<cname>MPI_Type_create_struct</cname>
<cppname>MPI::Datatype::Create_struct</cppname>
<fname>MPI_TYPE_CREATE_STRUCT</fname>
<namespace></namespace>
<description>Returns a new datatype that representscount blocks. Each block is defined by an entry in array_of_blocklengths,array_of_displacements, and array_of_types. Displacements are expressed in bytes.</description>
<prototype>
<returnType>int</returnType>
<name>MPI_Type_create_struct</name>
<arguments>int, int [], MPI_Aint [], MPI_Datatype [], MPI_Datatype *</arguments>
</prototype>
</function>

<function>
<cname>MPI_Type_create_subarray</cname>
<cppname>MPI::Datatype::Create_subarray</cppname>
<fname>MPI_TYPE_CREATE_SUBARRAY</fname>
<namespace></namespace>
<description>Returns a new datatype that represents anndims-dimensional subarray of anndims-dimensional array.</description>
<prototype>
<returnType>int</returnType>
<name>MPI_Type_create_subarray</name>
<arguments>int, int [], int [], int [], int, MPI_Datatype, MPI_Datatype *</arguments>
</prototype>
</function>

<function>
<cname>MPI_Type_delete_attr</cname>
<cppname>MPI::Datatype::Delete_attr</cppname>
<fname>MPI_TYPE_DELETE_ATTR</fname>
<namespace></namespace>
<description>Deletes an attribute from a datatype.</description>
<prototype>
<returnType>int</returnType>
<name>MPI_Type_delete_attr</name>
<arguments>MPI_Datatype, int</arguments>
</prototype>
</function>

<function>
<cname>MPI_Type_dup</cname>
<cppname>MPI::Datatype::Dup</cppname>
<fname>MPI_TYPE_DUP</fname>
<namespace></namespace>
<description>Duplicates the existing type with associated key values.</description>
<prototype>
<returnType>int</returnType>
<name>MPI_Type_dup</name>
<arguments>MPI_Datatype, MPI_Datatype *</arguments>
</prototype>
</function>

<function>
<cname>MPI_Type_extent</cname>
<cppname>(none)</cppname>
<fname>MPI_TYPE_EXTENT</fname>
<namespace></namespace>
<description>Returns the extent of any defined datatype.</description>
<prototype>
<returnType>int</returnType>
<name>MPI_Type_extent</name>
<arguments>MPI_Datatype, MPI_Aint *</arguments>
</prototype>
</function>

<function>
<cname>MPI_Type_f2c</cname>
<cppname>(none)</cppname>
<fname>(none)</fname>
<namespace></namespace>
<description>Returns a C handle to a datatype.</description>
<prototype>
<returnType>MPI_Datatype</returnType>
<name>MPI_Type_f2c</name>
<arguments>MPI_Fint</arguments>
</prototype>
</function>

<function>
<cname>MPI_Type_free</cname>
<cppname>MPI::Datatype::Free</cppname>
<fname>MPI_TYPE_FREE</fname>
<namespace></namespace>
<description>Marks a derived datatype for deallocation and sets its handle to MPI_DATATYPE_NULL.</description>
<prototype>
<returnType>int</returnType>
<name>MPI_Type_free</name>
<arguments>MPI_Datatype *</arguments>
</prototype>
</function>

<function>
<cname>MPI_Type_free_keyval</cname>
<cppname>MPI::Datatype::Free_keyval</cppname>
<fname>MPI_TYPE_FREE_KEYVAL</fname>
<namespace></namespace>
<description>Frees a datatype key value.</description>
<prototype>
<returnType>int</returnType>
<name>MPI_Type_free_keyval</name>
<arguments>int *</arguments>
</prototype>
</function>

<function>
<cname>MPI_Type_get_attr</cname>
<cppname>MPI::Datatype::Get_attr</cppname>
<fname>MPI_TYPE_GET_ATTR</fname>
<namespace></namespace>
<description>Attaches an attribute to a datatype.</description>
<prototype>
<returnType>int</returnType>
<name>MPI_Type_get_attr</name>
<arguments>MPI_Datatype, int, void *, int *</arguments>
</prototype>
</function>

<function>
<cname>MPI_Type_get_contents</cname>
<cppname>MPI::Datatype::Get_contents</cppname>
<fname>MPI_TYPE_GET_CONTENTS</fname>
<namespace></namespace>
<description>Obtains the arguments used in the creation of the datatype.</description>
<prototype>
<returnType>int</returnType>
<name>MPI_Type_get_contents</name>
<arguments>MPI_Datatype, int, int, int, int [], MPI_Aint [], MPI_Datatype []</arguments>
</prototype>
</function>

<function>
<cname>MPI_Type_get_envelope</cname>
<cppname>MPI::Datatype::Get_envelope</cppname>
<fname>MPI_TYPE_GET_ENVELOPE</fname>
<namespace></namespace>
<description>Determines the constructor that was used to create the datatype.</description>
<prototype>
<returnType>int</returnType>
<name>MPI_Type_get_envelope</name>
<arguments>MPI_Datatype, int *, int *, int *, int *</arguments>
</prototype>
</function>

<function>
<cname>MPI_Type_get_extent</cname>
<cppname>MPI::Datatype::Get_extent</cppname>
<fname>MPI_TYPE_GET_EXTENT</fname>
<namespace></namespace>
<description>Returns the lower bound and the extent of any defined datatype.</description>
<prototype>
<returnType>int</returnType>
<name>MPI_Type_get_extent</name>
<arguments>MPI_Datatype, MPI_Aint *, MPI_Aint *</arguments>
</prototype>
</function>

<function>
<cname>MPI_Type_get_name</cname>
<cppname>MPI::Datatype::Get_name</cppname>
<fname>MPI_TYPE_GET_NAME</fname>
<namespace></namespace>
<description>Returns the name that was last associated with a datatype.</description>
<prototype>
<returnType>int</returnType>
<name>MPI_Type_get_name</name>
<arguments>MPI_Datatype, char *, int *</arguments>
</prototype>
</function>

<function>
<cname>MPI_Type_get_true_extent</cname>
<cppname>MPI::Datatype::Get_true_extent</cppname>
<fname>MPI_TYPE_GET_TRUE_EXTENT</fname>
<namespace></namespace>
<description>Returns the true extent of any defined datatype.</description>
<prototype>
<returnType>int</returnType>
<name>MPI_Type_get_true_extent</name>
<arguments>MPI_Datatype, MPI_Aint *, MPI_Aint *</arguments>
</prototype>
</function>

<function>
<cname>MPI_Type_hindexed</cname>
<cppname>(none)</cppname>
<fname>MPI_TYPE_HINDEXED</fname>
<namespace></namespace>
<description>Returns a new datatype that representscount distinct blocks with offsets expressed in bytes.</description>
<prototype>
<returnType>int</returnType>
<name>MPI_Type_hindexed</name>
<arguments>int, int *, MPI_Aint *, MPI_Datatype, MPI_Datatype *</arguments>
</prototype>
</function>

<function>
<cname>MPI_Type_hvector</cname>
<cppname>(none)</cppname>
<fname>MPI_TYPE_HVECTOR</fname>
<namespace></namespace>
<description>Returns a new datatype of count blocks with stride expressed in bytes.</description>
<prototype>
<returnType>int</returnType>
<name>MPI_Type_hvector</name>
<arguments>int, int, MPI_Aint, MPI_Datatype, MPI_Datatype *</arguments>
</prototype>
</function>

<function>
<cname>MPI_Type_indexed</cname>
<cppname>MPI::Datatype::Create_indexed</cppname>
<fname>MPI_TYPE_INDEXED</fname>
<namespace></namespace>
<description>Returns a new datatype that representscount blocks with stride in terms of defining type.</description>
<prototype>
<returnType>int</returnType>
<name>MPI_Type_indexed</name>
<arguments>int, int *, int *, MPI_Datatype, MPI_Datatype *</arguments>
</prototype>
</function>

<function>
<cname>MPI_Type_lb</cname>
<cppname>(none)</cppname>
<fname>MPI_TYPE_LB</fname>
<namespace></namespace>
<description>Returns the lower bound of a datatype.</description>
<prototype>
<returnType>int</returnType>
<name>MPI_Type_lb</name>
<arguments>MPI_Datatype, MPI_Aint *</arguments>
</prototype>
</function>

<function>
<cname>MPI_Type_match_size</cname>
<cppname>MPI::Datatype::Match_size</cppname>
<fname>MPI_TYPE_CREATE_MATCH_SIZE</fname>
<namespace></namespace>
<description>Returns a reference (handle) to one of the predefined named datatypes, not a duplicate.</description>
<prototype>
<returnType>int</returnType>
<name>MPI_Type_match_size</name>
<arguments> int, int, MPI_Datatype *</arguments>
</prototype>
</function>

<function>
<cname>MPI_Type_set_attr</cname>
<cppname>MPI::Datatype::Set_attr</cppname>
<fname>MPI_TYPE_SET_ATTR</fname>
<namespace></namespace>
<description>Attaches the datatype attribute value to the datatype and associates it with the key.</description>
<prototype>
<returnType>int</returnType>
<name>MPI_Type_set_attr</name>
<arguments>MPI_Datatype, int, void *</arguments>
</prototype>
</function>

<function>
<cname>MPI_Type_set_name</cname>
<cppname>MPI::Datatype::Set_name</cppname>
<fname>MPI_TYPE_SET_NAME</fname>
<namespace></namespace>
<description>Associates a name string with a datatype.</description>
<prototype>
<returnType>int</returnType>
<name>MPI_Type_set_name</name>
<arguments>MPI_Datatype, char *</arguments>
</prototype>
</function>

<function>
<cname>MPI_Type_size</cname>
<cppname>MPI::Datatype::Get_size</cppname>
<fname>MPI_TYPE_SIZE</fname>
<namespace></namespace>
<description>Returns the number of bytes represented by any defined datatype.</description>
<prototype>
<returnType>int</returnType>
<name>MPI_Type_size</name>
<arguments>MPI_Datatype, int *</arguments>
</prototype>
</function>

<function>
<cname>MPI_Type_struct</cname>
<cppname>(none)</cppname>
<fname>MPI_TYPE_STRUCT</fname>
<namespace></namespace>
<description>Returns a new datatype that representscount blocks, each with a distinct format and offset.</description>
<prototype>
<returnType>int</returnType>
<name>MPI_Type_struct</name>
<arguments>int, int *, MPI_Aint *, MPI_Datatype *, MPI_Datatype *</arguments>
</prototype>
</function>

<function>
<cname>MPI_Type_ub</cname>
<cppname>(none)</cppname>
<fname>MPI_TYPE_UB</fname>
<namespace></namespace>
<description>Returns the upper bound of a datatype.</description>
<prototype>
<returnType>int</returnType>
<name>MPI_Type_ub</name>
<arguments>MPI_Datatype, MPI_Aint *</arguments>
</prototype>
</function>

<function>
<cname>MPI_Type_vector</cname>
<cppname>MPI::Datatype::Create_vector</cppname>
<fname>MPI_TYPE_VECTOR</fname>
<namespace></namespace>
<description>Returns a new datatype that represents equally-spaced blocks of replicated data.</description>
<prototype>
<returnType>int</returnType>
<name>MPI_Type_vector</name>
<arguments>int, int, int, MPI_Datatype, MPI_Datatype *</arguments>
</prototype>
</function>

<function>
<cname>MPI_Unpack</cname>
<cppname>MPI::Datatype::Unpack</cppname>
<fname>MPI_UNPACK</fname>
<namespace></namespace>
<description>Unpacks the message into the specified receive buffer from the specified packed buffer.</description>
<prototype>
<returnType>int</returnType>
<name>MPI_Unpack</name>
<arguments>void*, int, int *, void *, int, MPI_Datatype, MPI_Comm</arguments>
</prototype>
</function>

<function>
<cname>MPI_Unpack_external</cname>
<cppname>MPI::Datatype::Unpack_external</cppname>
<fname>MPI_UNPACK_EXTERNAL</fname>
<namespace></namespace>
<description>Unpacks the message into the specified receive buffer from the specified packed buffer, using the external32 data format.</description>
<prototype>
<returnType>int</returnType>
<name>MPI_Unpack_external</name>
<arguments>char *, void *, MPI_Aint, MPI_Aint *, void *, int, MPI_Datatype</arguments>
</prototype>
</function>

<function>
<cname>MPI_Unpublish_name</cname>
<cppname>MPI::Unpublish_name</cppname>
<fname>MPI_UNPUBLISH_NAME</fname>
<namespace></namespace>
<description>Publishes a service name.</description>
<prototype>
<returnType>int</returnType>
<name>MPI_Unpublish_name</name>
<arguments>char *, MPI_Info, char *</arguments>
</prototype>
</function>

<function>
<cname>MPI_Wait</cname>
<cppname>MPI::Request::Wait</cppname>
<fname>MPI_WAIT</fname>
<namespace></namespace>
<description>Waits for a non-blocking operation to complete.</description>
<prototype>
<returnType>int</returnType>
<name>MPI_Wait</name>
<arguments>MPI_Request *, MPI_Status *</arguments>
</prototype>
</function>

<function>
<cname>MPI_Waitall</cname>
<cppname>MPI::Request::Waitall</cppname>
<fname>MPI_WAITALL</fname>
<namespace></namespace>
<description>Waits for a collection of non-blocking operations to complete.</description>
<prototype>
<returnType>int</returnType>
<name>MPI_Waitall</name>
<arguments>int, MPI_Request *, MPI_Status *</arguments>
</prototype>
</function>

<function>
<cname>MPI_Waitany</cname>
<cppname>MPI::Request::Waitany</cppname>
<fname>MPI_WAITANY</fname>
<namespace></namespace>
<description>Waits for any specified non-blocking operation to complete.</description>
<prototype>
<returnType>int</returnType>
<name>MPI_Waitany</name>
<arguments>int, MPI_Request *, int *, MPI_Status *</arguments>
</prototype>
</function>

<function>
<cname>MPI_Waitsome</cname>
<cppname>MPI::Request::Waitsome</cppname>
<fname>MPI_WAITSOME</fname>
<namespace></namespace>
<description>Waits for at least one of a list of non-blocking operations to complete.</description>
<prototype>
<returnType>int</returnType>
<name>MPI_Waitsome</name>
<arguments>int, MPI_Request *, int *, int *, MPI_Status *</arguments>
</prototype>
</function>

<function>
<cname>MPI_Win_c2f</cname>
<cppname>(none)</cppname>
<fname>(none)</fname>
<namespace></namespace>
<description>Translates a C window handle into a FORTRAN handle to the same window.</description>
<prototype>
<returnType>MPI_Fint</returnType>
<name>MPI_Win_c2f</name>
<arguments>MPI_Win</arguments>
</prototype>
</function>

<function>
<cname>MPI_Win_call_errhandler</cname>
<cppname>MPI::Win::Call_errhandler</cppname>
<fname>MPI_WIN_CALL_ERRHANDLER</fname>
<namespace></namespace>