Upgrade macos
This commit is contained in:
Bassem Girgis
File diff suppressed because it is too large
Load Diff
@@ -1,18 +0,0 @@
|
||||
<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML3.2 EN">
|
||||
<HTML>
|
||||
<HEAD>
|
||||
<META NAME="GENERATOR" CONTENT="DOCTEXT">
|
||||
<TITLE>MPIR_Type_commit</TITLE>
|
||||
</HEAD>
|
||||
<BODY BGCOLOR="FFFFFF">
|
||||
<A NAME="MPIR_Type_commit"><H1>MPIR_Type_commit</H1></A>
|
||||
nput Parameters: . datatype_p - pointer to MPI datatype
|
||||
<H2>Synopsis</H2>
|
||||
<PRE>
|
||||
int MPIR_Type_commit(MPI_Datatype * datatype_p)
|
||||
</PRE>
|
||||
<H2>Output Parameters</H2>
|
||||
<P>
|
||||
<H2>Return Value</H2>
|
||||
0 on success, -1 on failure.
|
||||
</BODY></HTML>
|
||||
@@ -1,27 +0,0 @@
|
||||
<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML3.2 EN">
|
||||
<HTML>
|
||||
<HEAD>
|
||||
<META NAME="GENERATOR" CONTENT="DOCTEXT">
|
||||
<TITLE>MPIR_Type_contiguous</TITLE>
|
||||
</HEAD>
|
||||
<BODY BGCOLOR="FFFFFF">
|
||||
<A NAME="MPIR_Type_contiguous"><H1>MPIR_Type_contiguous</H1></A>
|
||||
create a contiguous datatype
|
||||
<H2>Synopsis</H2>
|
||||
<PRE>
|
||||
int MPIR_Type_contiguous(int count, MPI_Datatype oldtype, MPI_Datatype * newtype)
|
||||
</PRE>
|
||||
<H2>Input Parameters</H2>
|
||||
<DL>
|
||||
<DT><B>count </B><DD>number of elements in the contiguous block
|
||||
|
||||
<DT><B>oldtype </B><DD>type (using handle) of datatype on which vector is based
|
||||
</DL>
|
||||
<P>
|
||||
<H2>Output Parameters</H2>
|
||||
<DL><DT><B>newtype </B> <DD> handle of new contiguous datatype
|
||||
</DL>
|
||||
<P>
|
||||
<H2>Return Value</H2>
|
||||
MPI_SUCCESS on success, MPI error code on failure.
|
||||
</BODY></HTML>
|
||||
@@ -1,29 +0,0 @@
|
||||
<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML3.2 EN">
|
||||
<HTML>
|
||||
<HEAD>
|
||||
<META NAME="GENERATOR" CONTENT="DOCTEXT">
|
||||
<TITLE>MPIR_Type_dup</TITLE>
|
||||
</HEAD>
|
||||
<BODY BGCOLOR="FFFFFF">
|
||||
<A NAME="MPIR_Type_dup"><H1>MPIR_Type_dup</H1></A>
|
||||
create a copy of a datatype
|
||||
<H2>Synopsis</H2>
|
||||
<PRE>
|
||||
#undef FUNCNAME
|
||||
#define FUNCNAME MPIR_Type_dup
|
||||
#undef FCNAME
|
||||
#define FCNAME MPL_QUOTE(FUNCNAME)
|
||||
int MPIR_Type_dup(MPI_Datatype oldtype, MPI_Datatype * newtype)
|
||||
</PRE>
|
||||
<H2>Input Parameters</H2>
|
||||
<DL><DT><B>oldtype </B> <DD> handle of original datatype
|
||||
</DL>
|
||||
</DL>
|
||||
<P>
|
||||
<H2>Output Parameters</H2>
|
||||
<DL><DT><B>newtype </B> <DD> handle of newly created copy of datatype
|
||||
</DL>
|
||||
<P>
|
||||
<H2>Return Value</H2>
|
||||
0 on success, MPI error code on failure.
|
||||
</BODY></HTML>
|
||||
@@ -1,39 +0,0 @@
|
||||
<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML3.2 EN">
|
||||
<HTML>
|
||||
<HEAD>
|
||||
<META NAME="GENERATOR" CONTENT="DOCTEXT">
|
||||
<TITLE>MPIR_Type_get_contents</TITLE>
|
||||
</HEAD>
|
||||
<BODY BGCOLOR="FFFFFF">
|
||||
<A NAME="MPIR_Type_get_contents"><H1>MPIR_Type_get_contents</H1></A>
|
||||
get content information from datatype
|
||||
<H2>Synopsis</H2>
|
||||
<PRE>
|
||||
int MPIR_Type_get_contents(MPI_Datatype datatype,
|
||||
int max_integers,
|
||||
int max_addresses,
|
||||
int max_datatypes,
|
||||
int array_of_integers[],
|
||||
MPI_Aint array_of_addresses[], MPI_Datatype array_of_datatypes[])
|
||||
</PRE>
|
||||
<H2>Input Parameters</H2>
|
||||
<DL>
|
||||
<DT><B>datatype </B><DD>MPI datatype
|
||||
|
||||
<DT><B>max_integers </B><DD>size of array_of_integers
|
||||
|
||||
<DT><B>max_addresses </B><DD>size of array_of_addresses
|
||||
|
||||
<DT><B>max_datatypes </B><DD>size of array_of_datatypes
|
||||
</DL>
|
||||
<P>
|
||||
<H2>Output Parameters</H2>
|
||||
<DL>
|
||||
<DT><B>array_of_integers </B><DD>integers used in creating type
|
||||
|
||||
<DT><B>array_of_addresses </B><DD>MPI_Aints used in creating type
|
||||
|
||||
<DT><B>array_of_datatypes </B><DD>MPI_Datatypes used in creating type
|
||||
</DL>
|
||||
<P>
|
||||
</BODY></HTML>
|
||||
@@ -1,39 +0,0 @@
|
||||
<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML3.2 EN">
|
||||
<HTML>
|
||||
<HEAD>
|
||||
<META NAME="GENERATOR" CONTENT="DOCTEXT">
|
||||
<TITLE>MPIR_Type_indexed</TITLE>
|
||||
</HEAD>
|
||||
<BODY BGCOLOR="FFFFFF">
|
||||
<A NAME="MPIR_Type_indexed"><H1>MPIR_Type_indexed</H1></A>
|
||||
create an indexed datatype
|
||||
<H2>Synopsis</H2>
|
||||
<PRE>
|
||||
int MPIR_Type_indexed(int count,
|
||||
const int *blocklength_array,
|
||||
const void *displacement_array,
|
||||
int dispinbytes, MPI_Datatype oldtype, MPI_Datatype * newtype)
|
||||
</PRE>
|
||||
<H2>Input Parameters</H2>
|
||||
<DL>
|
||||
<DT><B>count </B><DD>number of blocks in type
|
||||
|
||||
<DT><B>blocklength_array </B><DD>number of elements in each block
|
||||
|
||||
<DT><B>displacement_array </B><DD>offsets of blocks from start of type (see next
|
||||
parameter for units)
|
||||
|
||||
<DT><B>dispinbytes </B><DD>if nonzero, then displacements are in bytes (the
|
||||
displacement_array is an array of ints), otherwise they in terms of
|
||||
extent of oldtype (the displacement_array is an array of MPI_Aints)
|
||||
|
||||
<DT><B>oldtype </B><DD>type (using handle) of datatype on which new type is based
|
||||
</DL>
|
||||
<P>
|
||||
<H2>Output Parameters</H2>
|
||||
<DL><DT><B>newtype </B> <DD> handle of new indexed datatype
|
||||
</DL>
|
||||
<P>
|
||||
<H2>Return Value</H2>
|
||||
0 on success, -1 on failure.
|
||||
</BODY></HTML>
|
||||
@@ -1,38 +0,0 @@
|
||||
<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML3.2 EN">
|
||||
<HTML>
|
||||
<HEAD>
|
||||
<META NAME="GENERATOR" CONTENT="DOCTEXT">
|
||||
<TITLE>MPIR_Type_struct</TITLE>
|
||||
</HEAD>
|
||||
<BODY BGCOLOR="FFFFFF">
|
||||
<A NAME="MPIR_Type_struct"><H1>MPIR_Type_struct</H1></A>
|
||||
create a struct datatype
|
||||
<H2>Synopsis</H2>
|
||||
<PRE>
|
||||
#undef FUNCNAME
|
||||
#define FUNCNAME MPIR_Type_struct
|
||||
#undef FCNAME
|
||||
#define FCNAME MPL_QUOTE(FUNCNAME)
|
||||
int MPIR_Type_struct(int count,
|
||||
const int *blocklength_array,
|
||||
const MPI_Aint * displacement_array,
|
||||
const MPI_Datatype * oldtype_array, MPI_Datatype * newtype)
|
||||
</PRE>
|
||||
<H2>Input Parameters</H2>
|
||||
<DL>
|
||||
<DT><B>count </B><DD>number of blocks in vector
|
||||
|
||||
<DT><B>blocklength_array </B><DD>number of elements in each block
|
||||
|
||||
<DT><B>displacement_array </B><DD>offsets of blocks from start of type in bytes
|
||||
|
||||
<DT><B>oldtype_array </B><DD>types (using handle) of datatypes on which vector is based
|
||||
</DL>
|
||||
<P>
|
||||
<H2>Output Parameters</H2>
|
||||
<DL><DT><B>newtype </B> <DD> handle of new struct datatype
|
||||
</DL>
|
||||
<P>
|
||||
<H2>Return Value</H2>
|
||||
MPI_SUCCESS on success, MPI errno on failure.
|
||||
</BODY></HTML>
|
||||
@@ -1,38 +0,0 @@
|
||||
<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML3.2 EN">
|
||||
<HTML>
|
||||
<HEAD>
|
||||
<META NAME="GENERATOR" CONTENT="DOCTEXT">
|
||||
<TITLE>MPIR_Type_vector</TITLE>
|
||||
</HEAD>
|
||||
<BODY BGCOLOR="FFFFFF">
|
||||
<A NAME="MPIR_Type_vector"><H1>MPIR_Type_vector</H1></A>
|
||||
create a vector datatype
|
||||
<H2>Synopsis</H2>
|
||||
<PRE>
|
||||
int MPIR_Type_vector(int count,
|
||||
int blocklength,
|
||||
MPI_Aint stride,
|
||||
int strideinbytes, MPI_Datatype oldtype, MPI_Datatype * newtype)
|
||||
</PRE>
|
||||
<H2>Input Parameters</H2>
|
||||
<DL>
|
||||
<DT><B>count </B><DD>number of blocks in vector
|
||||
|
||||
<DT><B>blocklength </B><DD>number of elements in each block
|
||||
|
||||
<DT><B>stride </B><DD>distance from beginning of one block to the next (see next
|
||||
parameter for units)
|
||||
|
||||
<DT><B>strideinbytes </B><DD>if nonzero, then stride is in bytes, otherwise stride
|
||||
is in terms of extent of oldtype
|
||||
|
||||
<DT><B>oldtype </B><DD>type (using handle) of datatype on which vector is based
|
||||
</DL>
|
||||
<P>
|
||||
<H2>Output Parameters</H2>
|
||||
<DL><DT><B>newtype </B> <DD> handle of new vector datatype
|
||||
</DL>
|
||||
<P>
|
||||
<H2>Return Value</H2>
|
||||
0 on success, MPI error code on failure.
|
||||
</BODY></HTML>
|
||||
@@ -0,0 +1,110 @@
|
||||
<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML3.2 EN">
|
||||
<HTML>
|
||||
<HEAD>
|
||||
<META NAME="GENERATOR" CONTENT="DOCTEXT">
|
||||
<TITLE>MPIX_Allreduce_enqueue</TITLE>
|
||||
</HEAD>
|
||||
<BODY BGCOLOR="FFFFFF">
|
||||
<H1 id="MPIX_Allreduce_enqueue">MPIX_Allreduce_enqueue</H1>
|
||||
Enqueue an allreduce operation to a GPU stream that is associated with the local stream
|
||||
<H2>Synopsis</H2>
|
||||
<PRE>
|
||||
</PRE>
|
||||
<PRE>
|
||||
int MPIX_Allreduce_enqueue(const void *sendbuf, void *recvbuf, int count,
|
||||
MPI_Datatype datatype, MPI_Op op, MPI_Comm comm)
|
||||
</PRE>
|
||||
|
||||
<PRE>
|
||||
int MPIX_Allreduce_enqueue_c(const void *sendbuf, void *recvbuf,
|
||||
MPI_Count count, MPI_Datatype datatype, MPI_Op op,
|
||||
MPI_Comm comm)
|
||||
</PRE>
|
||||
|
||||
<P>
|
||||
<H2>Input Parameters</H2>
|
||||
<DL>
|
||||
<DT><B>sendbuf </B> <DD> starting address of send buffer (choice)
|
||||
|
||||
<DT><B>count </B> <DD> number of elements in send buffer (non-negative integer)
|
||||
|
||||
<DT><B>datatype </B> <DD> data type of elements of send buffer (handle)
|
||||
|
||||
<DT><B>op </B> <DD> operation (handle)
|
||||
|
||||
<DT><B>comm </B> <DD> communicator (handle)
|
||||
</DL>
|
||||
<P>
|
||||
<H2>Output Parameters</H2>
|
||||
<DL>
|
||||
<DT><B>recvbuf </B> <DD> starting address of receive buffer (choice)
|
||||
</DL>
|
||||
<P>
|
||||
<H2>Thread and Interrupt Safety</H2>
|
||||
<P>
|
||||
This routine is thread-safe. This means that this routine may be
|
||||
safely used by multiple threads without the need for any user-provided
|
||||
thread locks. However, the routine is not interrupt safe. Typically,
|
||||
this is due to the use of memory allocation routines such as <tt>malloc
|
||||
</tt>or other non-MPICH runtime routines that are themselves not interrupt-safe.
|
||||
<P>
|
||||
<H2>Notes for Fortran</H2>
|
||||
All MPI routines in Fortran (except for <tt>MPI_WTIME</tt> and <tt>MPI_WTICK</tt>) have
|
||||
an additional argument <tt>ierr</tt> at the end of the argument list. <tt>ierr
|
||||
</tt>is an integer and has the same meaning as the return value of the routine
|
||||
in C. In Fortran, MPI routines are subroutines, and are invoked with the
|
||||
<tt>call</tt> statement.
|
||||
<P>
|
||||
All MPI objects (e.g., <tt>MPI_Datatype</tt>, <tt>MPI_Comm</tt>) are of type <tt>INTEGER
|
||||
</tt>in Fortran.
|
||||
<P>
|
||||
<H2>Errors</H2>
|
||||
<P>
|
||||
All MPI routines (except <tt>MPI_Wtime</tt> and <tt>MPI_Wtick</tt>) return an error value;
|
||||
C routines as the value of the function and Fortran routines in the last
|
||||
argument. Before the value is returned, the current MPI error handler is
|
||||
called. By default, this error handler aborts the MPI job. The error handler
|
||||
may be changed with <tt>MPI_Comm_set_errhandler</tt> (for communicators),
|
||||
<tt>MPI_File_set_errhandler</tt> (for files), and <tt>MPI_Win_set_errhandler</tt> (for
|
||||
RMA windows). The MPI-1 routine <tt>MPI_Errhandler_set</tt> may be used but
|
||||
its use is deprecated. The predefined error handler
|
||||
<tt>MPI_ERRORS_RETURN</tt> may be used to cause error values to be returned.
|
||||
Note that MPI does <em>not</em> guarantee that an MPI program can continue past
|
||||
an error; however, MPI implementations will attempt to continue whenever
|
||||
possible.
|
||||
<P>
|
||||
<DL>
|
||||
<DT><B>MPI_SUCCESS </B> <DD> No error; MPI routine completed successfully.
|
||||
</DL>
|
||||
<DL>
|
||||
<DT><B>MPI_ERR_ARG </B> <DD> Invalid argument. Some argument is invalid and is not
|
||||
identified by a specific error class (e.g., <tt>MPI_ERR_RANK</tt>).
|
||||
</DL>
|
||||
<DL>
|
||||
<DT><B>MPI_ERR_BUFFER </B> <DD> Invalid buffer pointer. Usually a null buffer where
|
||||
one is not valid.
|
||||
</DL>
|
||||
<DL>
|
||||
<DT><B>MPI_ERR_COMM </B> <DD> Invalid communicator. A common error is to use a null
|
||||
communicator in a call (not even allowed in <tt>MPI_Comm_rank</tt>).
|
||||
</DL>
|
||||
<DL>
|
||||
<DT><B>MPI_ERR_COUNT </B> <DD> Invalid count argument. Count arguments must be
|
||||
non-negative; a count of zero is often valid.
|
||||
</DL>
|
||||
<DL>
|
||||
<DT><B>MPI_ERR_OP </B> <DD> Invalid operation. MPI operations (objects of type <tt>MPI_Op</tt>)
|
||||
must either be one of the predefined operations (e.g., <tt>MPI_SUM</tt>) or
|
||||
created with <tt>MPI_Op_create</tt>.
|
||||
</DL>
|
||||
<DL>
|
||||
<DT><B>MPI_ERR_TYPE </B> <DD> Invalid datatype argument. Additionally, this error can
|
||||
occur if an uncommitted MPI_Datatype (see <tt>MPI_Type_commit</tt>) is used
|
||||
in a communication call.
|
||||
</DL>
|
||||
<DL>
|
||||
<DT><B>MPI_ERR_OTHER </B> <DD> Other error; use <tt>MPI_Error_string</tt> to get more information
|
||||
about this error code.
|
||||
</DL>
|
||||
<P>
|
||||
</BODY></HTML>
|
||||
@@ -0,0 +1 @@
|
||||
<meta http-equiv="refresh" content="0; url=MPIX_Allreduce_enqueue.html">
|
||||
@@ -0,0 +1,64 @@
|
||||
<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML3.2 EN">
|
||||
<HTML>
|
||||
<HEAD>
|
||||
<META NAME="GENERATOR" CONTENT="DOCTEXT">
|
||||
<TITLE>MPIX_Async_get_state</TITLE>
|
||||
</HEAD>
|
||||
<BODY BGCOLOR="FFFFFF">
|
||||
<H1 id="MPIX_Async_get_state">MPIX_Async_get_state</H1>
|
||||
[short description]
|
||||
<H2>Synopsis</H2>
|
||||
<PRE>
|
||||
</PRE>
|
||||
<PRE>
|
||||
void * MPIX_Async_get_state(MPIX_Async_thing async_thing)
|
||||
</PRE>
|
||||
|
||||
<P>
|
||||
<H2>Input Parameters</H2>
|
||||
<DL>
|
||||
<DT><B>async_thing </B> <DD> opaque pointer for async thing (None)
|
||||
</DL>
|
||||
<P>
|
||||
<H2>Thread and Interrupt Safety</H2>
|
||||
<P>
|
||||
This routine is thread-safe. This means that this routine may be
|
||||
safely used by multiple threads without the need for any user-provided
|
||||
thread locks. However, the routine is not interrupt safe. Typically,
|
||||
this is due to the use of memory allocation routines such as <tt>malloc
|
||||
</tt>or other non-MPICH runtime routines that are themselves not interrupt-safe.
|
||||
<P>
|
||||
<H2>Notes for Fortran</H2>
|
||||
All MPI routines in Fortran (except for <tt>MPI_WTIME</tt> and <tt>MPI_WTICK</tt>) have
|
||||
an additional argument <tt>ierr</tt> at the end of the argument list. <tt>ierr
|
||||
</tt>is an integer and has the same meaning as the return value of the routine
|
||||
in C. In Fortran, MPI routines are subroutines, and are invoked with the
|
||||
<tt>call</tt> statement.
|
||||
<P>
|
||||
All MPI objects (e.g., <tt>MPI_Datatype</tt>, <tt>MPI_Comm</tt>) are of type <tt>INTEGER
|
||||
</tt>in Fortran.
|
||||
<P>
|
||||
<H2>Errors</H2>
|
||||
<P>
|
||||
All MPI routines (except <tt>MPI_Wtime</tt> and <tt>MPI_Wtick</tt>) return an error value;
|
||||
C routines as the value of the function and Fortran routines in the last
|
||||
argument. Before the value is returned, the current MPI error handler is
|
||||
called. By default, this error handler aborts the MPI job. The error handler
|
||||
may be changed with <tt>MPI_Comm_set_errhandler</tt> (for communicators),
|
||||
<tt>MPI_File_set_errhandler</tt> (for files), and <tt>MPI_Win_set_errhandler</tt> (for
|
||||
RMA windows). The MPI-1 routine <tt>MPI_Errhandler_set</tt> may be used but
|
||||
its use is deprecated. The predefined error handler
|
||||
<tt>MPI_ERRORS_RETURN</tt> may be used to cause error values to be returned.
|
||||
Note that MPI does <em>not</em> guarantee that an MPI program can continue past
|
||||
an error; however, MPI implementations will attempt to continue whenever
|
||||
possible.
|
||||
<P>
|
||||
<DL>
|
||||
<DT><B>MPI_SUCCESS </B> <DD> No error; MPI routine completed successfully.
|
||||
</DL>
|
||||
<DL>
|
||||
<DT><B>MPI_ERR_OTHER </B> <DD> Other error; use <tt>MPI_Error_string</tt> to get more information
|
||||
about this error code.
|
||||
</DL>
|
||||
<P>
|
||||
</BODY></HTML>
|
||||
76
macx64/mpi/mpich/share/doc/mpich/www3/MPIX_Async_spawn.html
Normal file
76
macx64/mpi/mpich/share/doc/mpich/www3/MPIX_Async_spawn.html
Normal file
@@ -0,0 +1,76 @@
|
||||
<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML3.2 EN">
|
||||
<HTML>
|
||||
<HEAD>
|
||||
<META NAME="GENERATOR" CONTENT="DOCTEXT">
|
||||
<TITLE>MPIX_Async_spawn</TITLE>
|
||||
</HEAD>
|
||||
<BODY BGCOLOR="FFFFFF">
|
||||
<H1 id="MPIX_Async_spawn">MPIX_Async_spawn</H1>
|
||||
[short description]
|
||||
<H2>Synopsis</H2>
|
||||
<PRE>
|
||||
</PRE>
|
||||
<PRE>
|
||||
int MPIX_Async_spawn(MPIX_Async_thing async_thing,
|
||||
MPIX_Async_poll_function *poll_fn, void *extra_state,
|
||||
MPIX_Stream stream)
|
||||
</PRE>
|
||||
|
||||
<P>
|
||||
<H2>Input Parameters</H2>
|
||||
<DL>
|
||||
<DT><B>async_thing </B> <DD> opaque pointer for async thing (None)
|
||||
|
||||
<DT><B>poll_fn </B> <DD> user defined poll function for progressing async things (function)
|
||||
|
||||
<DT><B>extra_state </B> <DD> extra state for callback function (None)
|
||||
|
||||
<DT><B>stream </B> <DD> stream object (handle)
|
||||
</DL>
|
||||
<P>
|
||||
<H2>Thread and Interrupt Safety</H2>
|
||||
<P>
|
||||
This routine is thread-safe. This means that this routine may be
|
||||
safely used by multiple threads without the need for any user-provided
|
||||
thread locks. However, the routine is not interrupt safe. Typically,
|
||||
this is due to the use of memory allocation routines such as <tt>malloc
|
||||
</tt>or other non-MPICH runtime routines that are themselves not interrupt-safe.
|
||||
<P>
|
||||
<H2>Notes for Fortran</H2>
|
||||
All MPI routines in Fortran (except for <tt>MPI_WTIME</tt> and <tt>MPI_WTICK</tt>) have
|
||||
an additional argument <tt>ierr</tt> at the end of the argument list. <tt>ierr
|
||||
</tt>is an integer and has the same meaning as the return value of the routine
|
||||
in C. In Fortran, MPI routines are subroutines, and are invoked with the
|
||||
<tt>call</tt> statement.
|
||||
<P>
|
||||
All MPI objects (e.g., <tt>MPI_Datatype</tt>, <tt>MPI_Comm</tt>) are of type <tt>INTEGER
|
||||
</tt>in Fortran.
|
||||
<P>
|
||||
<H2>Errors</H2>
|
||||
<P>
|
||||
All MPI routines (except <tt>MPI_Wtime</tt> and <tt>MPI_Wtick</tt>) return an error value;
|
||||
C routines as the value of the function and Fortran routines in the last
|
||||
argument. Before the value is returned, the current MPI error handler is
|
||||
called. By default, this error handler aborts the MPI job. The error handler
|
||||
may be changed with <tt>MPI_Comm_set_errhandler</tt> (for communicators),
|
||||
<tt>MPI_File_set_errhandler</tt> (for files), and <tt>MPI_Win_set_errhandler</tt> (for
|
||||
RMA windows). The MPI-1 routine <tt>MPI_Errhandler_set</tt> may be used but
|
||||
its use is deprecated. The predefined error handler
|
||||
<tt>MPI_ERRORS_RETURN</tt> may be used to cause error values to be returned.
|
||||
Note that MPI does <em>not</em> guarantee that an MPI program can continue past
|
||||
an error; however, MPI implementations will attempt to continue whenever
|
||||
possible.
|
||||
<P>
|
||||
<DL>
|
||||
<DT><B>MPI_SUCCESS </B> <DD> No error; MPI routine completed successfully.
|
||||
</DL>
|
||||
<DL>
|
||||
<DT><B>MPI_ERR_ARG </B> <DD> Invalid argument. Some argument is invalid and is not
|
||||
identified by a specific error class (e.g., <tt>MPI_ERR_RANK</tt>).
|
||||
</DL>
|
||||
<DL>
|
||||
<DT><B>MPI_ERR_OTHER </B> <DD> Other error; use <tt>MPI_Error_string</tt> to get more information
|
||||
about this error code.
|
||||
</DL>
|
||||
<P>
|
||||
</BODY></HTML>
|
||||
73
macx64/mpi/mpich/share/doc/mpich/www3/MPIX_Async_start.html
Normal file
73
macx64/mpi/mpich/share/doc/mpich/www3/MPIX_Async_start.html
Normal file
@@ -0,0 +1,73 @@
|
||||
<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML3.2 EN">
|
||||
<HTML>
|
||||
<HEAD>
|
||||
<META NAME="GENERATOR" CONTENT="DOCTEXT">
|
||||
<TITLE>MPIX_Async_start</TITLE>
|
||||
</HEAD>
|
||||
<BODY BGCOLOR="FFFFFF">
|
||||
<H1 id="MPIX_Async_start">MPIX_Async_start</H1>
|
||||
[short description]
|
||||
<H2>Synopsis</H2>
|
||||
<PRE>
|
||||
</PRE>
|
||||
<PRE>
|
||||
int MPIX_Async_start(MPIX_Async_poll_function *poll_fn, void *extra_state,
|
||||
MPIX_Stream stream)
|
||||
</PRE>
|
||||
|
||||
<P>
|
||||
<H2>Input Parameters</H2>
|
||||
<DL>
|
||||
<DT><B>poll_fn </B> <DD> user defined poll function for progressing async things (function)
|
||||
|
||||
<DT><B>extra_state </B> <DD> extra state for callback function (None)
|
||||
|
||||
<DT><B>stream </B> <DD> stream object (handle)
|
||||
</DL>
|
||||
<P>
|
||||
<H2>Thread and Interrupt Safety</H2>
|
||||
<P>
|
||||
This routine is thread-safe. This means that this routine may be
|
||||
safely used by multiple threads without the need for any user-provided
|
||||
thread locks. However, the routine is not interrupt safe. Typically,
|
||||
this is due to the use of memory allocation routines such as <tt>malloc
|
||||
</tt>or other non-MPICH runtime routines that are themselves not interrupt-safe.
|
||||
<P>
|
||||
<H2>Notes for Fortran</H2>
|
||||
All MPI routines in Fortran (except for <tt>MPI_WTIME</tt> and <tt>MPI_WTICK</tt>) have
|
||||
an additional argument <tt>ierr</tt> at the end of the argument list. <tt>ierr
|
||||
</tt>is an integer and has the same meaning as the return value of the routine
|
||||
in C. In Fortran, MPI routines are subroutines, and are invoked with the
|
||||
<tt>call</tt> statement.
|
||||
<P>
|
||||
All MPI objects (e.g., <tt>MPI_Datatype</tt>, <tt>MPI_Comm</tt>) are of type <tt>INTEGER
|
||||
</tt>in Fortran.
|
||||
<P>
|
||||
<H2>Errors</H2>
|
||||
<P>
|
||||
All MPI routines (except <tt>MPI_Wtime</tt> and <tt>MPI_Wtick</tt>) return an error value;
|
||||
C routines as the value of the function and Fortran routines in the last
|
||||
argument. Before the value is returned, the current MPI error handler is
|
||||
called. By default, this error handler aborts the MPI job. The error handler
|
||||
may be changed with <tt>MPI_Comm_set_errhandler</tt> (for communicators),
|
||||
<tt>MPI_File_set_errhandler</tt> (for files), and <tt>MPI_Win_set_errhandler</tt> (for
|
||||
RMA windows). The MPI-1 routine <tt>MPI_Errhandler_set</tt> may be used but
|
||||
its use is deprecated. The predefined error handler
|
||||
<tt>MPI_ERRORS_RETURN</tt> may be used to cause error values to be returned.
|
||||
Note that MPI does <em>not</em> guarantee that an MPI program can continue past
|
||||
an error; however, MPI implementations will attempt to continue whenever
|
||||
possible.
|
||||
<P>
|
||||
<DL>
|
||||
<DT><B>MPI_SUCCESS </B> <DD> No error; MPI routine completed successfully.
|
||||
</DL>
|
||||
<DL>
|
||||
<DT><B>MPI_ERR_ARG </B> <DD> Invalid argument. Some argument is invalid and is not
|
||||
identified by a specific error class (e.g., <tt>MPI_ERR_RANK</tt>).
|
||||
</DL>
|
||||
<DL>
|
||||
<DT><B>MPI_ERR_OTHER </B> <DD> Other error; use <tt>MPI_Error_string</tt> to get more information
|
||||
about this error code.
|
||||
</DL>
|
||||
<P>
|
||||
</BODY></HTML>
|
||||
@@ -5,57 +5,82 @@
|
||||
<TITLE>MPIX_Comm_agree</TITLE>
|
||||
</HEAD>
|
||||
<BODY BGCOLOR="FFFFFF">
|
||||
<A NAME="MPIX_Comm_agree"><H1>MPIX_Comm_agree</H1></A>
|
||||
<H1 id="MPIX_Comm_agree">MPIX_Comm_agree</H1>
|
||||
Performs agreement operation on comm
|
||||
<H2>Synopsis</H2>
|
||||
<PRE>
|
||||
</PRE>
|
||||
<PRE>
|
||||
int MPIX_Comm_agree(MPI_Comm comm, int *flag)
|
||||
</PRE>
|
||||
|
||||
<P>
|
||||
<H2>Input Parameters</H2>
|
||||
<DL><DT><B>comm </B> <DD> communicator (handle)
|
||||
<DL>
|
||||
<DT><B>comm </B> <DD> communicator (handle)
|
||||
</DL>
|
||||
<P>
|
||||
<H2>Output Parameters</H2>
|
||||
<DL><DT><B>newcomm </B> <DD> new communicator (handle)
|
||||
<DL>
|
||||
<DT><B>flag </B> <DD> new communicator (logical)
|
||||
</DL>
|
||||
<P>
|
||||
<H2>Notes</H2>
|
||||
The purpose of this collective communication is to agree on the integer value flag and on the group of failed processes in comm.
|
||||
<P>
|
||||
On completion, all non-failed MPI processes have agreed to set the output integer value of flag to the result of a bitwise AND operation over the contributed input values of flag. If comm is an intercommunicator, the value of flagis a bitwise AND operation over the values contributed by the remote group.
|
||||
<P>
|
||||
When an MPI process fails before contributing to the operation, the flag is computed ignoring its contribution, and MPIX_Comm_agree raises an error of class MPI_ERR_PROC_FAILED. However, if all MPI processes have acknowledged this failure priorto the call to MPIX_Comm_agree, using MPIX_Comm_failure_ack, the error related to this failure is not raised. When an error of class MPI_ERR_PROC_FAILED is raised, it is consistently raised at allMPI processes, in both the local and remote groups (if applicable).
|
||||
<P>
|
||||
After MPIX_Comm_agree raised an error of class MPI_ERR_PROC_FAILED, a subse-quent call to MPIX_Comm_failure_ack on comm acknowledges the failure of every MPI process that didn<tt>t contribute to the computation offlag.
|
||||
<P>
|
||||
<H2>Thread and Interrupt Safety</H2>
|
||||
<P>
|
||||
This routine is thread-safe. This means that this routine may be
|
||||
safely used by multiple threads without the need for any user-provided
|
||||
thread locks. However, the routine is not interrupt safe. Typically,
|
||||
this is due to the use of memory allocation routines such as <TT>malloc
|
||||
</TT>or other non-MPICH runtime routines that are themselves not interrupt-safe.
|
||||
this is due to the use of memory allocation routines such as </tt>malloc
|
||||
<tt>or other non-MPICH runtime routines that are themselves not interrupt-safe.
|
||||
<P>
|
||||
<H2>Notes for Fortran</H2>
|
||||
All MPI routines in Fortran (except for <TT>MPI_WTIME</TT> and <TT>MPI_WTICK</TT>) have
|
||||
an additional argument <TT>ierr</TT> at the end of the argument list. <TT>ierr
|
||||
</TT>is an integer and has the same meaning as the return value of the routine
|
||||
All MPI routines in Fortran (except for </tt>MPI_WTIME<tt> and </tt>MPI_WTICK<tt>) have
|
||||
an additional argument </tt>ierr<tt> at the end of the argument list. </tt>ierr
|
||||
<tt>is an integer and has the same meaning as the return value of the routine
|
||||
in C. In Fortran, MPI routines are subroutines, and are invoked with the
|
||||
<TT>call</TT> statement.
|
||||
</tt>call<tt> statement.
|
||||
<P>
|
||||
All MPI objects (e.g., <TT>MPI_Datatype</TT>, <TT>MPI_Comm</TT>) are of type <TT>INTEGER
|
||||
</TT>in Fortran.
|
||||
All MPI objects (e.g., </tt>MPI_Datatype<tt>, </tt>MPI_Comm<tt>) are of type </tt>INTEGER
|
||||
<tt>in Fortran.
|
||||
<P>
|
||||
<H2>Errors</H2>
|
||||
<P>
|
||||
All MPI routines (except <TT>MPI_Wtime</TT> and <TT>MPI_Wtick</TT>) return an error value;
|
||||
All MPI routines (except </tt>MPI_Wtime<tt> and </tt>MPI_Wtick<tt>) return an error value;
|
||||
C routines as the value of the function and Fortran routines in the last
|
||||
argument. Before the value is returned, the current MPI error handler is
|
||||
called. By default, this error handler aborts the MPI job. The error handler
|
||||
may be changed with <TT>MPI_Comm_set_errhandler</TT> (for communicators),
|
||||
<TT>MPI_File_set_errhandler</TT> (for files), and <TT>MPI_Win_set_errhandler</TT> (for
|
||||
RMA windows). The MPI-1 routine <TT>MPI_Errhandler_set</TT> may be used but
|
||||
may be changed with </tt>MPI_Comm_set_errhandler<tt> (for communicators),
|
||||
</tt>MPI_File_set_errhandler<tt> (for files), and </tt>MPI_Win_set_errhandler<tt> (for
|
||||
RMA windows). The MPI-1 routine </tt>MPI_Errhandler_set<tt> may be used but
|
||||
its use is deprecated. The predefined error handler
|
||||
<TT>MPI_ERRORS_RETURN</TT> may be used to cause error values to be returned.
|
||||
Note that MPI does <EM>not</EM> guarentee that an MPI program can continue past
|
||||
</tt>MPI_ERRORS_RETURN<tt> may be used to cause error values to be returned.
|
||||
Note that MPI does </tt><em>not</em> guarantee that an MPI program can continue past
|
||||
an error; however, MPI implementations will attempt to continue whenever
|
||||
possible.
|
||||
<P>
|
||||
<DL><DT><B>MPI_SUCCESS </B> <DD> No error; MPI routine completed successfully.
|
||||
<DL>
|
||||
<DT><B>MPI_SUCCESS </B> <DD> No error; MPI routine completed successfully.
|
||||
</DL>
|
||||
<DL><DT><B>MPI_ERR_COMM </B> <DD> Invalid communicator. A common error is to use a null
|
||||
communicator in a call (not even allowed in <TT>MPI_Comm_rank</TT>).
|
||||
<DL>
|
||||
<DT><B>MPI_ERR_ARG </B> <DD> Invalid argument. Some argument is invalid and is not
|
||||
identified by a specific error class (e.g., MPI_ERR_RANK<tt>).
|
||||
</DL>
|
||||
<DL>
|
||||
<DT><B>MPI_ERR_COMM </B> <DD> Invalid communicator. A common error is to use a null
|
||||
communicator in a call (not even allowed in </tt>MPI_Comm_rank<tt>).
|
||||
</DL>
|
||||
<DL>
|
||||
<DT><B>MPI_ERR_OTHER </B> <DD> Other error; use </tt>MPI_Error_string<tt> to get more information
|
||||
about this error code.
|
||||
</DL>
|
||||
<P>
|
||||
</BODY></HTML>
|
||||
|
||||
@@ -0,0 +1,80 @@
|
||||
<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML3.2 EN">
|
||||
<HTML>
|
||||
<HEAD>
|
||||
<META NAME="GENERATOR" CONTENT="DOCTEXT">
|
||||
<TITLE>MPIX_Comm_create_errhandler_x</TITLE>
|
||||
</HEAD>
|
||||
<BODY BGCOLOR="FFFFFF">
|
||||
<H1 id="MPIX_Comm_create_errhandler_x">MPIX_Comm_create_errhandler_x</H1>
|
||||
Creates an MPI-style communicator errorhandler with an extra_state
|
||||
<H2>Synopsis</H2>
|
||||
<PRE>
|
||||
</PRE>
|
||||
<PRE>
|
||||
int MPIX_Comm_create_errhandler_x(MPIX_Comm_errhandler_function_x *comm_errhandler_fn_x,
|
||||
MPIX_Destructor_function *destructor_fn,
|
||||
void *extra_state,
|
||||
MPI_Errhandler *errhandler)
|
||||
</PRE>
|
||||
|
||||
<P>
|
||||
<H2>Input Parameters</H2>
|
||||
<DL>
|
||||
<DT><B>comm_errhandler_fn_x </B> <DD> user defined error handling procedure with extra_state (function)
|
||||
|
||||
<DT><B>destructor_fn </B> <DD> callback when op is freed (function)
|
||||
|
||||
<DT><B>extra_state </B> <DD> extra state (None)
|
||||
</DL>
|
||||
<P>
|
||||
<H2>Output Parameters</H2>
|
||||
<DL>
|
||||
<DT><B>errhandler </B> <DD> MPI error handler (handle)
|
||||
</DL>
|
||||
<P>
|
||||
<H2>Thread and Interrupt Safety</H2>
|
||||
<P>
|
||||
This routine is thread-safe. This means that this routine may be
|
||||
safely used by multiple threads without the need for any user-provided
|
||||
thread locks. However, the routine is not interrupt safe. Typically,
|
||||
this is due to the use of memory allocation routines such as <tt>malloc
|
||||
</tt>or other non-MPICH runtime routines that are themselves not interrupt-safe.
|
||||
<P>
|
||||
<H2>Notes for Fortran</H2>
|
||||
All MPI routines in Fortran (except for <tt>MPI_WTIME</tt> and <tt>MPI_WTICK</tt>) have
|
||||
an additional argument <tt>ierr</tt> at the end of the argument list. <tt>ierr
|
||||
</tt>is an integer and has the same meaning as the return value of the routine
|
||||
in C. In Fortran, MPI routines are subroutines, and are invoked with the
|
||||
<tt>call</tt> statement.
|
||||
<P>
|
||||
All MPI objects (e.g., <tt>MPI_Datatype</tt>, <tt>MPI_Comm</tt>) are of type <tt>INTEGER
|
||||
</tt>in Fortran.
|
||||
<P>
|
||||
<H2>Errors</H2>
|
||||
<P>
|
||||
All MPI routines (except <tt>MPI_Wtime</tt> and <tt>MPI_Wtick</tt>) return an error value;
|
||||
C routines as the value of the function and Fortran routines in the last
|
||||
argument. Before the value is returned, the current MPI error handler is
|
||||
called. By default, this error handler aborts the MPI job. The error handler
|
||||
may be changed with <tt>MPI_Comm_set_errhandler</tt> (for communicators),
|
||||
<tt>MPI_File_set_errhandler</tt> (for files), and <tt>MPI_Win_set_errhandler</tt> (for
|
||||
RMA windows). The MPI-1 routine <tt>MPI_Errhandler_set</tt> may be used but
|
||||
its use is deprecated. The predefined error handler
|
||||
<tt>MPI_ERRORS_RETURN</tt> may be used to cause error values to be returned.
|
||||
Note that MPI does <em>not</em> guarantee that an MPI program can continue past
|
||||
an error; however, MPI implementations will attempt to continue whenever
|
||||
possible.
|
||||
<P>
|
||||
<DL>
|
||||
<DT><B>MPI_SUCCESS </B> <DD> No error; MPI routine completed successfully.
|
||||
</DL>
|
||||
<DL>
|
||||
<DT><B>MPI_ERR_ARG </B> <DD> Invalid argument. Some argument is invalid and is not
|
||||
identified by a specific error class (e.g., <tt>MPI_ERR_RANK</tt>).
|
||||
</DL>
|
||||
<DL>
|
||||
<DT><B>MPI_ERR_OTHER </B> <DD> Other error; use <tt>MPI_Error_string</tt> to get more information
|
||||
about this error code.
|
||||
</DL>
|
||||
<P>
|
||||
</BODY></HTML>
|
||||
@@ -5,57 +5,67 @@
|
||||
<TITLE>MPIX_Comm_failure_ack</TITLE>
|
||||
</HEAD>
|
||||
<BODY BGCOLOR="FFFFFF">
|
||||
<A NAME="MPIX_Comm_failure_ack"><H1>MPIX_Comm_failure_ack</H1></A>
|
||||
<H1 id="MPIX_Comm_failure_ack">MPIX_Comm_failure_ack</H1>
|
||||
Acknowledge the current group of failed processes
|
||||
<H2>Synopsis</H2>
|
||||
<PRE>
|
||||
</PRE>
|
||||
<PRE>
|
||||
int MPIX_Comm_failure_ack(MPI_Comm comm)
|
||||
</PRE>
|
||||
|
||||
<P>
|
||||
<H2>Input Parameters</H2>
|
||||
<DL><DT><B>comm </B> <DD> Communicator (handle)
|
||||
<DL>
|
||||
<DT><B>comm </B> <DD> communicator (handle)
|
||||
</DL>
|
||||
<P>
|
||||
<H2>Notes</H2>
|
||||
Because MPI specifies that null objects (e.g., <TT>MPI_COMM_NULL</TT>) are invalid
|
||||
as input to MPI routines unless otherwise specified, using <TT>MPI_COMM_NULL
|
||||
</TT>as input to this routine is an error.
|
||||
This local operation gives the users a way to acknowledge all locally notified failures on comm. After the call, unmatched MPI_ANY_SOURCE receive operations that would haveraised an error of class MPI_ERR_PROC_FAILED_PENDING due to MPI process failure proceed without further raising errors due to those acknowledged failures. Also after this call, MPIX_Comm_agree will not raise an error of class MPI_ERR_PROC_FAILED due to those acknowledged failures.
|
||||
<P>
|
||||
<H2>Thread and Interrupt Safety</H2>
|
||||
<P>
|
||||
This routine is thread-safe. This means that this routine may be
|
||||
safely used by multiple threads without the need for any user-provided
|
||||
thread locks. However, the routine is not interrupt safe. Typically,
|
||||
this is due to the use of memory allocation routines such as <TT>malloc
|
||||
</TT>or other non-MPICH runtime routines that are themselves not interrupt-safe.
|
||||
this is due to the use of memory allocation routines such as <tt>malloc
|
||||
</tt>or other non-MPICH runtime routines that are themselves not interrupt-safe.
|
||||
<P>
|
||||
<H2>Notes for Fortran</H2>
|
||||
All MPI routines in Fortran (except for <TT>MPI_WTIME</TT> and <TT>MPI_WTICK</TT>) have
|
||||
an additional argument <TT>ierr</TT> at the end of the argument list. <TT>ierr
|
||||
</TT>is an integer and has the same meaning as the return value of the routine
|
||||
All MPI routines in Fortran (except for <tt>MPI_WTIME</tt> and <tt>MPI_WTICK</tt>) have
|
||||
an additional argument <tt>ierr</tt> at the end of the argument list. <tt>ierr
|
||||
</tt>is an integer and has the same meaning as the return value of the routine
|
||||
in C. In Fortran, MPI routines are subroutines, and are invoked with the
|
||||
<TT>call</TT> statement.
|
||||
<tt>call</tt> statement.
|
||||
<P>
|
||||
All MPI objects (e.g., <TT>MPI_Datatype</TT>, <TT>MPI_Comm</TT>) are of type <TT>INTEGER
|
||||
</TT>in Fortran.
|
||||
All MPI objects (e.g., <tt>MPI_Datatype</tt>, <tt>MPI_Comm</tt>) are of type <tt>INTEGER
|
||||
</tt>in Fortran.
|
||||
<P>
|
||||
<H2>Errors</H2>
|
||||
<P>
|
||||
All MPI routines (except <TT>MPI_Wtime</TT> and <TT>MPI_Wtick</TT>) return an error value;
|
||||
All MPI routines (except <tt>MPI_Wtime</tt> and <tt>MPI_Wtick</tt>) return an error value;
|
||||
C routines as the value of the function and Fortran routines in the last
|
||||
argument. Before the value is returned, the current MPI error handler is
|
||||
called. By default, this error handler aborts the MPI job. The error handler
|
||||
may be changed with <TT>MPI_Comm_set_errhandler</TT> (for communicators),
|
||||
<TT>MPI_File_set_errhandler</TT> (for files), and <TT>MPI_Win_set_errhandler</TT> (for
|
||||
RMA windows). The MPI-1 routine <TT>MPI_Errhandler_set</TT> may be used but
|
||||
may be changed with <tt>MPI_Comm_set_errhandler</tt> (for communicators),
|
||||
<tt>MPI_File_set_errhandler</tt> (for files), and <tt>MPI_Win_set_errhandler</tt> (for
|
||||
RMA windows). The MPI-1 routine <tt>MPI_Errhandler_set</tt> may be used but
|
||||
its use is deprecated. The predefined error handler
|
||||
<TT>MPI_ERRORS_RETURN</TT> may be used to cause error values to be returned.
|
||||
Note that MPI does <EM>not</EM> guarentee that an MPI program can continue past
|
||||
<tt>MPI_ERRORS_RETURN</tt> may be used to cause error values to be returned.
|
||||
Note that MPI does <em>not</em> guarantee that an MPI program can continue past
|
||||
an error; however, MPI implementations will attempt to continue whenever
|
||||
possible.
|
||||
<P>
|
||||
<DL><DT><B>MPI_SUCCESS </B> <DD> No error; MPI routine completed successfully.
|
||||
<DL>
|
||||
<DT><B>MPI_SUCCESS </B> <DD> No error; MPI routine completed successfully.
|
||||
</DL>
|
||||
<DL><DT><B>MPI_ERR_COMM </B> <DD> Invalid communicator. A common error is to use a null
|
||||
communicator in a call (not even allowed in <TT>MPI_Comm_rank</TT>).
|
||||
<DL>
|
||||
<DT><B>MPI_ERR_COMM </B> <DD> Invalid communicator. A common error is to use a null
|
||||
communicator in a call (not even allowed in <tt>MPI_Comm_rank</tt>).
|
||||
</DL>
|
||||
<DL>
|
||||
<DT><B>MPI_ERR_OTHER </B> <DD> Other error; use <tt>MPI_Error_string</tt> to get more information
|
||||
about this error code.
|
||||
</DL>
|
||||
<P>
|
||||
</BODY></HTML>
|
||||
|
||||
@@ -5,61 +5,76 @@
|
||||
<TITLE>MPIX_Comm_failure_get_acked</TITLE>
|
||||
</HEAD>
|
||||
<BODY BGCOLOR="FFFFFF">
|
||||
<A NAME="MPIX_Comm_failure_get_acked"><H1>MPIX_Comm_failure_get_acked</H1></A>
|
||||
<H1 id="MPIX_Comm_failure_get_acked">MPIX_Comm_failure_get_acked</H1>
|
||||
Get the group of acknowledged failures.
|
||||
<H2>Synopsis</H2>
|
||||
<PRE>
|
||||
int MPIX_Comm_failure_get_acked(MPI_Comm comm, MPI_Group * failedgrp)
|
||||
</PRE>
|
||||
<PRE>
|
||||
int MPIX_Comm_failure_get_acked(MPI_Comm comm, MPI_Group *failedgrp)
|
||||
</PRE>
|
||||
|
||||
<P>
|
||||
<H2>Input Parameters</H2>
|
||||
<DL><DT><B>comm </B> <DD> Communicator (handle)
|
||||
<DL>
|
||||
<DT><B>comm </B> <DD> communicator (handle)
|
||||
</DL>
|
||||
<P>
|
||||
<H2>Output Parameters</H2>
|
||||
<DL><DT><B>failed_group </B> <DD> Group (handle)
|
||||
<DL>
|
||||
<DT><B>failedgrp </B> <DD> group of failed processes (handle)
|
||||
</DL>
|
||||
<P>
|
||||
<H2>Notes</H2>
|
||||
Because MPI specifies that null objects (e.g., <TT>MPI_COMM_NULL</TT>) are invalid
|
||||
as input to MPI routines unless otherwise specified, using <TT>MPI_COMM_NULL
|
||||
</TT>as input to this routine is an error.
|
||||
This local operation returns the group failedgrp of processes, from the communicatorcomm, that have been locally acknowledged as failed by preceding calls to MPIX_Comm_failure_ack. The failedgrp can be empty, that is, equal to MPI_GROUP_EMPTY.
|
||||
<P>
|
||||
<H2>Thread and Interrupt Safety</H2>
|
||||
<P>
|
||||
This routine is thread-safe. This means that this routine may be
|
||||
safely used by multiple threads without the need for any user-provided
|
||||
thread locks. However, the routine is not interrupt safe. Typically,
|
||||
this is due to the use of memory allocation routines such as <TT>malloc
|
||||
</TT>or other non-MPICH runtime routines that are themselves not interrupt-safe.
|
||||
this is due to the use of memory allocation routines such as <tt>malloc
|
||||
</tt>or other non-MPICH runtime routines that are themselves not interrupt-safe.
|
||||
<P>
|
||||
<H2>Notes for Fortran</H2>
|
||||
All MPI routines in Fortran (except for <TT>MPI_WTIME</TT> and <TT>MPI_WTICK</TT>) have
|
||||
an additional argument <TT>ierr</TT> at the end of the argument list. <TT>ierr
|
||||
</TT>is an integer and has the same meaning as the return value of the routine
|
||||
All MPI routines in Fortran (except for <tt>MPI_WTIME</tt> and <tt>MPI_WTICK</tt>) have
|
||||
an additional argument <tt>ierr</tt> at the end of the argument list. <tt>ierr
|
||||
</tt>is an integer and has the same meaning as the return value of the routine
|
||||
in C. In Fortran, MPI routines are subroutines, and are invoked with the
|
||||
<TT>call</TT> statement.
|
||||
<tt>call</tt> statement.
|
||||
<P>
|
||||
All MPI objects (e.g., <TT>MPI_Datatype</TT>, <TT>MPI_Comm</TT>) are of type <TT>INTEGER
|
||||
</TT>in Fortran.
|
||||
All MPI objects (e.g., <tt>MPI_Datatype</tt>, <tt>MPI_Comm</tt>) are of type <tt>INTEGER
|
||||
</tt>in Fortran.
|
||||
<P>
|
||||
<H2>Errors</H2>
|
||||
<P>
|
||||
All MPI routines (except <TT>MPI_Wtime</TT> and <TT>MPI_Wtick</TT>) return an error value;
|
||||
All MPI routines (except <tt>MPI_Wtime</tt> and <tt>MPI_Wtick</tt>) return an error value;
|
||||
C routines as the value of the function and Fortran routines in the last
|
||||
argument. Before the value is returned, the current MPI error handler is
|
||||
called. By default, this error handler aborts the MPI job. The error handler
|
||||
may be changed with <TT>MPI_Comm_set_errhandler</TT> (for communicators),
|
||||
<TT>MPI_File_set_errhandler</TT> (for files), and <TT>MPI_Win_set_errhandler</TT> (for
|
||||
RMA windows). The MPI-1 routine <TT>MPI_Errhandler_set</TT> may be used but
|
||||
may be changed with <tt>MPI_Comm_set_errhandler</tt> (for communicators),
|
||||
<tt>MPI_File_set_errhandler</tt> (for files), and <tt>MPI_Win_set_errhandler</tt> (for
|
||||
RMA windows). The MPI-1 routine <tt>MPI_Errhandler_set</tt> may be used but
|
||||
its use is deprecated. The predefined error handler
|
||||
<TT>MPI_ERRORS_RETURN</TT> may be used to cause error values to be returned.
|
||||
Note that MPI does <EM>not</EM> guarentee that an MPI program can continue past
|
||||
<tt>MPI_ERRORS_RETURN</tt> may be used to cause error values to be returned.
|
||||
Note that MPI does <em>not</em> guarantee that an MPI program can continue past
|
||||
an error; however, MPI implementations will attempt to continue whenever
|
||||
possible.
|
||||
<P>
|
||||
<DL><DT><B>MPI_SUCCESS </B> <DD> No error; MPI routine completed successfully.
|
||||
<DL>
|
||||
<DT><B>MPI_SUCCESS </B> <DD> No error; MPI routine completed successfully.
|
||||
</DL>
|
||||
<DL><DT><B>MPI_ERR_COMM </B> <DD> Invalid communicator. A common error is to use a null
|
||||
communicator in a call (not even allowed in <TT>MPI_Comm_rank</TT>).
|
||||
<DL>
|
||||
<DT><B>MPI_ERR_ARG </B> <DD> Invalid argument. Some argument is invalid and is not
|
||||
identified by a specific error class (e.g., <tt>MPI_ERR_RANK</tt>).
|
||||
</DL>
|
||||
<DL>
|
||||
<DT><B>MPI_ERR_COMM </B> <DD> Invalid communicator. A common error is to use a null
|
||||
communicator in a call (not even allowed in <tt>MPI_Comm_rank</tt>).
|
||||
</DL>
|
||||
<DL>
|
||||
<DT><B>MPI_ERR_OTHER </B> <DD> Other error; use <tt>MPI_Error_string</tt> to get more information
|
||||
about this error code.
|
||||
</DL>
|
||||
<P>
|
||||
</BODY></HTML>
|
||||
|
||||
@@ -0,0 +1,82 @@
|
||||
<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML3.2 EN">
|
||||
<HTML>
|
||||
<HEAD>
|
||||
<META NAME="GENERATOR" CONTENT="DOCTEXT">
|
||||
<TITLE>MPIX_Comm_get_failed</TITLE>
|
||||
</HEAD>
|
||||
<BODY BGCOLOR="FFFFFF">
|
||||
<H1 id="MPIX_Comm_get_failed">MPIX_Comm_get_failed</H1>
|
||||
This local operation returns the group of processes that are locally known to have failed.
|
||||
<H2>Synopsis</H2>
|
||||
<PRE>
|
||||
</PRE>
|
||||
<PRE>
|
||||
int MPIX_Comm_get_failed(MPI_Comm comm, MPI_Group *failedgrp)
|
||||
</PRE>
|
||||
|
||||
<P>
|
||||
<H2>Input Parameters</H2>
|
||||
<DL>
|
||||
<DT><B>comm </B> <DD> communicator (handle)
|
||||
</DL>
|
||||
<P>
|
||||
<H2>Output Parameters</H2>
|
||||
<DL>
|
||||
<DT><B>failedgrp </B> <DD> group of failed processes (handle)
|
||||
</DL>
|
||||
<P>
|
||||
<H2>Notes</H2>
|
||||
The returned failedgrp can be empty, that is, equal to MPI_GROUP_EMPTY.
|
||||
<P>
|
||||
For any two groups obtained from calls to this routine at the same MPI process with the same comm, the smaller group is a prefix of the larger group, that is, the same failed process will have the same rank in the returned failedgrp.
|
||||
<P>
|
||||
<H2>Thread and Interrupt Safety</H2>
|
||||
<P>
|
||||
This routine is thread-safe. This means that this routine may be
|
||||
safely used by multiple threads without the need for any user-provided
|
||||
thread locks. However, the routine is not interrupt safe. Typically,
|
||||
this is due to the use of memory allocation routines such as <tt>malloc
|
||||
</tt>or other non-MPICH runtime routines that are themselves not interrupt-safe.
|
||||
<P>
|
||||
<H2>Notes for Fortran</H2>
|
||||
All MPI routines in Fortran (except for <tt>MPI_WTIME</tt> and <tt>MPI_WTICK</tt>) have
|
||||
an additional argument <tt>ierr</tt> at the end of the argument list. <tt>ierr
|
||||
</tt>is an integer and has the same meaning as the return value of the routine
|
||||
in C. In Fortran, MPI routines are subroutines, and are invoked with the
|
||||
<tt>call</tt> statement.
|
||||
<P>
|
||||
All MPI objects (e.g., <tt>MPI_Datatype</tt>, <tt>MPI_Comm</tt>) are of type <tt>INTEGER
|
||||
</tt>in Fortran.
|
||||
<P>
|
||||
<H2>Errors</H2>
|
||||
<P>
|
||||
All MPI routines (except <tt>MPI_Wtime</tt> and <tt>MPI_Wtick</tt>) return an error value;
|
||||
C routines as the value of the function and Fortran routines in the last
|
||||
argument. Before the value is returned, the current MPI error handler is
|
||||
called. By default, this error handler aborts the MPI job. The error handler
|
||||
may be changed with <tt>MPI_Comm_set_errhandler</tt> (for communicators),
|
||||
<tt>MPI_File_set_errhandler</tt> (for files), and <tt>MPI_Win_set_errhandler</tt> (for
|
||||
RMA windows). The MPI-1 routine <tt>MPI_Errhandler_set</tt> may be used but
|
||||
its use is deprecated. The predefined error handler
|
||||
<tt>MPI_ERRORS_RETURN</tt> may be used to cause error values to be returned.
|
||||
Note that MPI does <em>not</em> guarantee that an MPI program can continue past
|
||||
an error; however, MPI implementations will attempt to continue whenever
|
||||
possible.
|
||||
<P>
|
||||
<DL>
|
||||
<DT><B>MPI_SUCCESS </B> <DD> No error; MPI routine completed successfully.
|
||||
</DL>
|
||||
<DL>
|
||||
<DT><B>MPI_ERR_ARG </B> <DD> Invalid argument. Some argument is invalid and is not
|
||||
identified by a specific error class (e.g., <tt>MPI_ERR_RANK</tt>).
|
||||
</DL>
|
||||
<DL>
|
||||
<DT><B>MPI_ERR_COMM </B> <DD> Invalid communicator. A common error is to use a null
|
||||
communicator in a call (not even allowed in <tt>MPI_Comm_rank</tt>).
|
||||
</DL>
|
||||
<DL>
|
||||
<DT><B>MPI_ERR_OTHER </B> <DD> Other error; use <tt>MPI_Error_string</tt> to get more information
|
||||
about this error code.
|
||||
</DL>
|
||||
<P>
|
||||
</BODY></HTML>
|
||||
@@ -0,0 +1,79 @@
|
||||
<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML3.2 EN">
|
||||
<HTML>
|
||||
<HEAD>
|
||||
<META NAME="GENERATOR" CONTENT="DOCTEXT">
|
||||
<TITLE>MPIX_Comm_get_stream</TITLE>
|
||||
</HEAD>
|
||||
<BODY BGCOLOR="FFFFFF">
|
||||
<H1 id="MPIX_Comm_get_stream">MPIX_Comm_get_stream</H1>
|
||||
Get the stream object that is attached to the communicator
|
||||
<H2>Synopsis</H2>
|
||||
<PRE>
|
||||
</PRE>
|
||||
<PRE>
|
||||
int MPIX_Comm_get_stream(MPI_Comm comm, int idx, MPIX_Stream *stream)
|
||||
</PRE>
|
||||
|
||||
<P>
|
||||
<H2>Input Parameters</H2>
|
||||
<DL>
|
||||
<DT><B>comm </B> <DD> communicator (handle)
|
||||
|
||||
<DT><B>idx </B> <DD> idx (integer)
|
||||
</DL>
|
||||
<P>
|
||||
<H2>Output Parameters</H2>
|
||||
<DL>
|
||||
<DT><B>stream </B> <DD> stream object (handle)
|
||||
</DL>
|
||||
<P>
|
||||
<H2>Thread and Interrupt Safety</H2>
|
||||
<P>
|
||||
This routine is thread-safe. This means that this routine may be
|
||||
safely used by multiple threads without the need for any user-provided
|
||||
thread locks. However, the routine is not interrupt safe. Typically,
|
||||
this is due to the use of memory allocation routines such as <tt>malloc
|
||||
</tt>or other non-MPICH runtime routines that are themselves not interrupt-safe.
|
||||
<P>
|
||||
<H2>Notes for Fortran</H2>
|
||||
All MPI routines in Fortran (except for <tt>MPI_WTIME</tt> and <tt>MPI_WTICK</tt>) have
|
||||
an additional argument <tt>ierr</tt> at the end of the argument list. <tt>ierr
|
||||
</tt>is an integer and has the same meaning as the return value of the routine
|
||||
in C. In Fortran, MPI routines are subroutines, and are invoked with the
|
||||
<tt>call</tt> statement.
|
||||
<P>
|
||||
All MPI objects (e.g., <tt>MPI_Datatype</tt>, <tt>MPI_Comm</tt>) are of type <tt>INTEGER
|
||||
</tt>in Fortran.
|
||||
<P>
|
||||
<H2>Errors</H2>
|
||||
<P>
|
||||
All MPI routines (except <tt>MPI_Wtime</tt> and <tt>MPI_Wtick</tt>) return an error value;
|
||||
C routines as the value of the function and Fortran routines in the last
|
||||
argument. Before the value is returned, the current MPI error handler is
|
||||
called. By default, this error handler aborts the MPI job. The error handler
|
||||
may be changed with <tt>MPI_Comm_set_errhandler</tt> (for communicators),
|
||||
<tt>MPI_File_set_errhandler</tt> (for files), and <tt>MPI_Win_set_errhandler</tt> (for
|
||||
RMA windows). The MPI-1 routine <tt>MPI_Errhandler_set</tt> may be used but
|
||||
its use is deprecated. The predefined error handler
|
||||
<tt>MPI_ERRORS_RETURN</tt> may be used to cause error values to be returned.
|
||||
Note that MPI does <em>not</em> guarantee that an MPI program can continue past
|
||||
an error; however, MPI implementations will attempt to continue whenever
|
||||
possible.
|
||||
<P>
|
||||
<DL>
|
||||
<DT><B>MPI_SUCCESS </B> <DD> No error; MPI routine completed successfully.
|
||||
</DL>
|
||||
<DL>
|
||||
<DT><B>MPI_ERR_ARG </B> <DD> Invalid argument. Some argument is invalid and is not
|
||||
identified by a specific error class (e.g., <tt>MPI_ERR_RANK</tt>).
|
||||
</DL>
|
||||
<DL>
|
||||
<DT><B>MPI_ERR_COMM </B> <DD> Invalid communicator. A common error is to use a null
|
||||
communicator in a call (not even allowed in <tt>MPI_Comm_rank</tt>).
|
||||
</DL>
|
||||
<DL>
|
||||
<DT><B>MPI_ERR_OTHER </B> <DD> Other error; use <tt>MPI_Error_string</tt> to get more information
|
||||
about this error code.
|
||||
</DL>
|
||||
<P>
|
||||
</BODY></HTML>
|
||||
@@ -5,46 +5,20 @@
|
||||
<TITLE>MPIX_Comm_revoke</TITLE>
|
||||
</HEAD>
|
||||
<BODY BGCOLOR="FFFFFF">
|
||||
<A NAME="MPIX_Comm_revoke"><H1>MPIX_Comm_revoke</H1></A>
|
||||
<H1 id="MPIX_Comm_revoke">MPIX_Comm_revoke</H1>
|
||||
Prevent a communicator from being used in the future
|
||||
<H2>Synopsis</H2>
|
||||
<PRE>
|
||||
</PRE>
|
||||
<PRE>
|
||||
int MPIX_Comm_revoke(MPI_Comm comm)
|
||||
</PRE>
|
||||
|
||||
<P>
|
||||
<H2>Input Parameters</H2>
|
||||
<DL><DT><B>comm </B> <DD> communicator to revoke
|
||||
<DL>
|
||||
<DT><B>comm </B> <DD> communicator to revoke (handle)
|
||||
</DL>
|
||||
<P>
|
||||
<H2>Notes</H2>
|
||||
Asynchronously notifies all MPI processes associated with the communicator <TT>comm</TT>.
|
||||
This will be manifest by returning the MPIX_ERR_REVOKED during a subsequent MPI
|
||||
call.
|
||||
<P>
|
||||
<H2>Notes for Fortran</H2>
|
||||
All MPI routines in Fortran (except for <TT>MPI_WTIME</TT> and <TT>MPI_WTICK</TT>) have
|
||||
an additional argument <TT>ierr</TT> at the end of the argument list. <TT>ierr
|
||||
</TT>is an integer and has the same meaning as the return value of the routine
|
||||
in C. In Fortran, MPI routines are subroutines, and are invoked with the
|
||||
<TT>call</TT> statement.
|
||||
<P>
|
||||
All MPI objects (e.g., <TT>MPI_Datatype</TT>, <TT>MPI_Comm</TT>) are of type <TT>INTEGER
|
||||
</TT>in Fortran.
|
||||
<P>
|
||||
<H2>Errors</H2>
|
||||
<P>
|
||||
All MPI routines (except <TT>MPI_Wtime</TT> and <TT>MPI_Wtick</TT>) return an error value;
|
||||
C routines as the value of the function and Fortran routines in the last
|
||||
argument. Before the value is returned, the current MPI error handler is
|
||||
called. By default, this error handler aborts the MPI job. The error handler
|
||||
may be changed with <TT>MPI_Comm_set_errhandler</TT> (for communicators),
|
||||
<TT>MPI_File_set_errhandler</TT> (for files), and <TT>MPI_Win_set_errhandler</TT> (for
|
||||
RMA windows). The MPI-1 routine <TT>MPI_Errhandler_set</TT> may be used but
|
||||
its use is deprecated. The predefined error handler
|
||||
<TT>MPI_ERRORS_RETURN</TT> may be used to cause error values to be returned.
|
||||
Note that MPI does <EM>not</EM> guarentee that an MPI program can continue past
|
||||
an error; however, MPI implementations will attempt to continue whenever
|
||||
possible.
|
||||
<P>
|
||||
<DL><DT><B>MPI_SUCCESS </B> <DD> No error; MPI routine completed successfully.
|
||||
</DL>
|
||||
</BODY></HTML>
|
||||
|
||||
@@ -5,57 +5,25 @@
|
||||
<TITLE>MPIX_Comm_shrink</TITLE>
|
||||
</HEAD>
|
||||
<BODY BGCOLOR="FFFFFF">
|
||||
<A NAME="MPIX_Comm_shrink"><H1>MPIX_Comm_shrink</H1></A>
|
||||
<H1 id="MPIX_Comm_shrink">MPIX_Comm_shrink</H1>
|
||||
Creates a new communitor from an existing communicator while excluding failed processes
|
||||
<H2>Synopsis</H2>
|
||||
<PRE>
|
||||
int MPIX_Comm_shrink(MPI_Comm comm, MPI_Comm * newcomm)
|
||||
</PRE>
|
||||
<PRE>
|
||||
int MPIX_Comm_shrink(MPI_Comm comm, MPI_Comm *newcomm)
|
||||
</PRE>
|
||||
|
||||
<P>
|
||||
<H2>Input Parameters</H2>
|
||||
<DL><DT><B>comm </B> <DD> communicator (handle)
|
||||
<DL>
|
||||
<DT><B>comm </B> <DD> communicator (handle)
|
||||
</DL>
|
||||
<P>
|
||||
<H2>Output Parameters</H2>
|
||||
<DL><DT><B>newcomm </B> <DD> new communicator (handle)
|
||||
</DL>
|
||||
<P>
|
||||
<H2>Thread and Interrupt Safety</H2>
|
||||
<P>
|
||||
This routine is thread-safe. This means that this routine may be
|
||||
safely used by multiple threads without the need for any user-provided
|
||||
thread locks. However, the routine is not interrupt safe. Typically,
|
||||
this is due to the use of memory allocation routines such as <TT>malloc
|
||||
</TT>or other non-MPICH runtime routines that are themselves not interrupt-safe.
|
||||
<P>
|
||||
<H2>Notes for Fortran</H2>
|
||||
All MPI routines in Fortran (except for <TT>MPI_WTIME</TT> and <TT>MPI_WTICK</TT>) have
|
||||
an additional argument <TT>ierr</TT> at the end of the argument list. <TT>ierr
|
||||
</TT>is an integer and has the same meaning as the return value of the routine
|
||||
in C. In Fortran, MPI routines are subroutines, and are invoked with the
|
||||
<TT>call</TT> statement.
|
||||
<P>
|
||||
All MPI objects (e.g., <TT>MPI_Datatype</TT>, <TT>MPI_Comm</TT>) are of type <TT>INTEGER
|
||||
</TT>in Fortran.
|
||||
<P>
|
||||
<H2>Errors</H2>
|
||||
<P>
|
||||
All MPI routines (except <TT>MPI_Wtime</TT> and <TT>MPI_Wtick</TT>) return an error value;
|
||||
C routines as the value of the function and Fortran routines in the last
|
||||
argument. Before the value is returned, the current MPI error handler is
|
||||
called. By default, this error handler aborts the MPI job. The error handler
|
||||
may be changed with <TT>MPI_Comm_set_errhandler</TT> (for communicators),
|
||||
<TT>MPI_File_set_errhandler</TT> (for files), and <TT>MPI_Win_set_errhandler</TT> (for
|
||||
RMA windows). The MPI-1 routine <TT>MPI_Errhandler_set</TT> may be used but
|
||||
its use is deprecated. The predefined error handler
|
||||
<TT>MPI_ERRORS_RETURN</TT> may be used to cause error values to be returned.
|
||||
Note that MPI does <EM>not</EM> guarentee that an MPI program can continue past
|
||||
an error; however, MPI implementations will attempt to continue whenever
|
||||
possible.
|
||||
<P>
|
||||
<DL><DT><B>MPI_SUCCESS </B> <DD> No error; MPI routine completed successfully.
|
||||
</DL>
|
||||
<DL><DT><B>MPI_ERR_COMM </B> <DD> Invalid communicator. A common error is to use a null
|
||||
communicator in a call (not even allowed in <TT>MPI_Comm_rank</TT>).
|
||||
<DL>
|
||||
<DT><B>newcomm </B> <DD> new communicator (handle)
|
||||
</DL>
|
||||
<P>
|
||||
<H2>Notes</H2>
|
||||
</BODY></HTML>
|
||||
|
||||
@@ -0,0 +1,77 @@
|
||||
<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML3.2 EN">
|
||||
<HTML>
|
||||
<HEAD>
|
||||
<META NAME="GENERATOR" CONTENT="DOCTEXT">
|
||||
<TITLE>MPIX_Comm_test_threadcomm</TITLE>
|
||||
</HEAD>
|
||||
<BODY BGCOLOR="FFFFFF">
|
||||
<H1 id="MPIX_Comm_test_threadcomm">MPIX_Comm_test_threadcomm</H1>
|
||||
Tests to see if a comm is a threadcomm
|
||||
<H2>Synopsis</H2>
|
||||
<PRE>
|
||||
</PRE>
|
||||
<PRE>
|
||||
int MPIX_Comm_test_threadcomm(MPI_Comm comm, int *flag)
|
||||
</PRE>
|
||||
|
||||
<P>
|
||||
<H2>Input Parameters</H2>
|
||||
<DL>
|
||||
<DT><B>comm </B> <DD> communicator (handle)
|
||||
</DL>
|
||||
<P>
|
||||
<H2>Output Parameters</H2>
|
||||
<DL>
|
||||
<DT><B>flag </B> <DD> true if comm is an inter-communicator (logical)
|
||||
</DL>
|
||||
<P>
|
||||
<H2>Thread and Interrupt Safety</H2>
|
||||
<P>
|
||||
This routine is thread-safe. This means that this routine may be
|
||||
safely used by multiple threads without the need for any user-provided
|
||||
thread locks. However, the routine is not interrupt safe. Typically,
|
||||
this is due to the use of memory allocation routines such as <tt>malloc
|
||||
</tt>or other non-MPICH runtime routines that are themselves not interrupt-safe.
|
||||
<P>
|
||||
<H2>Notes for Fortran</H2>
|
||||
All MPI routines in Fortran (except for <tt>MPI_WTIME</tt> and <tt>MPI_WTICK</tt>) have
|
||||
an additional argument <tt>ierr</tt> at the end of the argument list. <tt>ierr
|
||||
</tt>is an integer and has the same meaning as the return value of the routine
|
||||
in C. In Fortran, MPI routines are subroutines, and are invoked with the
|
||||
<tt>call</tt> statement.
|
||||
<P>
|
||||
All MPI objects (e.g., <tt>MPI_Datatype</tt>, <tt>MPI_Comm</tt>) are of type <tt>INTEGER
|
||||
</tt>in Fortran.
|
||||
<P>
|
||||
<H2>Errors</H2>
|
||||
<P>
|
||||
All MPI routines (except <tt>MPI_Wtime</tt> and <tt>MPI_Wtick</tt>) return an error value;
|
||||
C routines as the value of the function and Fortran routines in the last
|
||||
argument. Before the value is returned, the current MPI error handler is
|
||||
called. By default, this error handler aborts the MPI job. The error handler
|
||||
may be changed with <tt>MPI_Comm_set_errhandler</tt> (for communicators),
|
||||
<tt>MPI_File_set_errhandler</tt> (for files), and <tt>MPI_Win_set_errhandler</tt> (for
|
||||
RMA windows). The MPI-1 routine <tt>MPI_Errhandler_set</tt> may be used but
|
||||
its use is deprecated. The predefined error handler
|
||||
<tt>MPI_ERRORS_RETURN</tt> may be used to cause error values to be returned.
|
||||
Note that MPI does <em>not</em> guarantee that an MPI program can continue past
|
||||
an error; however, MPI implementations will attempt to continue whenever
|
||||
possible.
|
||||
<P>
|
||||
<DL>
|
||||
<DT><B>MPI_SUCCESS </B> <DD> No error; MPI routine completed successfully.
|
||||
</DL>
|
||||
<DL>
|
||||
<DT><B>MPI_ERR_ARG </B> <DD> Invalid argument. Some argument is invalid and is not
|
||||
identified by a specific error class (e.g., <tt>MPI_ERR_RANK</tt>).
|
||||
</DL>
|
||||
<DL>
|
||||
<DT><B>MPI_ERR_COMM </B> <DD> Invalid communicator. A common error is to use a null
|
||||
communicator in a call (not even allowed in <tt>MPI_Comm_rank</tt>).
|
||||
</DL>
|
||||
<DL>
|
||||
<DT><B>MPI_ERR_OTHER </B> <DD> Other error; use <tt>MPI_Error_string</tt> to get more information
|
||||
about this error code.
|
||||
</DL>
|
||||
<P>
|
||||
</BODY></HTML>
|
||||
@@ -0,0 +1,80 @@
|
||||
<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML3.2 EN">
|
||||
<HTML>
|
||||
<HEAD>
|
||||
<META NAME="GENERATOR" CONTENT="DOCTEXT">
|
||||
<TITLE>MPIX_File_create_errhandler_x</TITLE>
|
||||
</HEAD>
|
||||
<BODY BGCOLOR="FFFFFF">
|
||||
<H1 id="MPIX_File_create_errhandler_x">MPIX_File_create_errhandler_x</H1>
|
||||
Creates an MPI-style file errorhandler with an extra_state
|
||||
<H2>Synopsis</H2>
|
||||
<PRE>
|
||||
</PRE>
|
||||
<PRE>
|
||||
int MPIX_File_create_errhandler_x(MPIX_File_errhandler_function_x *comm_errhandler_fn_x,
|
||||
MPIX_Destructor_function *destructor_fn,
|
||||
void *extra_state,
|
||||
MPI_Errhandler *errhandler)
|
||||
</PRE>
|
||||
|
||||
<P>
|
||||
<H2>Input Parameters</H2>
|
||||
<DL>
|
||||
<DT><B>comm_errhandler_fn_x </B> <DD> user defined error handling procedure with extra_state (function)
|
||||
|
||||
<DT><B>destructor_fn </B> <DD> callback when op is freed (function)
|
||||
|
||||
<DT><B>extra_state </B> <DD> extra state (None)
|
||||
</DL>
|
||||
<P>
|
||||
<H2>Output Parameters</H2>
|
||||
<DL>
|
||||
<DT><B>errhandler </B> <DD> MPI error handler (handle)
|
||||
</DL>
|
||||
<P>
|
||||
<H2>Thread and Interrupt Safety</H2>
|
||||
<P>
|
||||
This routine is thread-safe. This means that this routine may be
|
||||
safely used by multiple threads without the need for any user-provided
|
||||
thread locks. However, the routine is not interrupt safe. Typically,
|
||||
this is due to the use of memory allocation routines such as <tt>malloc
|
||||
</tt>or other non-MPICH runtime routines that are themselves not interrupt-safe.
|
||||
<P>
|
||||
<H2>Notes for Fortran</H2>
|
||||
All MPI routines in Fortran (except for <tt>MPI_WTIME</tt> and <tt>MPI_WTICK</tt>) have
|
||||
an additional argument <tt>ierr</tt> at the end of the argument list. <tt>ierr
|
||||
</tt>is an integer and has the same meaning as the return value of the routine
|
||||
in C. In Fortran, MPI routines are subroutines, and are invoked with the
|
||||
<tt>call</tt> statement.
|
||||
<P>
|
||||
All MPI objects (e.g., <tt>MPI_Datatype</tt>, <tt>MPI_Comm</tt>) are of type <tt>INTEGER
|
||||
</tt>in Fortran.
|
||||
<P>
|
||||
<H2>Errors</H2>
|
||||
<P>
|
||||
All MPI routines (except <tt>MPI_Wtime</tt> and <tt>MPI_Wtick</tt>) return an error value;
|
||||
C routines as the value of the function and Fortran routines in the last
|
||||
argument. Before the value is returned, the current MPI error handler is
|
||||
called. By default, this error handler aborts the MPI job. The error handler
|
||||
may be changed with <tt>MPI_Comm_set_errhandler</tt> (for communicators),
|
||||
<tt>MPI_File_set_errhandler</tt> (for files), and <tt>MPI_Win_set_errhandler</tt> (for
|
||||
RMA windows). The MPI-1 routine <tt>MPI_Errhandler_set</tt> may be used but
|
||||
its use is deprecated. The predefined error handler
|
||||
<tt>MPI_ERRORS_RETURN</tt> may be used to cause error values to be returned.
|
||||
Note that MPI does <em>not</em> guarantee that an MPI program can continue past
|
||||
an error; however, MPI implementations will attempt to continue whenever
|
||||
possible.
|
||||
<P>
|
||||
<DL>
|
||||
<DT><B>MPI_SUCCESS </B> <DD> No error; MPI routine completed successfully.
|
||||
</DL>
|
||||
<DL>
|
||||
<DT><B>MPI_ERR_ARG </B> <DD> Invalid argument. Some argument is invalid and is not
|
||||
identified by a specific error class (e.g., <tt>MPI_ERR_RANK</tt>).
|
||||
</DL>
|
||||
<DL>
|
||||
<DT><B>MPI_ERR_OTHER </B> <DD> Other error; use <tt>MPI_Error_string</tt> to get more information
|
||||
about this error code.
|
||||
</DL>
|
||||
<P>
|
||||
</BODY></HTML>
|
||||
@@ -0,0 +1,73 @@
|
||||
<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML3.2 EN">
|
||||
<HTML>
|
||||
<HEAD>
|
||||
<META NAME="GENERATOR" CONTENT="DOCTEXT">
|
||||
<TITLE>MPIX_GPU_query_support</TITLE>
|
||||
</HEAD>
|
||||
<BODY BGCOLOR="FFFFFF">
|
||||
<H1 id="MPIX_GPU_query_support">MPIX_GPU_query_support</H1>
|
||||
Returns whether the specific type of GPU is supported
|
||||
<H2>Synopsis</H2>
|
||||
<PRE>
|
||||
</PRE>
|
||||
<PRE>
|
||||
int MPIX_GPU_query_support(int gpu_type, int *is_supported)
|
||||
</PRE>
|
||||
|
||||
<P>
|
||||
<H2>Input Parameters</H2>
|
||||
<DL>
|
||||
<DT><B>gpu_type </B> <DD> MPIX_GPU_SUPPORT_CUDA, MPIX_GPU_SUPPORT_ZE, or MPIX_GPU_SUPPORT_HIP (integer)
|
||||
</DL>
|
||||
<P>
|
||||
<H2>Output Parameters</H2>
|
||||
<DL>
|
||||
<DT><B>is_supported </B> <DD> true if gpu of given type is supported, false otherwise. (logical)
|
||||
</DL>
|
||||
<P>
|
||||
<H2>Thread and Interrupt Safety</H2>
|
||||
<P>
|
||||
This routine is thread-safe. This means that this routine may be
|
||||
safely used by multiple threads without the need for any user-provided
|
||||
thread locks. However, the routine is not interrupt safe. Typically,
|
||||
this is due to the use of memory allocation routines such as <tt>malloc
|
||||
</tt>or other non-MPICH runtime routines that are themselves not interrupt-safe.
|
||||
<P>
|
||||
<H2>Notes for Fortran</H2>
|
||||
All MPI routines in Fortran (except for <tt>MPI_WTIME</tt> and <tt>MPI_WTICK</tt>) have
|
||||
an additional argument <tt>ierr</tt> at the end of the argument list. <tt>ierr
|
||||
</tt>is an integer and has the same meaning as the return value of the routine
|
||||
in C. In Fortran, MPI routines are subroutines, and are invoked with the
|
||||
<tt>call</tt> statement.
|
||||
<P>
|
||||
All MPI objects (e.g., <tt>MPI_Datatype</tt>, <tt>MPI_Comm</tt>) are of type <tt>INTEGER
|
||||
</tt>in Fortran.
|
||||
<P>
|
||||
<H2>Errors</H2>
|
||||
<P>
|
||||
All MPI routines (except <tt>MPI_Wtime</tt> and <tt>MPI_Wtick</tt>) return an error value;
|
||||
C routines as the value of the function and Fortran routines in the last
|
||||
argument. Before the value is returned, the current MPI error handler is
|
||||
called. By default, this error handler aborts the MPI job. The error handler
|
||||
may be changed with <tt>MPI_Comm_set_errhandler</tt> (for communicators),
|
||||
<tt>MPI_File_set_errhandler</tt> (for files), and <tt>MPI_Win_set_errhandler</tt> (for
|
||||
RMA windows). The MPI-1 routine <tt>MPI_Errhandler_set</tt> may be used but
|
||||
its use is deprecated. The predefined error handler
|
||||
<tt>MPI_ERRORS_RETURN</tt> may be used to cause error values to be returned.
|
||||
Note that MPI does <em>not</em> guarantee that an MPI program can continue past
|
||||
an error; however, MPI implementations will attempt to continue whenever
|
||||
possible.
|
||||
<P>
|
||||
<DL>
|
||||
<DT><B>MPI_SUCCESS </B> <DD> No error; MPI routine completed successfully.
|
||||
</DL>
|
||||
<DL>
|
||||
<DT><B>MPI_ERR_ARG </B> <DD> Invalid argument. Some argument is invalid and is not
|
||||
identified by a specific error class (e.g., <tt>MPI_ERR_RANK</tt>).
|
||||
</DL>
|
||||
<DL>
|
||||
<DT><B>MPI_ERR_OTHER </B> <DD> Other error; use <tt>MPI_Error_string</tt> to get more information
|
||||
about this error code.
|
||||
</DL>
|
||||
<P>
|
||||
</BODY></HTML>
|
||||
@@ -0,0 +1,76 @@
|
||||
<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML3.2 EN">
|
||||
<HTML>
|
||||
<HEAD>
|
||||
<META NAME="GENERATOR" CONTENT="DOCTEXT">
|
||||
<TITLE>MPIX_Grequest_class_allocate</TITLE>
|
||||
</HEAD>
|
||||
<BODY BGCOLOR="FFFFFF">
|
||||
<H1 id="MPIX_Grequest_class_allocate">MPIX_Grequest_class_allocate</H1>
|
||||
Create and return a user-defined extended request based on a generalized request class
|
||||
<H2>Synopsis</H2>
|
||||
<PRE>
|
||||
</PRE>
|
||||
<PRE>
|
||||
int MPIX_Grequest_class_allocate(MPIX_Grequest_class greq_class,
|
||||
void *extra_state, MPI_Request *request)
|
||||
</PRE>
|
||||
|
||||
<P>
|
||||
<H2>Input Parameters</H2>
|
||||
<DL>
|
||||
<DT><B>greq_class </B> <DD> generalized request class (None)
|
||||
|
||||
<DT><B>extra_state </B> <DD> extra state (None)
|
||||
</DL>
|
||||
<P>
|
||||
<H2>Output Parameters</H2>
|
||||
<DL>
|
||||
<DT><B>request </B> <DD> generalized request (handle)
|
||||
</DL>
|
||||
<P>
|
||||
<H2>Thread and Interrupt Safety</H2>
|
||||
<P>
|
||||
This routine is thread-safe. This means that this routine may be
|
||||
safely used by multiple threads without the need for any user-provided
|
||||
thread locks. However, the routine is not interrupt safe. Typically,
|
||||
this is due to the use of memory allocation routines such as <tt>malloc
|
||||
</tt>or other non-MPICH runtime routines that are themselves not interrupt-safe.
|
||||
<P>
|
||||
<H2>Notes for Fortran</H2>
|
||||
All MPI routines in Fortran (except for <tt>MPI_WTIME</tt> and <tt>MPI_WTICK</tt>) have
|
||||
an additional argument <tt>ierr</tt> at the end of the argument list. <tt>ierr
|
||||
</tt>is an integer and has the same meaning as the return value of the routine
|
||||
in C. In Fortran, MPI routines are subroutines, and are invoked with the
|
||||
<tt>call</tt> statement.
|
||||
<P>
|
||||
All MPI objects (e.g., <tt>MPI_Datatype</tt>, <tt>MPI_Comm</tt>) are of type <tt>INTEGER
|
||||
</tt>in Fortran.
|
||||
<P>
|
||||
<H2>Errors</H2>
|
||||
<P>
|
||||
All MPI routines (except <tt>MPI_Wtime</tt> and <tt>MPI_Wtick</tt>) return an error value;
|
||||
C routines as the value of the function and Fortran routines in the last
|
||||
argument. Before the value is returned, the current MPI error handler is
|
||||
called. By default, this error handler aborts the MPI job. The error handler
|
||||
may be changed with <tt>MPI_Comm_set_errhandler</tt> (for communicators),
|
||||
<tt>MPI_File_set_errhandler</tt> (for files), and <tt>MPI_Win_set_errhandler</tt> (for
|
||||
RMA windows). The MPI-1 routine <tt>MPI_Errhandler_set</tt> may be used but
|
||||
its use is deprecated. The predefined error handler
|
||||
<tt>MPI_ERRORS_RETURN</tt> may be used to cause error values to be returned.
|
||||
Note that MPI does <em>not</em> guarantee that an MPI program can continue past
|
||||
an error; however, MPI implementations will attempt to continue whenever
|
||||
possible.
|
||||
<P>
|
||||
<DL>
|
||||
<DT><B>MPI_SUCCESS </B> <DD> No error; MPI routine completed successfully.
|
||||
</DL>
|
||||
<DL>
|
||||
<DT><B>MPI_ERR_ARG </B> <DD> Invalid argument. Some argument is invalid and is not
|
||||
identified by a specific error class (e.g., <tt>MPI_ERR_RANK</tt>).
|
||||
</DL>
|
||||
<DL>
|
||||
<DT><B>MPI_ERR_OTHER </B> <DD> Other error; use <tt>MPI_Error_string</tt> to get more information
|
||||
about this error code.
|
||||
</DL>
|
||||
<P>
|
||||
</BODY></HTML>
|
||||
@@ -0,0 +1,86 @@
|
||||
<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML3.2 EN">
|
||||
<HTML>
|
||||
<HEAD>
|
||||
<META NAME="GENERATOR" CONTENT="DOCTEXT">
|
||||
<TITLE>MPIX_Grequest_class_create</TITLE>
|
||||
</HEAD>
|
||||
<BODY BGCOLOR="FFFFFF">
|
||||
<H1 id="MPIX_Grequest_class_create">MPIX_Grequest_class_create</H1>
|
||||
[short description]
|
||||
<H2>Synopsis</H2>
|
||||
<PRE>
|
||||
</PRE>
|
||||
<PRE>
|
||||
int MPIX_Grequest_class_create(MPI_Grequest_query_function *query_fn,
|
||||
MPI_Grequest_free_function *free_fn,
|
||||
MPI_Grequest_cancel_function *cancel_fn,
|
||||
MPIX_Grequest_poll_function *poll_fn,
|
||||
MPIX_Grequest_wait_function *wait_fn,
|
||||
MPIX_Grequest_class *greq_class)
|
||||
</PRE>
|
||||
|
||||
<P>
|
||||
<H2>Input Parameters</H2>
|
||||
<DL>
|
||||
<DT><B>query_fn </B> <DD> callback function invoked when request status is queried (function)
|
||||
|
||||
<DT><B>free_fn </B> <DD> callback function invoked when request is freed (function)
|
||||
|
||||
<DT><B>cancel_fn </B> <DD> callback function invoked when request is cancelled (function)
|
||||
|
||||
<DT><B>poll_fn </B> <DD> callback function invoked when request completion is tested (function)
|
||||
|
||||
<DT><B>wait_fn </B> <DD> callback function invoked when request is waited on (function)
|
||||
</DL>
|
||||
<P>
|
||||
<H2>Output Parameters</H2>
|
||||
<DL>
|
||||
<DT><B>greq_class </B> <DD> generalized request class (None)
|
||||
</DL>
|
||||
<P>
|
||||
<H2>Thread and Interrupt Safety</H2>
|
||||
<P>
|
||||
This routine is thread-safe. This means that this routine may be
|
||||
safely used by multiple threads without the need for any user-provided
|
||||
thread locks. However, the routine is not interrupt safe. Typically,
|
||||
this is due to the use of memory allocation routines such as <tt>malloc
|
||||
</tt>or other non-MPICH runtime routines that are themselves not interrupt-safe.
|
||||
<P>
|
||||
<H2>Notes for Fortran</H2>
|
||||
All MPI routines in Fortran (except for <tt>MPI_WTIME</tt> and <tt>MPI_WTICK</tt>) have
|
||||
an additional argument <tt>ierr</tt> at the end of the argument list. <tt>ierr
|
||||
</tt>is an integer and has the same meaning as the return value of the routine
|
||||
in C. In Fortran, MPI routines are subroutines, and are invoked with the
|
||||
<tt>call</tt> statement.
|
||||
<P>
|
||||
All MPI objects (e.g., <tt>MPI_Datatype</tt>, <tt>MPI_Comm</tt>) are of type <tt>INTEGER
|
||||
</tt>in Fortran.
|
||||
<P>
|
||||
<H2>Errors</H2>
|
||||
<P>
|
||||
All MPI routines (except <tt>MPI_Wtime</tt> and <tt>MPI_Wtick</tt>) return an error value;
|
||||
C routines as the value of the function and Fortran routines in the last
|
||||
argument. Before the value is returned, the current MPI error handler is
|
||||
called. By default, this error handler aborts the MPI job. The error handler
|
||||
may be changed with <tt>MPI_Comm_set_errhandler</tt> (for communicators),
|
||||
<tt>MPI_File_set_errhandler</tt> (for files), and <tt>MPI_Win_set_errhandler</tt> (for
|
||||
RMA windows). The MPI-1 routine <tt>MPI_Errhandler_set</tt> may be used but
|
||||
its use is deprecated. The predefined error handler
|
||||
<tt>MPI_ERRORS_RETURN</tt> may be used to cause error values to be returned.
|
||||
Note that MPI does <em>not</em> guarantee that an MPI program can continue past
|
||||
an error; however, MPI implementations will attempt to continue whenever
|
||||
possible.
|
||||
<P>
|
||||
<DL>
|
||||
<DT><B>MPI_SUCCESS </B> <DD> No error; MPI routine completed successfully.
|
||||
</DL>
|
||||
<DL>
|
||||
<DT><B>MPI_ERR_ARG </B> <DD> Invalid argument. Some argument is invalid and is not
|
||||
identified by a specific error class (e.g., <tt>MPI_ERR_RANK</tt>).
|
||||
</DL>
|
||||
<DL>
|
||||
<DT><B>MPI_ERR_OTHER </B> <DD> Other error; use <tt>MPI_Error_string</tt> to get more information
|
||||
about this error code.
|
||||
</DL>
|
||||
<P>
|
||||
</BODY></HTML>
|
||||
@@ -0,0 +1,88 @@
|
||||
<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML3.2 EN">
|
||||
<HTML>
|
||||
<HEAD>
|
||||
<META NAME="GENERATOR" CONTENT="DOCTEXT">
|
||||
<TITLE>MPIX_Grequest_start</TITLE>
|
||||
</HEAD>
|
||||
<BODY BGCOLOR="FFFFFF">
|
||||
<H1 id="MPIX_Grequest_start">MPIX_Grequest_start</H1>
|
||||
Create and return a user-defined extended request
|
||||
<H2>Synopsis</H2>
|
||||
<PRE>
|
||||
</PRE>
|
||||
<PRE>
|
||||
int MPIX_Grequest_start(MPI_Grequest_query_function *query_fn,
|
||||
MPI_Grequest_free_function *free_fn,
|
||||
MPI_Grequest_cancel_function *cancel_fn,
|
||||
MPIX_Grequest_poll_function *poll_fn,
|
||||
MPIX_Grequest_wait_function *wait_fn, void *extra_state,
|
||||
MPI_Request *request)
|
||||
</PRE>
|
||||
|
||||
<P>
|
||||
<H2>Input Parameters</H2>
|
||||
<DL>
|
||||
<DT><B>query_fn </B> <DD> callback function invoked when request status is queried (function)
|
||||
|
||||
<DT><B>free_fn </B> <DD> callback function invoked when request is freed (function)
|
||||
|
||||
<DT><B>cancel_fn </B> <DD> callback function invoked when request is cancelled (function)
|
||||
|
||||
<DT><B>poll_fn </B> <DD> callback function invoked when request completion is tested (function)
|
||||
|
||||
<DT><B>wait_fn </B> <DD> callback function invoked when request is waited on (function)
|
||||
|
||||
<DT><B>extra_state </B> <DD> extra state (None)
|
||||
</DL>
|
||||
<P>
|
||||
<H2>Output Parameters</H2>
|
||||
<DL>
|
||||
<DT><B>request </B> <DD> generalized request (handle)
|
||||
</DL>
|
||||
<P>
|
||||
<H2>Thread and Interrupt Safety</H2>
|
||||
<P>
|
||||
This routine is thread-safe. This means that this routine may be
|
||||
safely used by multiple threads without the need for any user-provided
|
||||
thread locks. However, the routine is not interrupt safe. Typically,
|
||||
this is due to the use of memory allocation routines such as <tt>malloc
|
||||
</tt>or other non-MPICH runtime routines that are themselves not interrupt-safe.
|
||||
<P>
|
||||
<H2>Notes for Fortran</H2>
|
||||
All MPI routines in Fortran (except for <tt>MPI_WTIME</tt> and <tt>MPI_WTICK</tt>) have
|
||||
an additional argument <tt>ierr</tt> at the end of the argument list. <tt>ierr
|
||||
</tt>is an integer and has the same meaning as the return value of the routine
|
||||
in C. In Fortran, MPI routines are subroutines, and are invoked with the
|
||||
<tt>call</tt> statement.
|
||||
<P>
|
||||
All MPI objects (e.g., <tt>MPI_Datatype</tt>, <tt>MPI_Comm</tt>) are of type <tt>INTEGER
|
||||
</tt>in Fortran.
|
||||
<P>
|
||||
<H2>Errors</H2>
|
||||
<P>
|
||||
All MPI routines (except <tt>MPI_Wtime</tt> and <tt>MPI_Wtick</tt>) return an error value;
|
||||
C routines as the value of the function and Fortran routines in the last
|
||||
argument. Before the value is returned, the current MPI error handler is
|
||||
called. By default, this error handler aborts the MPI job. The error handler
|
||||
may be changed with <tt>MPI_Comm_set_errhandler</tt> (for communicators),
|
||||
<tt>MPI_File_set_errhandler</tt> (for files), and <tt>MPI_Win_set_errhandler</tt> (for
|
||||
RMA windows). The MPI-1 routine <tt>MPI_Errhandler_set</tt> may be used but
|
||||
its use is deprecated. The predefined error handler
|
||||
<tt>MPI_ERRORS_RETURN</tt> may be used to cause error values to be returned.
|
||||
Note that MPI does <em>not</em> guarantee that an MPI program can continue past
|
||||
an error; however, MPI implementations will attempt to continue whenever
|
||||
possible.
|
||||
<P>
|
||||
<DL>
|
||||
<DT><B>MPI_SUCCESS </B> <DD> No error; MPI routine completed successfully.
|
||||
</DL>
|
||||
<DL>
|
||||
<DT><B>MPI_ERR_ARG </B> <DD> Invalid argument. Some argument is invalid and is not
|
||||
identified by a specific error class (e.g., <tt>MPI_ERR_RANK</tt>).
|
||||
</DL>
|
||||
<DL>
|
||||
<DT><B>MPI_ERR_OTHER </B> <DD> Other error; use <tt>MPI_Error_string</tt> to get more information
|
||||
about this error code.
|
||||
</DL>
|
||||
<P>
|
||||
</BODY></HTML>
|
||||
78
macx64/mpi/mpich/share/doc/mpich/www3/MPIX_Info_set_hex.html
Normal file
78
macx64/mpi/mpich/share/doc/mpich/www3/MPIX_Info_set_hex.html
Normal file
@@ -0,0 +1,78 @@
|
||||
<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML3.2 EN">
|
||||
<HTML>
|
||||
<HEAD>
|
||||
<META NAME="GENERATOR" CONTENT="DOCTEXT">
|
||||
<TITLE>MPIX_Info_set_hex</TITLE>
|
||||
</HEAD>
|
||||
<BODY BGCOLOR="FFFFFF">
|
||||
<H1 id="MPIX_Info_set_hex">MPIX_Info_set_hex</H1>
|
||||
[short description]
|
||||
<H2>Synopsis</H2>
|
||||
<PRE>
|
||||
</PRE>
|
||||
<PRE>
|
||||
int MPIX_Info_set_hex(MPI_Info info, const char *key, const void *value,
|
||||
int value_size)
|
||||
</PRE>
|
||||
|
||||
<P>
|
||||
<H2>Input Parameters</H2>
|
||||
<DL>
|
||||
<DT><B>info </B> <DD> info object (handle)
|
||||
|
||||
<DT><B>key </B> <DD> key (string)
|
||||
|
||||
<DT><B>value </B> <DD> value (choice)
|
||||
|
||||
<DT><B>value_size </B> <DD> size of value (integer)
|
||||
</DL>
|
||||
<P>
|
||||
<H2>Thread and Interrupt Safety</H2>
|
||||
<P>
|
||||
This routine is thread-safe. This means that this routine may be
|
||||
safely used by multiple threads without the need for any user-provided
|
||||
thread locks. However, the routine is not interrupt safe. Typically,
|
||||
this is due to the use of memory allocation routines such as <tt>malloc
|
||||
</tt>or other non-MPICH runtime routines that are themselves not interrupt-safe.
|
||||
<P>
|
||||
<H2>Notes for Fortran</H2>
|
||||
All MPI routines in Fortran (except for <tt>MPI_WTIME</tt> and <tt>MPI_WTICK</tt>) have
|
||||
an additional argument <tt>ierr</tt> at the end of the argument list. <tt>ierr
|
||||
</tt>is an integer and has the same meaning as the return value of the routine
|
||||
in C. In Fortran, MPI routines are subroutines, and are invoked with the
|
||||
<tt>call</tt> statement.
|
||||
<P>
|
||||
All MPI objects (e.g., <tt>MPI_Datatype</tt>, <tt>MPI_Comm</tt>) are of type <tt>INTEGER
|
||||
</tt>in Fortran.
|
||||
<P>
|
||||
<H2>Errors</H2>
|
||||
<P>
|
||||
All MPI routines (except <tt>MPI_Wtime</tt> and <tt>MPI_Wtick</tt>) return an error value;
|
||||
C routines as the value of the function and Fortran routines in the last
|
||||
argument. Before the value is returned, the current MPI error handler is
|
||||
called. By default, this error handler aborts the MPI job. The error handler
|
||||
may be changed with <tt>MPI_Comm_set_errhandler</tt> (for communicators),
|
||||
<tt>MPI_File_set_errhandler</tt> (for files), and <tt>MPI_Win_set_errhandler</tt> (for
|
||||
RMA windows). The MPI-1 routine <tt>MPI_Errhandler_set</tt> may be used but
|
||||
its use is deprecated. The predefined error handler
|
||||
<tt>MPI_ERRORS_RETURN</tt> may be used to cause error values to be returned.
|
||||
Note that MPI does <em>not</em> guarantee that an MPI program can continue past
|
||||
an error; however, MPI implementations will attempt to continue whenever
|
||||
possible.
|
||||
<P>
|
||||
<DL>
|
||||
<DT><B>MPI_SUCCESS </B> <DD> No error; MPI routine completed successfully.
|
||||
</DL>
|
||||
<DL>
|
||||
<DT><B>MPI_ERR_ARG </B> <DD> Invalid argument. Some argument is invalid and is not
|
||||
identified by a specific error class (e.g., <tt>MPI_ERR_RANK</tt>).
|
||||
</DL>
|
||||
<DL>
|
||||
<DT><B>MPI_ERR_INFO </B> <DD> Invalid Info
|
||||
</DL>
|
||||
<DL>
|
||||
<DT><B>MPI_ERR_OTHER </B> <DD> Other error; use <tt>MPI_Error_string</tt> to get more information
|
||||
about this error code.
|
||||
</DL>
|
||||
<P>
|
||||
</BODY></HTML>
|
||||
118
macx64/mpi/mpich/share/doc/mpich/www3/MPIX_Irecv_enqueue.html
Normal file
118
macx64/mpi/mpich/share/doc/mpich/www3/MPIX_Irecv_enqueue.html
Normal file
@@ -0,0 +1,118 @@
|
||||
<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML3.2 EN">
|
||||
<HTML>
|
||||
<HEAD>
|
||||
<META NAME="GENERATOR" CONTENT="DOCTEXT">
|
||||
<TITLE>MPIX_Irecv_enqueue</TITLE>
|
||||
</HEAD>
|
||||
<BODY BGCOLOR="FFFFFF">
|
||||
<H1 id="MPIX_Irecv_enqueue">MPIX_Irecv_enqueue</H1>
|
||||
Enqueue a nonblocking receive operation to a GPU stream that is associated with the local stream
|
||||
<H2>Synopsis</H2>
|
||||
<PRE>
|
||||
</PRE>
|
||||
<PRE>
|
||||
int MPIX_Irecv_enqueue(void *buf, int count, MPI_Datatype datatype, int source,
|
||||
int tag, MPI_Comm comm, MPI_Request *request)
|
||||
</PRE>
|
||||
|
||||
<PRE>
|
||||
int MPIX_Irecv_enqueue_c(void *buf, MPI_Count count, MPI_Datatype datatype,
|
||||
int source, int tag, MPI_Comm comm,
|
||||
MPI_Request *request)
|
||||
</PRE>
|
||||
|
||||
<P>
|
||||
<H2>Input Parameters</H2>
|
||||
<DL>
|
||||
<DT><B>count </B> <DD> number of elements in receive buffer (non-negative integer)
|
||||
|
||||
<DT><B>datatype </B> <DD> datatype of each receive buffer element (handle)
|
||||
|
||||
<DT><B>source </B> <DD> rank of source or MPI_ANY_SOURCE (integer)
|
||||
|
||||
<DT><B>tag </B> <DD> message tag or MPI_ANY_TAG (integer)
|
||||
|
||||
<DT><B>comm </B> <DD> communicator (handle)
|
||||
</DL>
|
||||
<P>
|
||||
<H2>Output Parameters</H2>
|
||||
<DL>
|
||||
<DT><B>buf </B> <DD> initial address of receive buffer (choice)
|
||||
|
||||
<DT><B>request </B> <DD> communication request (handle)
|
||||
</DL>
|
||||
<P>
|
||||
<H2>Thread and Interrupt Safety</H2>
|
||||
<P>
|
||||
This routine is thread-safe. This means that this routine may be
|
||||
safely used by multiple threads without the need for any user-provided
|
||||
thread locks. However, the routine is not interrupt safe. Typically,
|
||||
this is due to the use of memory allocation routines such as <tt>malloc
|
||||
</tt>or other non-MPICH runtime routines that are themselves not interrupt-safe.
|
||||
<P>
|
||||
<H2>Notes for Fortran</H2>
|
||||
All MPI routines in Fortran (except for <tt>MPI_WTIME</tt> and <tt>MPI_WTICK</tt>) have
|
||||
an additional argument <tt>ierr</tt> at the end of the argument list. <tt>ierr
|
||||
</tt>is an integer and has the same meaning as the return value of the routine
|
||||
in C. In Fortran, MPI routines are subroutines, and are invoked with the
|
||||
<tt>call</tt> statement.
|
||||
<P>
|
||||
All MPI objects (e.g., <tt>MPI_Datatype</tt>, <tt>MPI_Comm</tt>) are of type <tt>INTEGER
|
||||
</tt>in Fortran.
|
||||
<P>
|
||||
<H2>Errors</H2>
|
||||
<P>
|
||||
All MPI routines (except <tt>MPI_Wtime</tt> and <tt>MPI_Wtick</tt>) return an error value;
|
||||
C routines as the value of the function and Fortran routines in the last
|
||||
argument. Before the value is returned, the current MPI error handler is
|
||||
called. By default, this error handler aborts the MPI job. The error handler
|
||||
may be changed with <tt>MPI_Comm_set_errhandler</tt> (for communicators),
|
||||
<tt>MPI_File_set_errhandler</tt> (for files), and <tt>MPI_Win_set_errhandler</tt> (for
|
||||
RMA windows). The MPI-1 routine <tt>MPI_Errhandler_set</tt> may be used but
|
||||
its use is deprecated. The predefined error handler
|
||||
<tt>MPI_ERRORS_RETURN</tt> may be used to cause error values to be returned.
|
||||
Note that MPI does <em>not</em> guarantee that an MPI program can continue past
|
||||
an error; however, MPI implementations will attempt to continue whenever
|
||||
possible.
|
||||
<P>
|
||||
<DL>
|
||||
<DT><B>MPI_SUCCESS </B> <DD> No error; MPI routine completed successfully.
|
||||
</DL>
|
||||
<DL>
|
||||
<DT><B>MPI_ERR_ARG </B> <DD> Invalid argument. Some argument is invalid and is not
|
||||
identified by a specific error class (e.g., <tt>MPI_ERR_RANK</tt>).
|
||||
</DL>
|
||||
<DL>
|
||||
<DT><B>MPI_ERR_BUFFER </B> <DD> Invalid buffer pointer. Usually a null buffer where
|
||||
one is not valid.
|
||||
</DL>
|
||||
<DL>
|
||||
<DT><B>MPI_ERR_COMM </B> <DD> Invalid communicator. A common error is to use a null
|
||||
communicator in a call (not even allowed in <tt>MPI_Comm_rank</tt>).
|
||||
</DL>
|
||||
<DL>
|
||||
<DT><B>MPI_ERR_COUNT </B> <DD> Invalid count argument. Count arguments must be
|
||||
non-negative; a count of zero is often valid.
|
||||
</DL>
|
||||
<DL>
|
||||
<DT><B>MPI_ERR_RANK </B> <DD> Invalid source or destination rank. Ranks must be between
|
||||
zero and the size of the communicator minus one; ranks in a receive
|
||||
(<tt>MPI_Recv</tt>, <tt>MPI_Irecv</tt>, <tt>MPI_Sendrecv</tt>, etc.) may also be <tt>MPI_ANY_SOURCE</tt>.
|
||||
</DL>
|
||||
<DL>
|
||||
<DT><B>MPI_ERR_TAG </B> <DD> Invalid tag argument. Tags must be non-negative; tags
|
||||
in a receive (<tt>MPI_Recv</tt>, <tt>MPI_Irecv</tt>, <tt>MPI_Sendrecv</tt>, etc.) may
|
||||
also be <tt>MPI_ANY_TAG</tt>. The largest tag value is available through the
|
||||
the attribute <tt>MPI_TAG_UB</tt>.
|
||||
</DL>
|
||||
<DL>
|
||||
<DT><B>MPI_ERR_TYPE </B> <DD> Invalid datatype argument. Additionally, this error can
|
||||
occur if an uncommitted MPI_Datatype (see <tt>MPI_Type_commit</tt>) is used
|
||||
in a communication call.
|
||||
</DL>
|
||||
<DL>
|
||||
<DT><B>MPI_ERR_OTHER </B> <DD> Other error; use <tt>MPI_Error_string</tt> to get more information
|
||||
about this error code.
|
||||
</DL>
|
||||
<P>
|
||||
</BODY></HTML>
|
||||
@@ -0,0 +1 @@
|
||||
<meta http-equiv="refresh" content="0; url=MPIX_Irecv_enqueue.html">
|
||||
118
macx64/mpi/mpich/share/doc/mpich/www3/MPIX_Isend_enqueue.html
Normal file
118
macx64/mpi/mpich/share/doc/mpich/www3/MPIX_Isend_enqueue.html
Normal file
@@ -0,0 +1,118 @@
|
||||
<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML3.2 EN">
|
||||
<HTML>
|
||||
<HEAD>
|
||||
<META NAME="GENERATOR" CONTENT="DOCTEXT">
|
||||
<TITLE>MPIX_Isend_enqueue</TITLE>
|
||||
</HEAD>
|
||||
<BODY BGCOLOR="FFFFFF">
|
||||
<H1 id="MPIX_Isend_enqueue">MPIX_Isend_enqueue</H1>
|
||||
Enqueue a nonblocking send operation to a GPU stream that is associated with the local stream
|
||||
<H2>Synopsis</H2>
|
||||
<PRE>
|
||||
</PRE>
|
||||
<PRE>
|
||||
int MPIX_Isend_enqueue(const void *buf, int count, MPI_Datatype datatype,
|
||||
int dest, int tag, MPI_Comm comm, MPI_Request *request)
|
||||
</PRE>
|
||||
|
||||
<PRE>
|
||||
int MPIX_Isend_enqueue_c(const void *buf, MPI_Count count,
|
||||
MPI_Datatype datatype, int dest, int tag,
|
||||
MPI_Comm comm, MPI_Request *request)
|
||||
</PRE>
|
||||
|
||||
<P>
|
||||
<H2>Input Parameters</H2>
|
||||
<DL>
|
||||
<DT><B>buf </B> <DD> initial address of send buffer (choice)
|
||||
|
||||
<DT><B>count </B> <DD> number of elements in send buffer (non-negative integer)
|
||||
|
||||
<DT><B>datatype </B> <DD> datatype of each send buffer element (handle)
|
||||
|
||||
<DT><B>dest </B> <DD> rank of destination (integer)
|
||||
|
||||
<DT><B>tag </B> <DD> message tag (integer)
|
||||
|
||||
<DT><B>comm </B> <DD> communicator (handle)
|
||||
</DL>
|
||||
<P>
|
||||
<H2>Output Parameters</H2>
|
||||
<DL>
|
||||
<DT><B>request </B> <DD> communication request (handle)
|
||||
</DL>
|
||||
<P>
|
||||
<H2>Thread and Interrupt Safety</H2>
|
||||
<P>
|
||||
This routine is thread-safe. This means that this routine may be
|
||||
safely used by multiple threads without the need for any user-provided
|
||||
thread locks. However, the routine is not interrupt safe. Typically,
|
||||
this is due to the use of memory allocation routines such as <tt>malloc
|
||||
</tt>or other non-MPICH runtime routines that are themselves not interrupt-safe.
|
||||
<P>
|
||||
<H2>Notes for Fortran</H2>
|
||||
All MPI routines in Fortran (except for <tt>MPI_WTIME</tt> and <tt>MPI_WTICK</tt>) have
|
||||
an additional argument <tt>ierr</tt> at the end of the argument list. <tt>ierr
|
||||
</tt>is an integer and has the same meaning as the return value of the routine
|
||||
in C. In Fortran, MPI routines are subroutines, and are invoked with the
|
||||
<tt>call</tt> statement.
|
||||
<P>
|
||||
All MPI objects (e.g., <tt>MPI_Datatype</tt>, <tt>MPI_Comm</tt>) are of type <tt>INTEGER
|
||||
</tt>in Fortran.
|
||||
<P>
|
||||
<H2>Errors</H2>
|
||||
<P>
|
||||
All MPI routines (except <tt>MPI_Wtime</tt> and <tt>MPI_Wtick</tt>) return an error value;
|
||||
C routines as the value of the function and Fortran routines in the last
|
||||
argument. Before the value is returned, the current MPI error handler is
|
||||
called. By default, this error handler aborts the MPI job. The error handler
|
||||
may be changed with <tt>MPI_Comm_set_errhandler</tt> (for communicators),
|
||||
<tt>MPI_File_set_errhandler</tt> (for files), and <tt>MPI_Win_set_errhandler</tt> (for
|
||||
RMA windows). The MPI-1 routine <tt>MPI_Errhandler_set</tt> may be used but
|
||||
its use is deprecated. The predefined error handler
|
||||
<tt>MPI_ERRORS_RETURN</tt> may be used to cause error values to be returned.
|
||||
Note that MPI does <em>not</em> guarantee that an MPI program can continue past
|
||||
an error; however, MPI implementations will attempt to continue whenever
|
||||
possible.
|
||||
<P>
|
||||
<DL>
|
||||
<DT><B>MPI_SUCCESS </B> <DD> No error; MPI routine completed successfully.
|
||||
</DL>
|
||||
<DL>
|
||||
<DT><B>MPI_ERR_ARG </B> <DD> Invalid argument. Some argument is invalid and is not
|
||||
identified by a specific error class (e.g., <tt>MPI_ERR_RANK</tt>).
|
||||
</DL>
|
||||
<DL>
|
||||
<DT><B>MPI_ERR_BUFFER </B> <DD> Invalid buffer pointer. Usually a null buffer where
|
||||
one is not valid.
|
||||
</DL>
|
||||
<DL>
|
||||
<DT><B>MPI_ERR_COMM </B> <DD> Invalid communicator. A common error is to use a null
|
||||
communicator in a call (not even allowed in <tt>MPI_Comm_rank</tt>).
|
||||
</DL>
|
||||
<DL>
|
||||
<DT><B>MPI_ERR_COUNT </B> <DD> Invalid count argument. Count arguments must be
|
||||
non-negative; a count of zero is often valid.
|
||||
</DL>
|
||||
<DL>
|
||||
<DT><B>MPI_ERR_RANK </B> <DD> Invalid source or destination rank. Ranks must be between
|
||||
zero and the size of the communicator minus one; ranks in a receive
|
||||
(<tt>MPI_Recv</tt>, <tt>MPI_Irecv</tt>, <tt>MPI_Sendrecv</tt>, etc.) may also be <tt>MPI_ANY_SOURCE</tt>.
|
||||
</DL>
|
||||
<DL>
|
||||
<DT><B>MPI_ERR_TAG </B> <DD> Invalid tag argument. Tags must be non-negative; tags
|
||||
in a receive (<tt>MPI_Recv</tt>, <tt>MPI_Irecv</tt>, <tt>MPI_Sendrecv</tt>, etc.) may
|
||||
also be <tt>MPI_ANY_TAG</tt>. The largest tag value is available through the
|
||||
the attribute <tt>MPI_TAG_UB</tt>.
|
||||
</DL>
|
||||
<DL>
|
||||
<DT><B>MPI_ERR_TYPE </B> <DD> Invalid datatype argument. Additionally, this error can
|
||||
occur if an uncommitted MPI_Datatype (see <tt>MPI_Type_commit</tt>) is used
|
||||
in a communication call.
|
||||
</DL>
|
||||
<DL>
|
||||
<DT><B>MPI_ERR_OTHER </B> <DD> Other error; use <tt>MPI_Error_string</tt> to get more information
|
||||
about this error code.
|
||||
</DL>
|
||||
<P>
|
||||
</BODY></HTML>
|
||||
@@ -0,0 +1 @@
|
||||
<meta http-equiv="refresh" content="0; url=MPIX_Isend_enqueue.html">
|
||||
94
macx64/mpi/mpich/share/doc/mpich/www3/MPIX_Op_create_x.html
Normal file
94
macx64/mpi/mpich/share/doc/mpich/www3/MPIX_Op_create_x.html
Normal file
@@ -0,0 +1,94 @@
|
||||
<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML3.2 EN">
|
||||
<HTML>
|
||||
<HEAD>
|
||||
<META NAME="GENERATOR" CONTENT="DOCTEXT">
|
||||
<TITLE>MPIX_Op_create_x</TITLE>
|
||||
</HEAD>
|
||||
<BODY BGCOLOR="FFFFFF">
|
||||
<H1 id="MPIX_Op_create_x">MPIX_Op_create_x</H1>
|
||||
Creates a user-defined reduction op with an extra_state
|
||||
<H2>Synopsis</H2>
|
||||
<PRE>
|
||||
</PRE>
|
||||
<PRE>
|
||||
int MPIX_Op_create_x(MPIX_User_function_x *user_fn_x,
|
||||
MPIX_Destructor_function *destructor_fn, int commute,
|
||||
void *extra_state, MPI_Op *op)
|
||||
</PRE>
|
||||
|
||||
<P>
|
||||
<H2>Input Parameters</H2>
|
||||
<DL>
|
||||
<DT><B>user_fn_x </B> <DD> user defined function with extra_state (function)
|
||||
|
||||
<DT><B>destructor_fn </B> <DD> callback when op is freed (function)
|
||||
|
||||
<DT><B>commute </B> <DD> true if commutative; false otherwise. (logical)
|
||||
|
||||
<DT><B>extra_state </B> <DD> extra state (None)
|
||||
</DL>
|
||||
<P>
|
||||
<H2>Output Parameters</H2>
|
||||
<DL>
|
||||
<DT><B>op </B> <DD> operation (handle)
|
||||
</DL>
|
||||
<P>
|
||||
<H2>Notes on MPIX_User_function_x</H2>
|
||||
The calling list for the user function type is
|
||||
<PRE>
|
||||
typedef void (MPIX_User_function_x) (void * a, void * b,
|
||||
MPI_Count len, MPI_Datatype datatype,
|
||||
void *extra_state);
|
||||
</PRE>
|
||||
|
||||
There are a few differences from MPI_User_function used in MPI_Op_create.
|
||||
1. It passes len and datatype as scalar input, rather than as addresses.
|
||||
2. The len is of MPI_Count, rather than int.
|
||||
3. It accepts a void *extra_state which is passed from users during MPIX_Op_create_x.
|
||||
<P>
|
||||
<H2>Thread and Interrupt Safety</H2>
|
||||
<P>
|
||||
This routine is thread-safe. This means that this routine may be
|
||||
safely used by multiple threads without the need for any user-provided
|
||||
thread locks. However, the routine is not interrupt safe. Typically,
|
||||
this is due to the use of memory allocation routines such as <tt>malloc
|
||||
</tt>or other non-MPICH runtime routines that are themselves not interrupt-safe.
|
||||
<P>
|
||||
<H2>Notes for Fortran</H2>
|
||||
All MPI routines in Fortran (except for <tt>MPI_WTIME</tt> and <tt>MPI_WTICK</tt>) have
|
||||
an additional argument <tt>ierr</tt> at the end of the argument list. <tt>ierr
|
||||
</tt>is an integer and has the same meaning as the return value of the routine
|
||||
in C. In Fortran, MPI routines are subroutines, and are invoked with the
|
||||
<tt>call</tt> statement.
|
||||
<P>
|
||||
All MPI objects (e.g., <tt>MPI_Datatype</tt>, <tt>MPI_Comm</tt>) are of type <tt>INTEGER
|
||||
</tt>in Fortran.
|
||||
<P>
|
||||
<H2>Errors</H2>
|
||||
<P>
|
||||
All MPI routines (except <tt>MPI_Wtime</tt> and <tt>MPI_Wtick</tt>) return an error value;
|
||||
C routines as the value of the function and Fortran routines in the last
|
||||
argument. Before the value is returned, the current MPI error handler is
|
||||
called. By default, this error handler aborts the MPI job. The error handler
|
||||
may be changed with <tt>MPI_Comm_set_errhandler</tt> (for communicators),
|
||||
<tt>MPI_File_set_errhandler</tt> (for files), and <tt>MPI_Win_set_errhandler</tt> (for
|
||||
RMA windows). The MPI-1 routine <tt>MPI_Errhandler_set</tt> may be used but
|
||||
its use is deprecated. The predefined error handler
|
||||
<tt>MPI_ERRORS_RETURN</tt> may be used to cause error values to be returned.
|
||||
Note that MPI does <em>not</em> guarantee that an MPI program can continue past
|
||||
an error; however, MPI implementations will attempt to continue whenever
|
||||
possible.
|
||||
<P>
|
||||
<DL>
|
||||
<DT><B>MPI_SUCCESS </B> <DD> No error; MPI routine completed successfully.
|
||||
</DL>
|
||||
<DL>
|
||||
<DT><B>MPI_ERR_ARG </B> <DD> Invalid argument. Some argument is invalid and is not
|
||||
identified by a specific error class (e.g., <tt>MPI_ERR_RANK</tt>).
|
||||
</DL>
|
||||
<DL>
|
||||
<DT><B>MPI_ERR_OTHER </B> <DD> Other error; use <tt>MPI_Error_string</tt> to get more information
|
||||
about this error code.
|
||||
</DL>
|
||||
<P>
|
||||
</BODY></HTML>
|
||||
@@ -0,0 +1,36 @@
|
||||
<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML3.2 EN">
|
||||
<HTML>
|
||||
<HEAD>
|
||||
<META NAME="GENERATOR" CONTENT="DOCTEXT">
|
||||
<TITLE>MPIX_Query_cuda_support</TITLE>
|
||||
</HEAD>
|
||||
<BODY BGCOLOR="FFFFFF">
|
||||
<H1 id="MPIX_Query_cuda_support">MPIX_Query_cuda_support</H1>
|
||||
Returns whether CUDA is supported
|
||||
<H2>Synopsis</H2>
|
||||
<PRE>
|
||||
</PRE>
|
||||
<PRE>
|
||||
int MPIX_Query_cuda_support(void)
|
||||
</PRE>
|
||||
|
||||
<P>
|
||||
<H2>Thread and Interrupt Safety</H2>
|
||||
<P>
|
||||
This routine is thread-safe. This means that this routine may be
|
||||
safely used by multiple threads without the need for any user-provided
|
||||
thread locks. However, the routine is not interrupt safe. Typically,
|
||||
this is due to the use of memory allocation routines such as <tt>malloc
|
||||
</tt>or other non-MPICH runtime routines that are themselves not interrupt-safe.
|
||||
<P>
|
||||
<H2>Notes for Fortran</H2>
|
||||
All MPI routines in Fortran (except for <tt>MPI_WTIME</tt> and <tt>MPI_WTICK</tt>) have
|
||||
an additional argument <tt>ierr</tt> at the end of the argument list. <tt>ierr
|
||||
</tt>is an integer and has the same meaning as the return value of the routine
|
||||
in C. In Fortran, MPI routines are subroutines, and are invoked with the
|
||||
<tt>call</tt> statement.
|
||||
<P>
|
||||
All MPI objects (e.g., <tt>MPI_Datatype</tt>, <tt>MPI_Comm</tt>) are of type <tt>INTEGER
|
||||
</tt>in Fortran.
|
||||
<P>
|
||||
</BODY></HTML>
|
||||
@@ -0,0 +1,36 @@
|
||||
<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML3.2 EN">
|
||||
<HTML>
|
||||
<HEAD>
|
||||
<META NAME="GENERATOR" CONTENT="DOCTEXT">
|
||||
<TITLE>MPIX_Query_hip_support</TITLE>
|
||||
</HEAD>
|
||||
<BODY BGCOLOR="FFFFFF">
|
||||
<H1 id="MPIX_Query_hip_support">MPIX_Query_hip_support</H1>
|
||||
Returns whether HIP (AMD GPU) is supported
|
||||
<H2>Synopsis</H2>
|
||||
<PRE>
|
||||
</PRE>
|
||||
<PRE>
|
||||
int MPIX_Query_hip_support(void)
|
||||
</PRE>
|
||||
|
||||
<P>
|
||||
<H2>Thread and Interrupt Safety</H2>
|
||||
<P>
|
||||
This routine is thread-safe. This means that this routine may be
|
||||
safely used by multiple threads without the need for any user-provided
|
||||
thread locks. However, the routine is not interrupt safe. Typically,
|
||||
this is due to the use of memory allocation routines such as <tt>malloc
|
||||
</tt>or other non-MPICH runtime routines that are themselves not interrupt-safe.
|
||||
<P>
|
||||
<H2>Notes for Fortran</H2>
|
||||
All MPI routines in Fortran (except for <tt>MPI_WTIME</tt> and <tt>MPI_WTICK</tt>) have
|
||||
an additional argument <tt>ierr</tt> at the end of the argument list. <tt>ierr
|
||||
</tt>is an integer and has the same meaning as the return value of the routine
|
||||
in C. In Fortran, MPI routines are subroutines, and are invoked with the
|
||||
<tt>call</tt> statement.
|
||||
<P>
|
||||
All MPI objects (e.g., <tt>MPI_Datatype</tt>, <tt>MPI_Comm</tt>) are of type <tt>INTEGER
|
||||
</tt>in Fortran.
|
||||
<P>
|
||||
</BODY></HTML>
|
||||
@@ -0,0 +1,36 @@
|
||||
<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML3.2 EN">
|
||||
<HTML>
|
||||
<HEAD>
|
||||
<META NAME="GENERATOR" CONTENT="DOCTEXT">
|
||||
<TITLE>MPIX_Query_ze_support</TITLE>
|
||||
</HEAD>
|
||||
<BODY BGCOLOR="FFFFFF">
|
||||
<H1 id="MPIX_Query_ze_support">MPIX_Query_ze_support</H1>
|
||||
Returns whether ZE (Intel GPU) is supported
|
||||
<H2>Synopsis</H2>
|
||||
<PRE>
|
||||
</PRE>
|
||||
<PRE>
|
||||
int MPIX_Query_ze_support(void)
|
||||
</PRE>
|
||||
|
||||
<P>
|
||||
<H2>Thread and Interrupt Safety</H2>
|
||||
<P>
|
||||
This routine is thread-safe. This means that this routine may be
|
||||
safely used by multiple threads without the need for any user-provided
|
||||
thread locks. However, the routine is not interrupt safe. Typically,
|
||||
this is due to the use of memory allocation routines such as <tt>malloc
|
||||
</tt>or other non-MPICH runtime routines that are themselves not interrupt-safe.
|
||||
<P>
|
||||
<H2>Notes for Fortran</H2>
|
||||
All MPI routines in Fortran (except for <tt>MPI_WTIME</tt> and <tt>MPI_WTICK</tt>) have
|
||||
an additional argument <tt>ierr</tt> at the end of the argument list. <tt>ierr
|
||||
</tt>is an integer and has the same meaning as the return value of the routine
|
||||
in C. In Fortran, MPI routines are subroutines, and are invoked with the
|
||||
<tt>call</tt> statement.
|
||||
<P>
|
||||
All MPI objects (e.g., <tt>MPI_Datatype</tt>, <tt>MPI_Comm</tt>) are of type <tt>INTEGER
|
||||
</tt>in Fortran.
|
||||
<P>
|
||||
</BODY></HTML>
|
||||
117
macx64/mpi/mpich/share/doc/mpich/www3/MPIX_Recv_enqueue.html
Normal file
117
macx64/mpi/mpich/share/doc/mpich/www3/MPIX_Recv_enqueue.html
Normal file
@@ -0,0 +1,117 @@
|
||||
<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML3.2 EN">
|
||||
<HTML>
|
||||
<HEAD>
|
||||
<META NAME="GENERATOR" CONTENT="DOCTEXT">
|
||||
<TITLE>MPIX_Recv_enqueue</TITLE>
|
||||
</HEAD>
|
||||
<BODY BGCOLOR="FFFFFF">
|
||||
<H1 id="MPIX_Recv_enqueue">MPIX_Recv_enqueue</H1>
|
||||
Enqueue a receive operation to a GPU stream that is associated with the local stream
|
||||
<H2>Synopsis</H2>
|
||||
<PRE>
|
||||
</PRE>
|
||||
<PRE>
|
||||
int MPIX_Recv_enqueue(void *buf, int count, MPI_Datatype datatype, int source,
|
||||
int tag, MPI_Comm comm, MPI_Status *status)
|
||||
</PRE>
|
||||
|
||||
<PRE>
|
||||
int MPIX_Recv_enqueue_c(void *buf, MPI_Count count, MPI_Datatype datatype,
|
||||
int source, int tag, MPI_Comm comm, MPI_Status *status)
|
||||
</PRE>
|
||||
|
||||
<P>
|
||||
<H2>Input Parameters</H2>
|
||||
<DL>
|
||||
<DT><B>count </B> <DD> number of elements in receive buffer (non-negative integer)
|
||||
|
||||
<DT><B>datatype </B> <DD> datatype of each receive buffer element (handle)
|
||||
|
||||
<DT><B>source </B> <DD> rank of source or MPI_ANY_SOURCE (integer)
|
||||
|
||||
<DT><B>tag </B> <DD> message tag or MPI_ANY_TAG (integer)
|
||||
|
||||
<DT><B>comm </B> <DD> communicator (handle)
|
||||
</DL>
|
||||
<P>
|
||||
<H2>Output Parameters</H2>
|
||||
<DL>
|
||||
<DT><B>buf </B> <DD> initial address of receive buffer (choice)
|
||||
|
||||
<DT><B>status </B> <DD> status object (Status)
|
||||
</DL>
|
||||
<P>
|
||||
<H2>Thread and Interrupt Safety</H2>
|
||||
<P>
|
||||
This routine is thread-safe. This means that this routine may be
|
||||
safely used by multiple threads without the need for any user-provided
|
||||
thread locks. However, the routine is not interrupt safe. Typically,
|
||||
this is due to the use of memory allocation routines such as <tt>malloc
|
||||
</tt>or other non-MPICH runtime routines that are themselves not interrupt-safe.
|
||||
<P>
|
||||
<H2>Notes for Fortran</H2>
|
||||
All MPI routines in Fortran (except for <tt>MPI_WTIME</tt> and <tt>MPI_WTICK</tt>) have
|
||||
an additional argument <tt>ierr</tt> at the end of the argument list. <tt>ierr
|
||||
</tt>is an integer and has the same meaning as the return value of the routine
|
||||
in C. In Fortran, MPI routines are subroutines, and are invoked with the
|
||||
<tt>call</tt> statement.
|
||||
<P>
|
||||
All MPI objects (e.g., <tt>MPI_Datatype</tt>, <tt>MPI_Comm</tt>) are of type <tt>INTEGER
|
||||
</tt>in Fortran.
|
||||
<P>
|
||||
<H2>Errors</H2>
|
||||
<P>
|
||||
All MPI routines (except <tt>MPI_Wtime</tt> and <tt>MPI_Wtick</tt>) return an error value;
|
||||
C routines as the value of the function and Fortran routines in the last
|
||||
argument. Before the value is returned, the current MPI error handler is
|
||||
called. By default, this error handler aborts the MPI job. The error handler
|
||||
may be changed with <tt>MPI_Comm_set_errhandler</tt> (for communicators),
|
||||
<tt>MPI_File_set_errhandler</tt> (for files), and <tt>MPI_Win_set_errhandler</tt> (for
|
||||
RMA windows). The MPI-1 routine <tt>MPI_Errhandler_set</tt> may be used but
|
||||
its use is deprecated. The predefined error handler
|
||||
<tt>MPI_ERRORS_RETURN</tt> may be used to cause error values to be returned.
|
||||
Note that MPI does <em>not</em> guarantee that an MPI program can continue past
|
||||
an error; however, MPI implementations will attempt to continue whenever
|
||||
possible.
|
||||
<P>
|
||||
<DL>
|
||||
<DT><B>MPI_SUCCESS </B> <DD> No error; MPI routine completed successfully.
|
||||
</DL>
|
||||
<DL>
|
||||
<DT><B>MPI_ERR_ARG </B> <DD> Invalid argument. Some argument is invalid and is not
|
||||
identified by a specific error class (e.g., <tt>MPI_ERR_RANK</tt>).
|
||||
</DL>
|
||||
<DL>
|
||||
<DT><B>MPI_ERR_BUFFER </B> <DD> Invalid buffer pointer. Usually a null buffer where
|
||||
one is not valid.
|
||||
</DL>
|
||||
<DL>
|
||||
<DT><B>MPI_ERR_COMM </B> <DD> Invalid communicator. A common error is to use a null
|
||||
communicator in a call (not even allowed in <tt>MPI_Comm_rank</tt>).
|
||||
</DL>
|
||||
<DL>
|
||||
<DT><B>MPI_ERR_COUNT </B> <DD> Invalid count argument. Count arguments must be
|
||||
non-negative; a count of zero is often valid.
|
||||
</DL>
|
||||
<DL>
|
||||
<DT><B>MPI_ERR_RANK </B> <DD> Invalid source or destination rank. Ranks must be between
|
||||
zero and the size of the communicator minus one; ranks in a receive
|
||||
(<tt>MPI_Recv</tt>, <tt>MPI_Irecv</tt>, <tt>MPI_Sendrecv</tt>, etc.) may also be <tt>MPI_ANY_SOURCE</tt>.
|
||||
</DL>
|
||||
<DL>
|
||||
<DT><B>MPI_ERR_TAG </B> <DD> Invalid tag argument. Tags must be non-negative; tags
|
||||
in a receive (<tt>MPI_Recv</tt>, <tt>MPI_Irecv</tt>, <tt>MPI_Sendrecv</tt>, etc.) may
|
||||
also be <tt>MPI_ANY_TAG</tt>. The largest tag value is available through the
|
||||
the attribute <tt>MPI_TAG_UB</tt>.
|
||||
</DL>
|
||||
<DL>
|
||||
<DT><B>MPI_ERR_TYPE </B> <DD> Invalid datatype argument. Additionally, this error can
|
||||
occur if an uncommitted MPI_Datatype (see <tt>MPI_Type_commit</tt>) is used
|
||||
in a communication call.
|
||||
</DL>
|
||||
<DL>
|
||||
<DT><B>MPI_ERR_OTHER </B> <DD> Other error; use <tt>MPI_Error_string</tt> to get more information
|
||||
about this error code.
|
||||
</DL>
|
||||
<P>
|
||||
</BODY></HTML>
|
||||
@@ -0,0 +1 @@
|
||||
<meta http-equiv="refresh" content="0; url=MPIX_Recv_enqueue.html">
|
||||
@@ -0,0 +1,64 @@
|
||||
<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML3.2 EN">
|
||||
<HTML>
|
||||
<HEAD>
|
||||
<META NAME="GENERATOR" CONTENT="DOCTEXT">
|
||||
<TITLE>MPIX_Request_is_complete</TITLE>
|
||||
</HEAD>
|
||||
<BODY BGCOLOR="FFFFFF">
|
||||
<H1 id="MPIX_Request_is_complete">MPIX_Request_is_complete</H1>
|
||||
[short description]
|
||||
<H2>Synopsis</H2>
|
||||
<PRE>
|
||||
</PRE>
|
||||
<PRE>
|
||||
int MPIX_Request_is_complete(MPI_Request request)
|
||||
</PRE>
|
||||
|
||||
<P>
|
||||
<H2>Input Parameters</H2>
|
||||
<DL>
|
||||
<DT><B>request </B> <DD> communication request (handle)
|
||||
</DL>
|
||||
<P>
|
||||
<H2>Thread and Interrupt Safety</H2>
|
||||
<P>
|
||||
This routine is thread-safe. This means that this routine may be
|
||||
safely used by multiple threads without the need for any user-provided
|
||||
thread locks. However, the routine is not interrupt safe. Typically,
|
||||
this is due to the use of memory allocation routines such as <tt>malloc
|
||||
</tt>or other non-MPICH runtime routines that are themselves not interrupt-safe.
|
||||
<P>
|
||||
<H2>Notes for Fortran</H2>
|
||||
All MPI routines in Fortran (except for <tt>MPI_WTIME</tt> and <tt>MPI_WTICK</tt>) have
|
||||
an additional argument <tt>ierr</tt> at the end of the argument list. <tt>ierr
|
||||
</tt>is an integer and has the same meaning as the return value of the routine
|
||||
in C. In Fortran, MPI routines are subroutines, and are invoked with the
|
||||
<tt>call</tt> statement.
|
||||
<P>
|
||||
All MPI objects (e.g., <tt>MPI_Datatype</tt>, <tt>MPI_Comm</tt>) are of type <tt>INTEGER
|
||||
</tt>in Fortran.
|
||||
<P>
|
||||
<H2>Errors</H2>
|
||||
<P>
|
||||
All MPI routines (except <tt>MPI_Wtime</tt> and <tt>MPI_Wtick</tt>) return an error value;
|
||||
C routines as the value of the function and Fortran routines in the last
|
||||
argument. Before the value is returned, the current MPI error handler is
|
||||
called. By default, this error handler aborts the MPI job. The error handler
|
||||
may be changed with <tt>MPI_Comm_set_errhandler</tt> (for communicators),
|
||||
<tt>MPI_File_set_errhandler</tt> (for files), and <tt>MPI_Win_set_errhandler</tt> (for
|
||||
RMA windows). The MPI-1 routine <tt>MPI_Errhandler_set</tt> may be used but
|
||||
its use is deprecated. The predefined error handler
|
||||
<tt>MPI_ERRORS_RETURN</tt> may be used to cause error values to be returned.
|
||||
Note that MPI does <em>not</em> guarantee that an MPI program can continue past
|
||||
an error; however, MPI implementations will attempt to continue whenever
|
||||
possible.
|
||||
<P>
|
||||
<DL>
|
||||
<DT><B>MPI_SUCCESS </B> <DD> No error; MPI routine completed successfully.
|
||||
</DL>
|
||||
<DL>
|
||||
<DT><B>MPI_ERR_OTHER </B> <DD> Other error; use <tt>MPI_Error_string</tt> to get more information
|
||||
about this error code.
|
||||
</DL>
|
||||
<P>
|
||||
</BODY></HTML>
|
||||
108
macx64/mpi/mpich/share/doc/mpich/www3/MPIX_Send_enqueue.html
Normal file
108
macx64/mpi/mpich/share/doc/mpich/www3/MPIX_Send_enqueue.html
Normal file
@@ -0,0 +1,108 @@
|
||||
<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML3.2 EN">
|
||||
<HTML>
|
||||
<HEAD>
|
||||
<META NAME="GENERATOR" CONTENT="DOCTEXT">
|
||||
<TITLE>MPIX_Send_enqueue</TITLE>
|
||||
</HEAD>
|
||||
<BODY BGCOLOR="FFFFFF">
|
||||
<H1 id="MPIX_Send_enqueue">MPIX_Send_enqueue</H1>
|
||||
Enqueue a send operation to a GPU stream that is associated with the local stream
|
||||
<H2>Synopsis</H2>
|
||||
<PRE>
|
||||
</PRE>
|
||||
<PRE>
|
||||
int MPIX_Send_enqueue(const void *buf, int count, MPI_Datatype datatype,
|
||||
int dest, int tag, MPI_Comm comm)
|
||||
</PRE>
|
||||
|
||||
<PRE>
|
||||
int MPIX_Send_enqueue_c(const void *buf, MPI_Count count, MPI_Datatype datatype,
|
||||
int dest, int tag, MPI_Comm comm)
|
||||
</PRE>
|
||||
|
||||
<P>
|
||||
<H2>Input Parameters</H2>
|
||||
<DL>
|
||||
<DT><B>buf </B> <DD> initial address of send buffer (choice)
|
||||
|
||||
<DT><B>count </B> <DD> number of elements in send buffer (non-negative integer)
|
||||
|
||||
<DT><B>datatype </B> <DD> datatype of each send buffer element (handle)
|
||||
|
||||
<DT><B>dest </B> <DD> rank of destination (integer)
|
||||
|
||||
<DT><B>tag </B> <DD> message tag (integer)
|
||||
|
||||
<DT><B>comm </B> <DD> communicator (handle)
|
||||
</DL>
|
||||
<P>
|
||||
<H2>Thread and Interrupt Safety</H2>
|
||||
<P>
|
||||
This routine is thread-safe. This means that this routine may be
|
||||
safely used by multiple threads without the need for any user-provided
|
||||
thread locks. However, the routine is not interrupt safe. Typically,
|
||||
this is due to the use of memory allocation routines such as <tt>malloc
|
||||
</tt>or other non-MPICH runtime routines that are themselves not interrupt-safe.
|
||||
<P>
|
||||
<H2>Notes for Fortran</H2>
|
||||
All MPI routines in Fortran (except for <tt>MPI_WTIME</tt> and <tt>MPI_WTICK</tt>) have
|
||||
an additional argument <tt>ierr</tt> at the end of the argument list. <tt>ierr
|
||||
</tt>is an integer and has the same meaning as the return value of the routine
|
||||
in C. In Fortran, MPI routines are subroutines, and are invoked with the
|
||||
<tt>call</tt> statement.
|
||||
<P>
|
||||
All MPI objects (e.g., <tt>MPI_Datatype</tt>, <tt>MPI_Comm</tt>) are of type <tt>INTEGER
|
||||
</tt>in Fortran.
|
||||
<P>
|
||||
<H2>Errors</H2>
|
||||
<P>
|
||||
All MPI routines (except <tt>MPI_Wtime</tt> and <tt>MPI_Wtick</tt>) return an error value;
|
||||
C routines as the value of the function and Fortran routines in the last
|
||||
argument. Before the value is returned, the current MPI error handler is
|
||||
called. By default, this error handler aborts the MPI job. The error handler
|
||||
may be changed with <tt>MPI_Comm_set_errhandler</tt> (for communicators),
|
||||
<tt>MPI_File_set_errhandler</tt> (for files), and <tt>MPI_Win_set_errhandler</tt> (for
|
||||
RMA windows). The MPI-1 routine <tt>MPI_Errhandler_set</tt> may be used but
|
||||
its use is deprecated. The predefined error handler
|
||||
<tt>MPI_ERRORS_RETURN</tt> may be used to cause error values to be returned.
|
||||
Note that MPI does <em>not</em> guarantee that an MPI program can continue past
|
||||
an error; however, MPI implementations will attempt to continue whenever
|
||||
possible.
|
||||
<P>
|
||||
<DL>
|
||||
<DT><B>MPI_SUCCESS </B> <DD> No error; MPI routine completed successfully.
|
||||
</DL>
|
||||
<DL>
|
||||
<DT><B>MPI_ERR_BUFFER </B> <DD> Invalid buffer pointer. Usually a null buffer where
|
||||
one is not valid.
|
||||
</DL>
|
||||
<DL>
|
||||
<DT><B>MPI_ERR_COMM </B> <DD> Invalid communicator. A common error is to use a null
|
||||
communicator in a call (not even allowed in <tt>MPI_Comm_rank</tt>).
|
||||
</DL>
|
||||
<DL>
|
||||
<DT><B>MPI_ERR_COUNT </B> <DD> Invalid count argument. Count arguments must be
|
||||
non-negative; a count of zero is often valid.
|
||||
</DL>
|
||||
<DL>
|
||||
<DT><B>MPI_ERR_RANK </B> <DD> Invalid source or destination rank. Ranks must be between
|
||||
zero and the size of the communicator minus one; ranks in a receive
|
||||
(<tt>MPI_Recv</tt>, <tt>MPI_Irecv</tt>, <tt>MPI_Sendrecv</tt>, etc.) may also be <tt>MPI_ANY_SOURCE</tt>.
|
||||
</DL>
|
||||
<DL>
|
||||
<DT><B>MPI_ERR_TAG </B> <DD> Invalid tag argument. Tags must be non-negative; tags
|
||||
in a receive (<tt>MPI_Recv</tt>, <tt>MPI_Irecv</tt>, <tt>MPI_Sendrecv</tt>, etc.) may
|
||||
also be <tt>MPI_ANY_TAG</tt>. The largest tag value is available through the
|
||||
the attribute <tt>MPI_TAG_UB</tt>.
|
||||
</DL>
|
||||
<DL>
|
||||
<DT><B>MPI_ERR_TYPE </B> <DD> Invalid datatype argument. Additionally, this error can
|
||||
occur if an uncommitted MPI_Datatype (see <tt>MPI_Type_commit</tt>) is used
|
||||
in a communication call.
|
||||
</DL>
|
||||
<DL>
|
||||
<DT><B>MPI_ERR_OTHER </B> <DD> Other error; use <tt>MPI_Error_string</tt> to get more information
|
||||
about this error code.
|
||||
</DL>
|
||||
<P>
|
||||
</BODY></HTML>
|
||||
@@ -0,0 +1 @@
|
||||
<meta http-equiv="refresh" content="0; url=MPIX_Send_enqueue.html">
|
||||
@@ -0,0 +1,80 @@
|
||||
<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML3.2 EN">
|
||||
<HTML>
|
||||
<HEAD>
|
||||
<META NAME="GENERATOR" CONTENT="DOCTEXT">
|
||||
<TITLE>MPIX_Session_create_errhandler_x</TITLE>
|
||||
</HEAD>
|
||||
<BODY BGCOLOR="FFFFFF">
|
||||
<H1 id="MPIX_Session_create_errhandler_x">MPIX_Session_create_errhandler_x</H1>
|
||||
Creates an MPI-style session errorhandler with an extra_state
|
||||
<H2>Synopsis</H2>
|
||||
<PRE>
|
||||
</PRE>
|
||||
<PRE>
|
||||
int MPIX_Session_create_errhandler_x(MPIX_Session_errhandler_function_x *comm_errhandler_fn_x,
|
||||
MPIX_Destructor_function *destructor_fn,
|
||||
void *extra_state,
|
||||
MPI_Errhandler *errhandler)
|
||||
</PRE>
|
||||
|
||||
<P>
|
||||
<H2>Input Parameters</H2>
|
||||
<DL>
|
||||
<DT><B>comm_errhandler_fn_x </B> <DD> user defined error handling procedure with extra_state (function)
|
||||
|
||||
<DT><B>destructor_fn </B> <DD> callback when op is freed (function)
|
||||
|
||||
<DT><B>extra_state </B> <DD> extra state (None)
|
||||
</DL>
|
||||
<P>
|
||||
<H2>Output Parameters</H2>
|
||||
<DL>
|
||||
<DT><B>errhandler </B> <DD> MPI error handler (handle)
|
||||
</DL>
|
||||
<P>
|
||||
<H2>Thread and Interrupt Safety</H2>
|
||||
<P>
|
||||
This routine is thread-safe. This means that this routine may be
|
||||
safely used by multiple threads without the need for any user-provided
|
||||
thread locks. However, the routine is not interrupt safe. Typically,
|
||||
this is due to the use of memory allocation routines such as <tt>malloc
|
||||
</tt>or other non-MPICH runtime routines that are themselves not interrupt-safe.
|
||||
<P>
|
||||
<H2>Notes for Fortran</H2>
|
||||
All MPI routines in Fortran (except for <tt>MPI_WTIME</tt> and <tt>MPI_WTICK</tt>) have
|
||||
an additional argument <tt>ierr</tt> at the end of the argument list. <tt>ierr
|
||||
</tt>is an integer and has the same meaning as the return value of the routine
|
||||
in C. In Fortran, MPI routines are subroutines, and are invoked with the
|
||||
<tt>call</tt> statement.
|
||||
<P>
|
||||
All MPI objects (e.g., <tt>MPI_Datatype</tt>, <tt>MPI_Comm</tt>) are of type <tt>INTEGER
|
||||
</tt>in Fortran.
|
||||
<P>
|
||||
<H2>Errors</H2>
|
||||
<P>
|
||||
All MPI routines (except <tt>MPI_Wtime</tt> and <tt>MPI_Wtick</tt>) return an error value;
|
||||
C routines as the value of the function and Fortran routines in the last
|
||||
argument. Before the value is returned, the current MPI error handler is
|
||||
called. By default, this error handler aborts the MPI job. The error handler
|
||||
may be changed with <tt>MPI_Comm_set_errhandler</tt> (for communicators),
|
||||
<tt>MPI_File_set_errhandler</tt> (for files), and <tt>MPI_Win_set_errhandler</tt> (for
|
||||
RMA windows). The MPI-1 routine <tt>MPI_Errhandler_set</tt> may be used but
|
||||
its use is deprecated. The predefined error handler
|
||||
<tt>MPI_ERRORS_RETURN</tt> may be used to cause error values to be returned.
|
||||
Note that MPI does <em>not</em> guarantee that an MPI program can continue past
|
||||
an error; however, MPI implementations will attempt to continue whenever
|
||||
possible.
|
||||
<P>
|
||||
<DL>
|
||||
<DT><B>MPI_SUCCESS </B> <DD> No error; MPI routine completed successfully.
|
||||
</DL>
|
||||
<DL>
|
||||
<DT><B>MPI_ERR_ARG </B> <DD> Invalid argument. Some argument is invalid and is not
|
||||
identified by a specific error class (e.g., <tt>MPI_ERR_RANK</tt>).
|
||||
</DL>
|
||||
<DL>
|
||||
<DT><B>MPI_ERR_OTHER </B> <DD> Other error; use <tt>MPI_Error_string</tt> to get more information
|
||||
about this error code.
|
||||
</DL>
|
||||
<P>
|
||||
</BODY></HTML>
|
||||
@@ -0,0 +1,64 @@
|
||||
<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML3.2 EN">
|
||||
<HTML>
|
||||
<HEAD>
|
||||
<META NAME="GENERATOR" CONTENT="DOCTEXT">
|
||||
<TITLE>MPIX_Start_progress_thread</TITLE>
|
||||
</HEAD>
|
||||
<BODY BGCOLOR="FFFFFF">
|
||||
<H1 id="MPIX_Start_progress_thread">MPIX_Start_progress_thread</H1>
|
||||
Start a progress thread that will poll progress on the given stream
|
||||
<H2>Synopsis</H2>
|
||||
<PRE>
|
||||
</PRE>
|
||||
<PRE>
|
||||
int MPIX_Start_progress_thread(MPIX_Stream stream)
|
||||
</PRE>
|
||||
|
||||
<P>
|
||||
<H2>Input Parameters</H2>
|
||||
<DL>
|
||||
<DT><B>stream </B> <DD> stream object (handle)
|
||||
</DL>
|
||||
<P>
|
||||
<H2>Thread and Interrupt Safety</H2>
|
||||
<P>
|
||||
This routine is thread-safe. This means that this routine may be
|
||||
safely used by multiple threads without the need for any user-provided
|
||||
thread locks. However, the routine is not interrupt safe. Typically,
|
||||
this is due to the use of memory allocation routines such as <tt>malloc
|
||||
</tt>or other non-MPICH runtime routines that are themselves not interrupt-safe.
|
||||
<P>
|
||||
<H2>Notes for Fortran</H2>
|
||||
All MPI routines in Fortran (except for <tt>MPI_WTIME</tt> and <tt>MPI_WTICK</tt>) have
|
||||
an additional argument <tt>ierr</tt> at the end of the argument list. <tt>ierr
|
||||
</tt>is an integer and has the same meaning as the return value of the routine
|
||||
in C. In Fortran, MPI routines are subroutines, and are invoked with the
|
||||
<tt>call</tt> statement.
|
||||
<P>
|
||||
All MPI objects (e.g., <tt>MPI_Datatype</tt>, <tt>MPI_Comm</tt>) are of type <tt>INTEGER
|
||||
</tt>in Fortran.
|
||||
<P>
|
||||
<H2>Errors</H2>
|
||||
<P>
|
||||
All MPI routines (except <tt>MPI_Wtime</tt> and <tt>MPI_Wtick</tt>) return an error value;
|
||||
C routines as the value of the function and Fortran routines in the last
|
||||
argument. Before the value is returned, the current MPI error handler is
|
||||
called. By default, this error handler aborts the MPI job. The error handler
|
||||
may be changed with <tt>MPI_Comm_set_errhandler</tt> (for communicators),
|
||||
<tt>MPI_File_set_errhandler</tt> (for files), and <tt>MPI_Win_set_errhandler</tt> (for
|
||||
RMA windows). The MPI-1 routine <tt>MPI_Errhandler_set</tt> may be used but
|
||||
its use is deprecated. The predefined error handler
|
||||
<tt>MPI_ERRORS_RETURN</tt> may be used to cause error values to be returned.
|
||||
Note that MPI does <em>not</em> guarantee that an MPI program can continue past
|
||||
an error; however, MPI implementations will attempt to continue whenever
|
||||
possible.
|
||||
<P>
|
||||
<DL>
|
||||
<DT><B>MPI_SUCCESS </B> <DD> No error; MPI routine completed successfully.
|
||||
</DL>
|
||||
<DL>
|
||||
<DT><B>MPI_ERR_OTHER </B> <DD> Other error; use <tt>MPI_Error_string</tt> to get more information
|
||||
about this error code.
|
||||
</DL>
|
||||
<P>
|
||||
</BODY></HTML>
|
||||
@@ -0,0 +1,64 @@
|
||||
<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML3.2 EN">
|
||||
<HTML>
|
||||
<HEAD>
|
||||
<META NAME="GENERATOR" CONTENT="DOCTEXT">
|
||||
<TITLE>MPIX_Stop_progress_thread</TITLE>
|
||||
</HEAD>
|
||||
<BODY BGCOLOR="FFFFFF">
|
||||
<H1 id="MPIX_Stop_progress_thread">MPIX_Stop_progress_thread</H1>
|
||||
Stop the progress thread that polls progress on the given stream
|
||||
<H2>Synopsis</H2>
|
||||
<PRE>
|
||||
</PRE>
|
||||
<PRE>
|
||||
int MPIX_Stop_progress_thread(MPIX_Stream stream)
|
||||
</PRE>
|
||||
|
||||
<P>
|
||||
<H2>Input Parameters</H2>
|
||||
<DL>
|
||||
<DT><B>stream </B> <DD> stream object (handle)
|
||||
</DL>
|
||||
<P>
|
||||
<H2>Thread and Interrupt Safety</H2>
|
||||
<P>
|
||||
This routine is thread-safe. This means that this routine may be
|
||||
safely used by multiple threads without the need for any user-provided
|
||||
thread locks. However, the routine is not interrupt safe. Typically,
|
||||
this is due to the use of memory allocation routines such as <tt>malloc
|
||||
</tt>or other non-MPICH runtime routines that are themselves not interrupt-safe.
|
||||
<P>
|
||||
<H2>Notes for Fortran</H2>
|
||||
All MPI routines in Fortran (except for <tt>MPI_WTIME</tt> and <tt>MPI_WTICK</tt>) have
|
||||
an additional argument <tt>ierr</tt> at the end of the argument list. <tt>ierr
|
||||
</tt>is an integer and has the same meaning as the return value of the routine
|
||||
in C. In Fortran, MPI routines are subroutines, and are invoked with the
|
||||
<tt>call</tt> statement.
|
||||
<P>
|
||||
All MPI objects (e.g., <tt>MPI_Datatype</tt>, <tt>MPI_Comm</tt>) are of type <tt>INTEGER
|
||||
</tt>in Fortran.
|
||||
<P>
|
||||
<H2>Errors</H2>
|
||||
<P>
|
||||
All MPI routines (except <tt>MPI_Wtime</tt> and <tt>MPI_Wtick</tt>) return an error value;
|
||||
C routines as the value of the function and Fortran routines in the last
|
||||
argument. Before the value is returned, the current MPI error handler is
|
||||
called. By default, this error handler aborts the MPI job. The error handler
|
||||
may be changed with <tt>MPI_Comm_set_errhandler</tt> (for communicators),
|
||||
<tt>MPI_File_set_errhandler</tt> (for files), and <tt>MPI_Win_set_errhandler</tt> (for
|
||||
RMA windows). The MPI-1 routine <tt>MPI_Errhandler_set</tt> may be used but
|
||||
its use is deprecated. The predefined error handler
|
||||
<tt>MPI_ERRORS_RETURN</tt> may be used to cause error values to be returned.
|
||||
Note that MPI does <em>not</em> guarantee that an MPI program can continue past
|
||||
an error; however, MPI implementations will attempt to continue whenever
|
||||
possible.
|
||||
<P>
|
||||
<DL>
|
||||
<DT><B>MPI_SUCCESS </B> <DD> No error; MPI routine completed successfully.
|
||||
</DL>
|
||||
<DL>
|
||||
<DT><B>MPI_ERR_OTHER </B> <DD> Other error; use <tt>MPI_Error_string</tt> to get more information
|
||||
about this error code.
|
||||
</DL>
|
||||
<P>
|
||||
</BODY></HTML>
|
||||
@@ -0,0 +1,80 @@
|
||||
<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML3.2 EN">
|
||||
<HTML>
|
||||
<HEAD>
|
||||
<META NAME="GENERATOR" CONTENT="DOCTEXT">
|
||||
<TITLE>MPIX_Stream_comm_create</TITLE>
|
||||
</HEAD>
|
||||
<BODY BGCOLOR="FFFFFF">
|
||||
<H1 id="MPIX_Stream_comm_create">MPIX_Stream_comm_create</H1>
|
||||
Create a new communicator with local stream attached
|
||||
<H2>Synopsis</H2>
|
||||
<PRE>
|
||||
</PRE>
|
||||
<PRE>
|
||||
int MPIX_Stream_comm_create(MPI_Comm comm, MPIX_Stream stream,
|
||||
MPI_Comm *newcomm)
|
||||
</PRE>
|
||||
|
||||
<P>
|
||||
<H2>Input Parameters</H2>
|
||||
<DL>
|
||||
<DT><B>comm </B> <DD> communicator (handle)
|
||||
|
||||
<DT><B>stream </B> <DD> stream object (handle)
|
||||
</DL>
|
||||
<P>
|
||||
<H2>Output Parameters</H2>
|
||||
<DL>
|
||||
<DT><B>newcomm </B> <DD> new stream-associated communicator (handle)
|
||||
</DL>
|
||||
<P>
|
||||
<H2>Thread and Interrupt Safety</H2>
|
||||
<P>
|
||||
This routine is thread-safe. This means that this routine may be
|
||||
safely used by multiple threads without the need for any user-provided
|
||||
thread locks. However, the routine is not interrupt safe. Typically,
|
||||
this is due to the use of memory allocation routines such as <tt>malloc
|
||||
</tt>or other non-MPICH runtime routines that are themselves not interrupt-safe.
|
||||
<P>
|
||||
<H2>Notes for Fortran</H2>
|
||||
All MPI routines in Fortran (except for <tt>MPI_WTIME</tt> and <tt>MPI_WTICK</tt>) have
|
||||
an additional argument <tt>ierr</tt> at the end of the argument list. <tt>ierr
|
||||
</tt>is an integer and has the same meaning as the return value of the routine
|
||||
in C. In Fortran, MPI routines are subroutines, and are invoked with the
|
||||
<tt>call</tt> statement.
|
||||
<P>
|
||||
All MPI objects (e.g., <tt>MPI_Datatype</tt>, <tt>MPI_Comm</tt>) are of type <tt>INTEGER
|
||||
</tt>in Fortran.
|
||||
<P>
|
||||
<H2>Errors</H2>
|
||||
<P>
|
||||
All MPI routines (except <tt>MPI_Wtime</tt> and <tt>MPI_Wtick</tt>) return an error value;
|
||||
C routines as the value of the function and Fortran routines in the last
|
||||
argument. Before the value is returned, the current MPI error handler is
|
||||
called. By default, this error handler aborts the MPI job. The error handler
|
||||
may be changed with <tt>MPI_Comm_set_errhandler</tt> (for communicators),
|
||||
<tt>MPI_File_set_errhandler</tt> (for files), and <tt>MPI_Win_set_errhandler</tt> (for
|
||||
RMA windows). The MPI-1 routine <tt>MPI_Errhandler_set</tt> may be used but
|
||||
its use is deprecated. The predefined error handler
|
||||
<tt>MPI_ERRORS_RETURN</tt> may be used to cause error values to be returned.
|
||||
Note that MPI does <em>not</em> guarantee that an MPI program can continue past
|
||||
an error; however, MPI implementations will attempt to continue whenever
|
||||
possible.
|
||||
<P>
|
||||
<DL>
|
||||
<DT><B>MPI_SUCCESS </B> <DD> No error; MPI routine completed successfully.
|
||||
</DL>
|
||||
<DL>
|
||||
<DT><B>MPI_ERR_ARG </B> <DD> Invalid argument. Some argument is invalid and is not
|
||||
identified by a specific error class (e.g., <tt>MPI_ERR_RANK</tt>).
|
||||
</DL>
|
||||
<DL>
|
||||
<DT><B>MPI_ERR_COMM </B> <DD> Invalid communicator. A common error is to use a null
|
||||
communicator in a call (not even allowed in <tt>MPI_Comm_rank</tt>).
|
||||
</DL>
|
||||
<DL>
|
||||
<DT><B>MPI_ERR_OTHER </B> <DD> Other error; use <tt>MPI_Error_string</tt> to get more information
|
||||
about this error code.
|
||||
</DL>
|
||||
<P>
|
||||
</BODY></HTML>
|
||||
@@ -0,0 +1,87 @@
|
||||
<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML3.2 EN">
|
||||
<HTML>
|
||||
<HEAD>
|
||||
<META NAME="GENERATOR" CONTENT="DOCTEXT">
|
||||
<TITLE>MPIX_Stream_comm_create_multiplex</TITLE>
|
||||
</HEAD>
|
||||
<BODY BGCOLOR="FFFFFF">
|
||||
<H1 id="MPIX_Stream_comm_create_multiplex">MPIX_Stream_comm_create_multiplex</H1>
|
||||
Create a new communicator with multiple local streams attached
|
||||
<H2>Synopsis</H2>
|
||||
<PRE>
|
||||
</PRE>
|
||||
<PRE>
|
||||
int MPIX_Stream_comm_create_multiplex(MPI_Comm comm, int count,
|
||||
MPIX_Stream array_of_streams[],
|
||||
MPI_Comm *newcomm)
|
||||
</PRE>
|
||||
|
||||
<P>
|
||||
<H2>Input Parameters</H2>
|
||||
<DL>
|
||||
<DT><B>comm </B> <DD> communicator (handle)
|
||||
|
||||
<DT><B>count </B> <DD> list length (non-negative integer)
|
||||
|
||||
<DT><B>array_of_streams </B> <DD> stream object array (handle)
|
||||
</DL>
|
||||
<P>
|
||||
<H2>Output Parameters</H2>
|
||||
<DL>
|
||||
<DT><B>newcomm </B> <DD> new stream-associated communicator (handle)
|
||||
</DL>
|
||||
<P>
|
||||
<H2>Thread and Interrupt Safety</H2>
|
||||
<P>
|
||||
This routine is thread-safe. This means that this routine may be
|
||||
safely used by multiple threads without the need for any user-provided
|
||||
thread locks. However, the routine is not interrupt safe. Typically,
|
||||
this is due to the use of memory allocation routines such as <tt>malloc
|
||||
</tt>or other non-MPICH runtime routines that are themselves not interrupt-safe.
|
||||
<P>
|
||||
<H2>Notes for Fortran</H2>
|
||||
All MPI routines in Fortran (except for <tt>MPI_WTIME</tt> and <tt>MPI_WTICK</tt>) have
|
||||
an additional argument <tt>ierr</tt> at the end of the argument list. <tt>ierr
|
||||
</tt>is an integer and has the same meaning as the return value of the routine
|
||||
in C. In Fortran, MPI routines are subroutines, and are invoked with the
|
||||
<tt>call</tt> statement.
|
||||
<P>
|
||||
All MPI objects (e.g., <tt>MPI_Datatype</tt>, <tt>MPI_Comm</tt>) are of type <tt>INTEGER
|
||||
</tt>in Fortran.
|
||||
<P>
|
||||
<H2>Errors</H2>
|
||||
<P>
|
||||
All MPI routines (except <tt>MPI_Wtime</tt> and <tt>MPI_Wtick</tt>) return an error value;
|
||||
C routines as the value of the function and Fortran routines in the last
|
||||
argument. Before the value is returned, the current MPI error handler is
|
||||
called. By default, this error handler aborts the MPI job. The error handler
|
||||
may be changed with <tt>MPI_Comm_set_errhandler</tt> (for communicators),
|
||||
<tt>MPI_File_set_errhandler</tt> (for files), and <tt>MPI_Win_set_errhandler</tt> (for
|
||||
RMA windows). The MPI-1 routine <tt>MPI_Errhandler_set</tt> may be used but
|
||||
its use is deprecated. The predefined error handler
|
||||
<tt>MPI_ERRORS_RETURN</tt> may be used to cause error values to be returned.
|
||||
Note that MPI does <em>not</em> guarantee that an MPI program can continue past
|
||||
an error; however, MPI implementations will attempt to continue whenever
|
||||
possible.
|
||||
<P>
|
||||
<DL>
|
||||
<DT><B>MPI_SUCCESS </B> <DD> No error; MPI routine completed successfully.
|
||||
</DL>
|
||||
<DL>
|
||||
<DT><B>MPI_ERR_ARG </B> <DD> Invalid argument. Some argument is invalid and is not
|
||||
identified by a specific error class (e.g., <tt>MPI_ERR_RANK</tt>).
|
||||
</DL>
|
||||
<DL>
|
||||
<DT><B>MPI_ERR_COMM </B> <DD> Invalid communicator. A common error is to use a null
|
||||
communicator in a call (not even allowed in <tt>MPI_Comm_rank</tt>).
|
||||
</DL>
|
||||
<DL>
|
||||
<DT><B>MPI_ERR_COUNT </B> <DD> Invalid count argument. Count arguments must be
|
||||
non-negative; a count of zero is often valid.
|
||||
</DL>
|
||||
<DL>
|
||||
<DT><B>MPI_ERR_OTHER </B> <DD> Other error; use <tt>MPI_Error_string</tt> to get more information
|
||||
about this error code.
|
||||
</DL>
|
||||
<P>
|
||||
</BODY></HTML>
|
||||
@@ -0,0 +1,76 @@
|
||||
<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML3.2 EN">
|
||||
<HTML>
|
||||
<HEAD>
|
||||
<META NAME="GENERATOR" CONTENT="DOCTEXT">
|
||||
<TITLE>MPIX_Stream_create</TITLE>
|
||||
</HEAD>
|
||||
<BODY BGCOLOR="FFFFFF">
|
||||
<H1 id="MPIX_Stream_create">MPIX_Stream_create</H1>
|
||||
Create a new stream object
|
||||
<H2>Synopsis</H2>
|
||||
<PRE>
|
||||
</PRE>
|
||||
<PRE>
|
||||
int MPIX_Stream_create(MPI_Info info, MPIX_Stream *stream)
|
||||
</PRE>
|
||||
|
||||
<P>
|
||||
<H2>Input Parameters</H2>
|
||||
<DL>
|
||||
<DT><B>info </B> <DD> info argument (handle)
|
||||
</DL>
|
||||
<P>
|
||||
<H2>Output Parameters</H2>
|
||||
<DL>
|
||||
<DT><B>stream </B> <DD> stream object created (handle)
|
||||
</DL>
|
||||
<P>
|
||||
<H2>Thread and Interrupt Safety</H2>
|
||||
<P>
|
||||
This routine is thread-safe. This means that this routine may be
|
||||
safely used by multiple threads without the need for any user-provided
|
||||
thread locks. However, the routine is not interrupt safe. Typically,
|
||||
this is due to the use of memory allocation routines such as <tt>malloc
|
||||
</tt>or other non-MPICH runtime routines that are themselves not interrupt-safe.
|
||||
<P>
|
||||
<H2>Notes for Fortran</H2>
|
||||
All MPI routines in Fortran (except for <tt>MPI_WTIME</tt> and <tt>MPI_WTICK</tt>) have
|
||||
an additional argument <tt>ierr</tt> at the end of the argument list. <tt>ierr
|
||||
</tt>is an integer and has the same meaning as the return value of the routine
|
||||
in C. In Fortran, MPI routines are subroutines, and are invoked with the
|
||||
<tt>call</tt> statement.
|
||||
<P>
|
||||
All MPI objects (e.g., <tt>MPI_Datatype</tt>, <tt>MPI_Comm</tt>) are of type <tt>INTEGER
|
||||
</tt>in Fortran.
|
||||
<P>
|
||||
<H2>Errors</H2>
|
||||
<P>
|
||||
All MPI routines (except <tt>MPI_Wtime</tt> and <tt>MPI_Wtick</tt>) return an error value;
|
||||
C routines as the value of the function and Fortran routines in the last
|
||||
argument. Before the value is returned, the current MPI error handler is
|
||||
called. By default, this error handler aborts the MPI job. The error handler
|
||||
may be changed with <tt>MPI_Comm_set_errhandler</tt> (for communicators),
|
||||
<tt>MPI_File_set_errhandler</tt> (for files), and <tt>MPI_Win_set_errhandler</tt> (for
|
||||
RMA windows). The MPI-1 routine <tt>MPI_Errhandler_set</tt> may be used but
|
||||
its use is deprecated. The predefined error handler
|
||||
<tt>MPI_ERRORS_RETURN</tt> may be used to cause error values to be returned.
|
||||
Note that MPI does <em>not</em> guarantee that an MPI program can continue past
|
||||
an error; however, MPI implementations will attempt to continue whenever
|
||||
possible.
|
||||
<P>
|
||||
<DL>
|
||||
<DT><B>MPI_SUCCESS </B> <DD> No error; MPI routine completed successfully.
|
||||
</DL>
|
||||
<DL>
|
||||
<DT><B>MPI_ERR_ARG </B> <DD> Invalid argument. Some argument is invalid and is not
|
||||
identified by a specific error class (e.g., <tt>MPI_ERR_RANK</tt>).
|
||||
</DL>
|
||||
<DL>
|
||||
<DT><B>MPI_ERR_INFO </B> <DD> Invalid Info
|
||||
</DL>
|
||||
<DL>
|
||||
<DT><B>MPI_ERR_OTHER </B> <DD> Other error; use <tt>MPI_Error_string</tt> to get more information
|
||||
about this error code.
|
||||
</DL>
|
||||
<P>
|
||||
</BODY></HTML>
|
||||
64
macx64/mpi/mpich/share/doc/mpich/www3/MPIX_Stream_free.html
Normal file
64
macx64/mpi/mpich/share/doc/mpich/www3/MPIX_Stream_free.html
Normal file
@@ -0,0 +1,64 @@
|
||||
<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML3.2 EN">
|
||||
<HTML>
|
||||
<HEAD>
|
||||
<META NAME="GENERATOR" CONTENT="DOCTEXT">
|
||||
<TITLE>MPIX_Stream_free</TITLE>
|
||||
</HEAD>
|
||||
<BODY BGCOLOR="FFFFFF">
|
||||
<H1 id="MPIX_Stream_free">MPIX_Stream_free</H1>
|
||||
Free a stream object
|
||||
<H2>Synopsis</H2>
|
||||
<PRE>
|
||||
</PRE>
|
||||
<PRE>
|
||||
int MPIX_Stream_free(MPIX_Stream *stream)
|
||||
</PRE>
|
||||
|
||||
<P>
|
||||
<H2>Input/Output Parameters</H2>
|
||||
<DL>
|
||||
<DT><B>stream </B> <DD> stream object (handle)
|
||||
</DL>
|
||||
<P>
|
||||
<H2>Thread and Interrupt Safety</H2>
|
||||
<P>
|
||||
This routine is thread-safe. This means that this routine may be
|
||||
safely used by multiple threads without the need for any user-provided
|
||||
thread locks. However, the routine is not interrupt safe. Typically,
|
||||
this is due to the use of memory allocation routines such as <tt>malloc
|
||||
</tt>or other non-MPICH runtime routines that are themselves not interrupt-safe.
|
||||
<P>
|
||||
<H2>Notes for Fortran</H2>
|
||||
All MPI routines in Fortran (except for <tt>MPI_WTIME</tt> and <tt>MPI_WTICK</tt>) have
|
||||
an additional argument <tt>ierr</tt> at the end of the argument list. <tt>ierr
|
||||
</tt>is an integer and has the same meaning as the return value of the routine
|
||||
in C. In Fortran, MPI routines are subroutines, and are invoked with the
|
||||
<tt>call</tt> statement.
|
||||
<P>
|
||||
All MPI objects (e.g., <tt>MPI_Datatype</tt>, <tt>MPI_Comm</tt>) are of type <tt>INTEGER
|
||||
</tt>in Fortran.
|
||||
<P>
|
||||
<H2>Errors</H2>
|
||||
<P>
|
||||
All MPI routines (except <tt>MPI_Wtime</tt> and <tt>MPI_Wtick</tt>) return an error value;
|
||||
C routines as the value of the function and Fortran routines in the last
|
||||
argument. Before the value is returned, the current MPI error handler is
|
||||
called. By default, this error handler aborts the MPI job. The error handler
|
||||
may be changed with <tt>MPI_Comm_set_errhandler</tt> (for communicators),
|
||||
<tt>MPI_File_set_errhandler</tt> (for files), and <tt>MPI_Win_set_errhandler</tt> (for
|
||||
RMA windows). The MPI-1 routine <tt>MPI_Errhandler_set</tt> may be used but
|
||||
its use is deprecated. The predefined error handler
|
||||
<tt>MPI_ERRORS_RETURN</tt> may be used to cause error values to be returned.
|
||||
Note that MPI does <em>not</em> guarantee that an MPI program can continue past
|
||||
an error; however, MPI implementations will attempt to continue whenever
|
||||
possible.
|
||||
<P>
|
||||
<DL>
|
||||
<DT><B>MPI_SUCCESS </B> <DD> No error; MPI routine completed successfully.
|
||||
</DL>
|
||||
<DL>
|
||||
<DT><B>MPI_ERR_OTHER </B> <DD> Other error; use <tt>MPI_Error_string</tt> to get more information
|
||||
about this error code.
|
||||
</DL>
|
||||
<P>
|
||||
</BODY></HTML>
|
||||
124
macx64/mpi/mpich/share/doc/mpich/www3/MPIX_Stream_irecv.html
Normal file
124
macx64/mpi/mpich/share/doc/mpich/www3/MPIX_Stream_irecv.html
Normal file
@@ -0,0 +1,124 @@
|
||||
<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML3.2 EN">
|
||||
<HTML>
|
||||
<HEAD>
|
||||
<META NAME="GENERATOR" CONTENT="DOCTEXT">
|
||||
<TITLE>MPIX_Stream_irecv</TITLE>
|
||||
</HEAD>
|
||||
<BODY BGCOLOR="FFFFFF">
|
||||
<H1 id="MPIX_Stream_irecv">MPIX_Stream_irecv</H1>
|
||||
Start a nonblocking receive from a specific source stream to a specific local stream
|
||||
<H2>Synopsis</H2>
|
||||
<PRE>
|
||||
</PRE>
|
||||
<PRE>
|
||||
int MPIX_Stream_irecv(void *buf, int count, MPI_Datatype datatype, int source,
|
||||
int tag, MPI_Comm comm, int source_stream_index,
|
||||
int dest_stream_index, MPI_Request *request)
|
||||
</PRE>
|
||||
|
||||
<PRE>
|
||||
int MPIX_Stream_irecv_c(void *buf, MPI_Count count, MPI_Datatype datatype,
|
||||
int source, int tag, MPI_Comm comm,
|
||||
int source_stream_index, int dest_stream_index,
|
||||
MPI_Request *request)
|
||||
</PRE>
|
||||
|
||||
<P>
|
||||
<H2>Input Parameters</H2>
|
||||
<DL>
|
||||
<DT><B>count </B> <DD> number of elements in receive buffer (non-negative integer)
|
||||
|
||||
<DT><B>datatype </B> <DD> datatype of each receive buffer element (handle)
|
||||
|
||||
<DT><B>source </B> <DD> rank of source or MPI_ANY_SOURCE (integer)
|
||||
|
||||
<DT><B>tag </B> <DD> message tag or MPI_ANY_TAG (integer)
|
||||
|
||||
<DT><B>comm </B> <DD> communicator (handle)
|
||||
|
||||
<DT><B>source_stream_index </B> <DD> source_stream_index (integer)
|
||||
|
||||
<DT><B>dest_stream_index </B> <DD> dest_stream_index (integer)
|
||||
</DL>
|
||||
<P>
|
||||
<H2>Output Parameters</H2>
|
||||
<DL>
|
||||
<DT><B>buf </B> <DD> initial address of receive buffer (choice)
|
||||
|
||||
<DT><B>request </B> <DD> communication request (handle)
|
||||
</DL>
|
||||
<P>
|
||||
<H2>Thread and Interrupt Safety</H2>
|
||||
<P>
|
||||
This routine is thread-safe. This means that this routine may be
|
||||
safely used by multiple threads without the need for any user-provided
|
||||
thread locks. However, the routine is not interrupt safe. Typically,
|
||||
this is due to the use of memory allocation routines such as <tt>malloc
|
||||
</tt>or other non-MPICH runtime routines that are themselves not interrupt-safe.
|
||||
<P>
|
||||
<H2>Notes for Fortran</H2>
|
||||
All MPI routines in Fortran (except for <tt>MPI_WTIME</tt> and <tt>MPI_WTICK</tt>) have
|
||||
an additional argument <tt>ierr</tt> at the end of the argument list. <tt>ierr
|
||||
</tt>is an integer and has the same meaning as the return value of the routine
|
||||
in C. In Fortran, MPI routines are subroutines, and are invoked with the
|
||||
<tt>call</tt> statement.
|
||||
<P>
|
||||
All MPI objects (e.g., <tt>MPI_Datatype</tt>, <tt>MPI_Comm</tt>) are of type <tt>INTEGER
|
||||
</tt>in Fortran.
|
||||
<P>
|
||||
<H2>Errors</H2>
|
||||
<P>
|
||||
All MPI routines (except <tt>MPI_Wtime</tt> and <tt>MPI_Wtick</tt>) return an error value;
|
||||
C routines as the value of the function and Fortran routines in the last
|
||||
argument. Before the value is returned, the current MPI error handler is
|
||||
called. By default, this error handler aborts the MPI job. The error handler
|
||||
may be changed with <tt>MPI_Comm_set_errhandler</tt> (for communicators),
|
||||
<tt>MPI_File_set_errhandler</tt> (for files), and <tt>MPI_Win_set_errhandler</tt> (for
|
||||
RMA windows). The MPI-1 routine <tt>MPI_Errhandler_set</tt> may be used but
|
||||
its use is deprecated. The predefined error handler
|
||||
<tt>MPI_ERRORS_RETURN</tt> may be used to cause error values to be returned.
|
||||
Note that MPI does <em>not</em> guarantee that an MPI program can continue past
|
||||
an error; however, MPI implementations will attempt to continue whenever
|
||||
possible.
|
||||
<P>
|
||||
<DL>
|
||||
<DT><B>MPI_SUCCESS </B> <DD> No error; MPI routine completed successfully.
|
||||
</DL>
|
||||
<DL>
|
||||
<DT><B>MPI_ERR_ARG </B> <DD> Invalid argument. Some argument is invalid and is not
|
||||
identified by a specific error class (e.g., <tt>MPI_ERR_RANK</tt>).
|
||||
</DL>
|
||||
<DL>
|
||||
<DT><B>MPI_ERR_BUFFER </B> <DD> Invalid buffer pointer. Usually a null buffer where
|
||||
one is not valid.
|
||||
</DL>
|
||||
<DL>
|
||||
<DT><B>MPI_ERR_COMM </B> <DD> Invalid communicator. A common error is to use a null
|
||||
communicator in a call (not even allowed in <tt>MPI_Comm_rank</tt>).
|
||||
</DL>
|
||||
<DL>
|
||||
<DT><B>MPI_ERR_COUNT </B> <DD> Invalid count argument. Count arguments must be
|
||||
non-negative; a count of zero is often valid.
|
||||
</DL>
|
||||
<DL>
|
||||
<DT><B>MPI_ERR_RANK </B> <DD> Invalid source or destination rank. Ranks must be between
|
||||
zero and the size of the communicator minus one; ranks in a receive
|
||||
(<tt>MPI_Recv</tt>, <tt>MPI_Irecv</tt>, <tt>MPI_Sendrecv</tt>, etc.) may also be <tt>MPI_ANY_SOURCE</tt>.
|
||||
</DL>
|
||||
<DL>
|
||||
<DT><B>MPI_ERR_TAG </B> <DD> Invalid tag argument. Tags must be non-negative; tags
|
||||
in a receive (<tt>MPI_Recv</tt>, <tt>MPI_Irecv</tt>, <tt>MPI_Sendrecv</tt>, etc.) may
|
||||
also be <tt>MPI_ANY_TAG</tt>. The largest tag value is available through the
|
||||
the attribute <tt>MPI_TAG_UB</tt>.
|
||||
</DL>
|
||||
<DL>
|
||||
<DT><B>MPI_ERR_TYPE </B> <DD> Invalid datatype argument. Additionally, this error can
|
||||
occur if an uncommitted MPI_Datatype (see <tt>MPI_Type_commit</tt>) is used
|
||||
in a communication call.
|
||||
</DL>
|
||||
<DL>
|
||||
<DT><B>MPI_ERR_OTHER </B> <DD> Other error; use <tt>MPI_Error_string</tt> to get more information
|
||||
about this error code.
|
||||
</DL>
|
||||
<P>
|
||||
</BODY></HTML>
|
||||
@@ -0,0 +1 @@
|
||||
<meta http-equiv="refresh" content="0; url=MPIX_Stream_irecv.html">
|
||||
124
macx64/mpi/mpich/share/doc/mpich/www3/MPIX_Stream_isend.html
Normal file
124
macx64/mpi/mpich/share/doc/mpich/www3/MPIX_Stream_isend.html
Normal file
@@ -0,0 +1,124 @@
|
||||
<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML3.2 EN">
|
||||
<HTML>
|
||||
<HEAD>
|
||||
<META NAME="GENERATOR" CONTENT="DOCTEXT">
|
||||
<TITLE>MPIX_Stream_isend</TITLE>
|
||||
</HEAD>
|
||||
<BODY BGCOLOR="FFFFFF">
|
||||
<H1 id="MPIX_Stream_isend">MPIX_Stream_isend</H1>
|
||||
Start a nonblocking send from a specific local stream to a specific remote stream
|
||||
<H2>Synopsis</H2>
|
||||
<PRE>
|
||||
</PRE>
|
||||
<PRE>
|
||||
int MPIX_Stream_isend(const void *buf, int count, MPI_Datatype datatype,
|
||||
int dest, int tag, MPI_Comm comm, int source_stream_index,
|
||||
int dest_stream_index, MPI_Request *request)
|
||||
</PRE>
|
||||
|
||||
<PRE>
|
||||
int MPIX_Stream_isend_c(const void *buf, MPI_Count count, MPI_Datatype datatype,
|
||||
int dest, int tag, MPI_Comm comm,
|
||||
int source_stream_index, int dest_stream_index,
|
||||
MPI_Request *request)
|
||||
</PRE>
|
||||
|
||||
<P>
|
||||
<H2>Input Parameters</H2>
|
||||
<DL>
|
||||
<DT><B>buf </B> <DD> initial address of send buffer (choice)
|
||||
|
||||
<DT><B>count </B> <DD> number of elements in send buffer (non-negative integer)
|
||||
|
||||
<DT><B>datatype </B> <DD> datatype of each send buffer element (handle)
|
||||
|
||||
<DT><B>dest </B> <DD> rank of destination (integer)
|
||||
|
||||
<DT><B>tag </B> <DD> message tag (integer)
|
||||
|
||||
<DT><B>comm </B> <DD> communicator (handle)
|
||||
|
||||
<DT><B>source_stream_index </B> <DD> source_stream_index (integer)
|
||||
|
||||
<DT><B>dest_stream_index </B> <DD> dest_stream_index (integer)
|
||||
</DL>
|
||||
<P>
|
||||
<H2>Output Parameters</H2>
|
||||
<DL>
|
||||
<DT><B>request </B> <DD> communication request (handle)
|
||||
</DL>
|
||||
<P>
|
||||
<H2>Thread and Interrupt Safety</H2>
|
||||
<P>
|
||||
This routine is thread-safe. This means that this routine may be
|
||||
safely used by multiple threads without the need for any user-provided
|
||||
thread locks. However, the routine is not interrupt safe. Typically,
|
||||
this is due to the use of memory allocation routines such as <tt>malloc
|
||||
</tt>or other non-MPICH runtime routines that are themselves not interrupt-safe.
|
||||
<P>
|
||||
<H2>Notes for Fortran</H2>
|
||||
All MPI routines in Fortran (except for <tt>MPI_WTIME</tt> and <tt>MPI_WTICK</tt>) have
|
||||
an additional argument <tt>ierr</tt> at the end of the argument list. <tt>ierr
|
||||
</tt>is an integer and has the same meaning as the return value of the routine
|
||||
in C. In Fortran, MPI routines are subroutines, and are invoked with the
|
||||
<tt>call</tt> statement.
|
||||
<P>
|
||||
All MPI objects (e.g., <tt>MPI_Datatype</tt>, <tt>MPI_Comm</tt>) are of type <tt>INTEGER
|
||||
</tt>in Fortran.
|
||||
<P>
|
||||
<H2>Errors</H2>
|
||||
<P>
|
||||
All MPI routines (except <tt>MPI_Wtime</tt> and <tt>MPI_Wtick</tt>) return an error value;
|
||||
C routines as the value of the function and Fortran routines in the last
|
||||
argument. Before the value is returned, the current MPI error handler is
|
||||
called. By default, this error handler aborts the MPI job. The error handler
|
||||
may be changed with <tt>MPI_Comm_set_errhandler</tt> (for communicators),
|
||||
<tt>MPI_File_set_errhandler</tt> (for files), and <tt>MPI_Win_set_errhandler</tt> (for
|
||||
RMA windows). The MPI-1 routine <tt>MPI_Errhandler_set</tt> may be used but
|
||||
its use is deprecated. The predefined error handler
|
||||
<tt>MPI_ERRORS_RETURN</tt> may be used to cause error values to be returned.
|
||||
Note that MPI does <em>not</em> guarantee that an MPI program can continue past
|
||||
an error; however, MPI implementations will attempt to continue whenever
|
||||
possible.
|
||||
<P>
|
||||
<DL>
|
||||
<DT><B>MPI_SUCCESS </B> <DD> No error; MPI routine completed successfully.
|
||||
</DL>
|
||||
<DL>
|
||||
<DT><B>MPI_ERR_ARG </B> <DD> Invalid argument. Some argument is invalid and is not
|
||||
identified by a specific error class (e.g., <tt>MPI_ERR_RANK</tt>).
|
||||
</DL>
|
||||
<DL>
|
||||
<DT><B>MPI_ERR_BUFFER </B> <DD> Invalid buffer pointer. Usually a null buffer where
|
||||
one is not valid.
|
||||
</DL>
|
||||
<DL>
|
||||
<DT><B>MPI_ERR_COMM </B> <DD> Invalid communicator. A common error is to use a null
|
||||
communicator in a call (not even allowed in <tt>MPI_Comm_rank</tt>).
|
||||
</DL>
|
||||
<DL>
|
||||
<DT><B>MPI_ERR_COUNT </B> <DD> Invalid count argument. Count arguments must be
|
||||
non-negative; a count of zero is often valid.
|
||||
</DL>
|
||||
<DL>
|
||||
<DT><B>MPI_ERR_RANK </B> <DD> Invalid source or destination rank. Ranks must be between
|
||||
zero and the size of the communicator minus one; ranks in a receive
|
||||
(<tt>MPI_Recv</tt>, <tt>MPI_Irecv</tt>, <tt>MPI_Sendrecv</tt>, etc.) may also be <tt>MPI_ANY_SOURCE</tt>.
|
||||
</DL>
|
||||
<DL>
|
||||
<DT><B>MPI_ERR_TAG </B> <DD> Invalid tag argument. Tags must be non-negative; tags
|
||||
in a receive (<tt>MPI_Recv</tt>, <tt>MPI_Irecv</tt>, <tt>MPI_Sendrecv</tt>, etc.) may
|
||||
also be <tt>MPI_ANY_TAG</tt>. The largest tag value is available through the
|
||||
the attribute <tt>MPI_TAG_UB</tt>.
|
||||
</DL>
|
||||
<DL>
|
||||
<DT><B>MPI_ERR_TYPE </B> <DD> Invalid datatype argument. Additionally, this error can
|
||||
occur if an uncommitted MPI_Datatype (see <tt>MPI_Type_commit</tt>) is used
|
||||
in a communication call.
|
||||
</DL>
|
||||
<DL>
|
||||
<DT><B>MPI_ERR_OTHER </B> <DD> Other error; use <tt>MPI_Error_string</tt> to get more information
|
||||
about this error code.
|
||||
</DL>
|
||||
<P>
|
||||
</BODY></HTML>
|
||||
@@ -0,0 +1 @@
|
||||
<meta http-equiv="refresh" content="0; url=MPIX_Stream_isend.html">
|
||||
@@ -0,0 +1,64 @@
|
||||
<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML3.2 EN">
|
||||
<HTML>
|
||||
<HEAD>
|
||||
<META NAME="GENERATOR" CONTENT="DOCTEXT">
|
||||
<TITLE>MPIX_Stream_progress</TITLE>
|
||||
</HEAD>
|
||||
<BODY BGCOLOR="FFFFFF">
|
||||
<H1 id="MPIX_Stream_progress">MPIX_Stream_progress</H1>
|
||||
Invoke progress on the given stream
|
||||
<H2>Synopsis</H2>
|
||||
<PRE>
|
||||
</PRE>
|
||||
<PRE>
|
||||
int MPIX_Stream_progress(MPIX_Stream stream)
|
||||
</PRE>
|
||||
|
||||
<P>
|
||||
<H2>Input Parameters</H2>
|
||||
<DL>
|
||||
<DT><B>stream </B> <DD> stream object (handle)
|
||||
</DL>
|
||||
<P>
|
||||
<H2>Thread and Interrupt Safety</H2>
|
||||
<P>
|
||||
This routine is thread-safe. This means that this routine may be
|
||||
safely used by multiple threads without the need for any user-provided
|
||||
thread locks. However, the routine is not interrupt safe. Typically,
|
||||
this is due to the use of memory allocation routines such as <tt>malloc
|
||||
</tt>or other non-MPICH runtime routines that are themselves not interrupt-safe.
|
||||
<P>
|
||||
<H2>Notes for Fortran</H2>
|
||||
All MPI routines in Fortran (except for <tt>MPI_WTIME</tt> and <tt>MPI_WTICK</tt>) have
|
||||
an additional argument <tt>ierr</tt> at the end of the argument list. <tt>ierr
|
||||
</tt>is an integer and has the same meaning as the return value of the routine
|
||||
in C. In Fortran, MPI routines are subroutines, and are invoked with the
|
||||
<tt>call</tt> statement.
|
||||
<P>
|
||||
All MPI objects (e.g., <tt>MPI_Datatype</tt>, <tt>MPI_Comm</tt>) are of type <tt>INTEGER
|
||||
</tt>in Fortran.
|
||||
<P>
|
||||
<H2>Errors</H2>
|
||||
<P>
|
||||
All MPI routines (except <tt>MPI_Wtime</tt> and <tt>MPI_Wtick</tt>) return an error value;
|
||||
C routines as the value of the function and Fortran routines in the last
|
||||
argument. Before the value is returned, the current MPI error handler is
|
||||
called. By default, this error handler aborts the MPI job. The error handler
|
||||
may be changed with <tt>MPI_Comm_set_errhandler</tt> (for communicators),
|
||||
<tt>MPI_File_set_errhandler</tt> (for files), and <tt>MPI_Win_set_errhandler</tt> (for
|
||||
RMA windows). The MPI-1 routine <tt>MPI_Errhandler_set</tt> may be used but
|
||||
its use is deprecated. The predefined error handler
|
||||
<tt>MPI_ERRORS_RETURN</tt> may be used to cause error values to be returned.
|
||||
Note that MPI does <em>not</em> guarantee that an MPI program can continue past
|
||||
an error; however, MPI implementations will attempt to continue whenever
|
||||
possible.
|
||||
<P>
|
||||
<DL>
|
||||
<DT><B>MPI_SUCCESS </B> <DD> No error; MPI routine completed successfully.
|
||||
</DL>
|
||||
<DL>
|
||||
<DT><B>MPI_ERR_OTHER </B> <DD> Other error; use <tt>MPI_Error_string</tt> to get more information
|
||||
about this error code.
|
||||
</DL>
|
||||
<P>
|
||||
</BODY></HTML>
|
||||
124
macx64/mpi/mpich/share/doc/mpich/www3/MPIX_Stream_recv.html
Normal file
124
macx64/mpi/mpich/share/doc/mpich/www3/MPIX_Stream_recv.html
Normal file
@@ -0,0 +1,124 @@
|
||||
<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML3.2 EN">
|
||||
<HTML>
|
||||
<HEAD>
|
||||
<META NAME="GENERATOR" CONTENT="DOCTEXT">
|
||||
<TITLE>MPIX_Stream_recv</TITLE>
|
||||
</HEAD>
|
||||
<BODY BGCOLOR="FFFFFF">
|
||||
<H1 id="MPIX_Stream_recv">MPIX_Stream_recv</H1>
|
||||
Receive a message from a specific source stream to a specific local stream
|
||||
<H2>Synopsis</H2>
|
||||
<PRE>
|
||||
</PRE>
|
||||
<PRE>
|
||||
int MPIX_Stream_recv(void *buf, int count, MPI_Datatype datatype, int source,
|
||||
int tag, MPI_Comm comm, int source_stream_index,
|
||||
int dest_stream_index, MPI_Status *status)
|
||||
</PRE>
|
||||
|
||||
<PRE>
|
||||
int MPIX_Stream_recv_c(void *buf, MPI_Count count, MPI_Datatype datatype,
|
||||
int source, int tag, MPI_Comm comm,
|
||||
int source_stream_index, int dest_stream_index,
|
||||
MPI_Status *status)
|
||||
</PRE>
|
||||
|
||||
<P>
|
||||
<H2>Input Parameters</H2>
|
||||
<DL>
|
||||
<DT><B>count </B> <DD> number of elements in receive buffer (non-negative integer)
|
||||
|
||||
<DT><B>datatype </B> <DD> datatype of each receive buffer element (handle)
|
||||
|
||||
<DT><B>source </B> <DD> rank of source or MPI_ANY_SOURCE (integer)
|
||||
|
||||
<DT><B>tag </B> <DD> message tag or MPI_ANY_TAG (integer)
|
||||
|
||||
<DT><B>comm </B> <DD> communicator (handle)
|
||||
|
||||
<DT><B>source_stream_index </B> <DD> source_stream_index (integer)
|
||||
|
||||
<DT><B>dest_stream_index </B> <DD> dest_stream_index (integer)
|
||||
</DL>
|
||||
<P>
|
||||
<H2>Output Parameters</H2>
|
||||
<DL>
|
||||
<DT><B>buf </B> <DD> initial address of receive buffer (choice)
|
||||
|
||||
<DT><B>status </B> <DD> status object (Status)
|
||||
</DL>
|
||||
<P>
|
||||
<H2>Thread and Interrupt Safety</H2>
|
||||
<P>
|
||||
This routine is thread-safe. This means that this routine may be
|
||||
safely used by multiple threads without the need for any user-provided
|
||||
thread locks. However, the routine is not interrupt safe. Typically,
|
||||
this is due to the use of memory allocation routines such as <tt>malloc
|
||||
</tt>or other non-MPICH runtime routines that are themselves not interrupt-safe.
|
||||
<P>
|
||||
<H2>Notes for Fortran</H2>
|
||||
All MPI routines in Fortran (except for <tt>MPI_WTIME</tt> and <tt>MPI_WTICK</tt>) have
|
||||
an additional argument <tt>ierr</tt> at the end of the argument list. <tt>ierr
|
||||
</tt>is an integer and has the same meaning as the return value of the routine
|
||||
in C. In Fortran, MPI routines are subroutines, and are invoked with the
|
||||
<tt>call</tt> statement.
|
||||
<P>
|
||||
All MPI objects (e.g., <tt>MPI_Datatype</tt>, <tt>MPI_Comm</tt>) are of type <tt>INTEGER
|
||||
</tt>in Fortran.
|
||||
<P>
|
||||
<H2>Errors</H2>
|
||||
<P>
|
||||
All MPI routines (except <tt>MPI_Wtime</tt> and <tt>MPI_Wtick</tt>) return an error value;
|
||||
C routines as the value of the function and Fortran routines in the last
|
||||
argument. Before the value is returned, the current MPI error handler is
|
||||
called. By default, this error handler aborts the MPI job. The error handler
|
||||
may be changed with <tt>MPI_Comm_set_errhandler</tt> (for communicators),
|
||||
<tt>MPI_File_set_errhandler</tt> (for files), and <tt>MPI_Win_set_errhandler</tt> (for
|
||||
RMA windows). The MPI-1 routine <tt>MPI_Errhandler_set</tt> may be used but
|
||||
its use is deprecated. The predefined error handler
|
||||
<tt>MPI_ERRORS_RETURN</tt> may be used to cause error values to be returned.
|
||||
Note that MPI does <em>not</em> guarantee that an MPI program can continue past
|
||||
an error; however, MPI implementations will attempt to continue whenever
|
||||
possible.
|
||||
<P>
|
||||
<DL>
|
||||
<DT><B>MPI_SUCCESS </B> <DD> No error; MPI routine completed successfully.
|
||||
</DL>
|
||||
<DL>
|
||||
<DT><B>MPI_ERR_ARG </B> <DD> Invalid argument. Some argument is invalid and is not
|
||||
identified by a specific error class (e.g., <tt>MPI_ERR_RANK</tt>).
|
||||
</DL>
|
||||
<DL>
|
||||
<DT><B>MPI_ERR_BUFFER </B> <DD> Invalid buffer pointer. Usually a null buffer where
|
||||
one is not valid.
|
||||
</DL>
|
||||
<DL>
|
||||
<DT><B>MPI_ERR_COMM </B> <DD> Invalid communicator. A common error is to use a null
|
||||
communicator in a call (not even allowed in <tt>MPI_Comm_rank</tt>).
|
||||
</DL>
|
||||
<DL>
|
||||
<DT><B>MPI_ERR_COUNT </B> <DD> Invalid count argument. Count arguments must be
|
||||
non-negative; a count of zero is often valid.
|
||||
</DL>
|
||||
<DL>
|
||||
<DT><B>MPI_ERR_RANK </B> <DD> Invalid source or destination rank. Ranks must be between
|
||||
zero and the size of the communicator minus one; ranks in a receive
|
||||
(<tt>MPI_Recv</tt>, <tt>MPI_Irecv</tt>, <tt>MPI_Sendrecv</tt>, etc.) may also be <tt>MPI_ANY_SOURCE</tt>.
|
||||
</DL>
|
||||
<DL>
|
||||
<DT><B>MPI_ERR_TAG </B> <DD> Invalid tag argument. Tags must be non-negative; tags
|
||||
in a receive (<tt>MPI_Recv</tt>, <tt>MPI_Irecv</tt>, <tt>MPI_Sendrecv</tt>, etc.) may
|
||||
also be <tt>MPI_ANY_TAG</tt>. The largest tag value is available through the
|
||||
the attribute <tt>MPI_TAG_UB</tt>.
|
||||
</DL>
|
||||
<DL>
|
||||
<DT><B>MPI_ERR_TYPE </B> <DD> Invalid datatype argument. Additionally, this error can
|
||||
occur if an uncommitted MPI_Datatype (see <tt>MPI_Type_commit</tt>) is used
|
||||
in a communication call.
|
||||
</DL>
|
||||
<DL>
|
||||
<DT><B>MPI_ERR_OTHER </B> <DD> Other error; use <tt>MPI_Error_string</tt> to get more information
|
||||
about this error code.
|
||||
</DL>
|
||||
<P>
|
||||
</BODY></HTML>
|
||||
@@ -0,0 +1 @@
|
||||
<meta http-equiv="refresh" content="0; url=MPIX_Stream_recv.html">
|
||||
118
macx64/mpi/mpich/share/doc/mpich/www3/MPIX_Stream_send.html
Normal file
118
macx64/mpi/mpich/share/doc/mpich/www3/MPIX_Stream_send.html
Normal file
@@ -0,0 +1,118 @@
|
||||
<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML3.2 EN">
|
||||
<HTML>
|
||||
<HEAD>
|
||||
<META NAME="GENERATOR" CONTENT="DOCTEXT">
|
||||
<TITLE>MPIX_Stream_send</TITLE>
|
||||
</HEAD>
|
||||
<BODY BGCOLOR="FFFFFF">
|
||||
<H1 id="MPIX_Stream_send">MPIX_Stream_send</H1>
|
||||
Send message from a specific local stream to a specific destination stream
|
||||
<H2>Synopsis</H2>
|
||||
<PRE>
|
||||
</PRE>
|
||||
<PRE>
|
||||
int MPIX_Stream_send(const void *buf, int count, MPI_Datatype datatype,
|
||||
int dest, int tag, MPI_Comm comm, int source_stream_index,
|
||||
int dest_stream_index)
|
||||
</PRE>
|
||||
|
||||
<PRE>
|
||||
int MPIX_Stream_send_c(const void *buf, MPI_Count count, MPI_Datatype datatype,
|
||||
int dest, int tag, MPI_Comm comm,
|
||||
int source_stream_index, int dest_stream_index)
|
||||
</PRE>
|
||||
|
||||
<P>
|
||||
<H2>Input Parameters</H2>
|
||||
<DL>
|
||||
<DT><B>buf </B> <DD> initial address of send buffer (choice)
|
||||
|
||||
<DT><B>count </B> <DD> number of elements in send buffer (non-negative integer)
|
||||
|
||||
<DT><B>datatype </B> <DD> datatype of each send buffer element (handle)
|
||||
|
||||
<DT><B>dest </B> <DD> rank of destination (integer)
|
||||
|
||||
<DT><B>tag </B> <DD> message tag (integer)
|
||||
|
||||
<DT><B>comm </B> <DD> communicator (handle)
|
||||
|
||||
<DT><B>source_stream_index </B> <DD> source_stream_index (integer)
|
||||
|
||||
<DT><B>dest_stream_index </B> <DD> dest_stream_index (integer)
|
||||
</DL>
|
||||
<P>
|
||||
<H2>Thread and Interrupt Safety</H2>
|
||||
<P>
|
||||
This routine is thread-safe. This means that this routine may be
|
||||
safely used by multiple threads without the need for any user-provided
|
||||
thread locks. However, the routine is not interrupt safe. Typically,
|
||||
this is due to the use of memory allocation routines such as <tt>malloc
|
||||
</tt>or other non-MPICH runtime routines that are themselves not interrupt-safe.
|
||||
<P>
|
||||
<H2>Notes for Fortran</H2>
|
||||
All MPI routines in Fortran (except for <tt>MPI_WTIME</tt> and <tt>MPI_WTICK</tt>) have
|
||||
an additional argument <tt>ierr</tt> at the end of the argument list. <tt>ierr
|
||||
</tt>is an integer and has the same meaning as the return value of the routine
|
||||
in C. In Fortran, MPI routines are subroutines, and are invoked with the
|
||||
<tt>call</tt> statement.
|
||||
<P>
|
||||
All MPI objects (e.g., <tt>MPI_Datatype</tt>, <tt>MPI_Comm</tt>) are of type <tt>INTEGER
|
||||
</tt>in Fortran.
|
||||
<P>
|
||||
<H2>Errors</H2>
|
||||
<P>
|
||||
All MPI routines (except <tt>MPI_Wtime</tt> and <tt>MPI_Wtick</tt>) return an error value;
|
||||
C routines as the value of the function and Fortran routines in the last
|
||||
argument. Before the value is returned, the current MPI error handler is
|
||||
called. By default, this error handler aborts the MPI job. The error handler
|
||||
may be changed with <tt>MPI_Comm_set_errhandler</tt> (for communicators),
|
||||
<tt>MPI_File_set_errhandler</tt> (for files), and <tt>MPI_Win_set_errhandler</tt> (for
|
||||
RMA windows). The MPI-1 routine <tt>MPI_Errhandler_set</tt> may be used but
|
||||
its use is deprecated. The predefined error handler
|
||||
<tt>MPI_ERRORS_RETURN</tt> may be used to cause error values to be returned.
|
||||
Note that MPI does <em>not</em> guarantee that an MPI program can continue past
|
||||
an error; however, MPI implementations will attempt to continue whenever
|
||||
possible.
|
||||
<P>
|
||||
<DL>
|
||||
<DT><B>MPI_SUCCESS </B> <DD> No error; MPI routine completed successfully.
|
||||
</DL>
|
||||
<DL>
|
||||
<DT><B>MPI_ERR_ARG </B> <DD> Invalid argument. Some argument is invalid and is not
|
||||
identified by a specific error class (e.g., <tt>MPI_ERR_RANK</tt>).
|
||||
</DL>
|
||||
<DL>
|
||||
<DT><B>MPI_ERR_BUFFER </B> <DD> Invalid buffer pointer. Usually a null buffer where
|
||||
one is not valid.
|
||||
</DL>
|
||||
<DL>
|
||||
<DT><B>MPI_ERR_COMM </B> <DD> Invalid communicator. A common error is to use a null
|
||||
communicator in a call (not even allowed in <tt>MPI_Comm_rank</tt>).
|
||||
</DL>
|
||||
<DL>
|
||||
<DT><B>MPI_ERR_COUNT </B> <DD> Invalid count argument. Count arguments must be
|
||||
non-negative; a count of zero is often valid.
|
||||
</DL>
|
||||
<DL>
|
||||
<DT><B>MPI_ERR_RANK </B> <DD> Invalid source or destination rank. Ranks must be between
|
||||
zero and the size of the communicator minus one; ranks in a receive
|
||||
(<tt>MPI_Recv</tt>, <tt>MPI_Irecv</tt>, <tt>MPI_Sendrecv</tt>, etc.) may also be <tt>MPI_ANY_SOURCE</tt>.
|
||||
</DL>
|
||||
<DL>
|
||||
<DT><B>MPI_ERR_TAG </B> <DD> Invalid tag argument. Tags must be non-negative; tags
|
||||
in a receive (<tt>MPI_Recv</tt>, <tt>MPI_Irecv</tt>, <tt>MPI_Sendrecv</tt>, etc.) may
|
||||
also be <tt>MPI_ANY_TAG</tt>. The largest tag value is available through the
|
||||
the attribute <tt>MPI_TAG_UB</tt>.
|
||||
</DL>
|
||||
<DL>
|
||||
<DT><B>MPI_ERR_TYPE </B> <DD> Invalid datatype argument. Additionally, this error can
|
||||
occur if an uncommitted MPI_Datatype (see <tt>MPI_Type_commit</tt>) is used
|
||||
in a communication call.
|
||||
</DL>
|
||||
<DL>
|
||||
<DT><B>MPI_ERR_OTHER </B> <DD> Other error; use <tt>MPI_Error_string</tt> to get more information
|
||||
about this error code.
|
||||
</DL>
|
||||
<P>
|
||||
</BODY></HTML>
|
||||
@@ -0,0 +1 @@
|
||||
<meta http-equiv="refresh" content="0; url=MPIX_Stream_send.html">
|
||||
@@ -0,0 +1,71 @@
|
||||
<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML3.2 EN">
|
||||
<HTML>
|
||||
<HEAD>
|
||||
<META NAME="GENERATOR" CONTENT="DOCTEXT">
|
||||
<TITLE>MPIX_Threadcomm_finish</TITLE>
|
||||
</HEAD>
|
||||
<BODY BGCOLOR="FFFFFF">
|
||||
<H1 id="MPIX_Threadcomm_finish">MPIX_Threadcomm_finish</H1>
|
||||
finish/deactiviate a thread communicator (inside thread parallel regions)
|
||||
<H2>Synopsis</H2>
|
||||
<PRE>
|
||||
</PRE>
|
||||
<PRE>
|
||||
int MPIX_Threadcomm_finish(MPI_Comm threadcomm)
|
||||
</PRE>
|
||||
|
||||
<P>
|
||||
<H2>Input Parameters</H2>
|
||||
<DL>
|
||||
<DT><B>threadcomm </B> <DD> thread communicator (handle)
|
||||
</DL>
|
||||
<P>
|
||||
<H2>Thread and Interrupt Safety</H2>
|
||||
<P>
|
||||
This routine is thread-safe. This means that this routine may be
|
||||
safely used by multiple threads without the need for any user-provided
|
||||
thread locks. However, the routine is not interrupt safe. Typically,
|
||||
this is due to the use of memory allocation routines such as <tt>malloc
|
||||
</tt>or other non-MPICH runtime routines that are themselves not interrupt-safe.
|
||||
<P>
|
||||
<H2>Notes for Fortran</H2>
|
||||
All MPI routines in Fortran (except for <tt>MPI_WTIME</tt> and <tt>MPI_WTICK</tt>) have
|
||||
an additional argument <tt>ierr</tt> at the end of the argument list. <tt>ierr
|
||||
</tt>is an integer and has the same meaning as the return value of the routine
|
||||
in C. In Fortran, MPI routines are subroutines, and are invoked with the
|
||||
<tt>call</tt> statement.
|
||||
<P>
|
||||
All MPI objects (e.g., <tt>MPI_Datatype</tt>, <tt>MPI_Comm</tt>) are of type <tt>INTEGER
|
||||
</tt>in Fortran.
|
||||
<P>
|
||||
<H2>Errors</H2>
|
||||
<P>
|
||||
All MPI routines (except <tt>MPI_Wtime</tt> and <tt>MPI_Wtick</tt>) return an error value;
|
||||
C routines as the value of the function and Fortran routines in the last
|
||||
argument. Before the value is returned, the current MPI error handler is
|
||||
called. By default, this error handler aborts the MPI job. The error handler
|
||||
may be changed with <tt>MPI_Comm_set_errhandler</tt> (for communicators),
|
||||
<tt>MPI_File_set_errhandler</tt> (for files), and <tt>MPI_Win_set_errhandler</tt> (for
|
||||
RMA windows). The MPI-1 routine <tt>MPI_Errhandler_set</tt> may be used but
|
||||
its use is deprecated. The predefined error handler
|
||||
<tt>MPI_ERRORS_RETURN</tt> may be used to cause error values to be returned.
|
||||
Note that MPI does <em>not</em> guarantee that an MPI program can continue past
|
||||
an error; however, MPI implementations will attempt to continue whenever
|
||||
possible.
|
||||
<P>
|
||||
<DL>
|
||||
<DT><B>MPI_SUCCESS </B> <DD> No error; MPI routine completed successfully.
|
||||
</DL>
|
||||
<DL>
|
||||
<DT><B>MPI_ERR_COMM </B> <DD> Invalid communicator. A common error is to use a null
|
||||
communicator in a call (not even allowed in <tt>MPI_Comm_rank</tt>).
|
||||
</DL>
|
||||
<DL>
|
||||
<DT><B>MPI_ERR_OTHER </B> <DD> Other error; use <tt>MPI_Error_string</tt> to get more information
|
||||
about this error code.
|
||||
</DL>
|
||||
<P>
|
||||
<H2>See Also</H2>
|
||||
MPIX_Threadcomm_init, MPIX_Threadcomm_start, MPIX_Threadcomm_free
|
||||
<br>
|
||||
</BODY></HTML>
|
||||
@@ -0,0 +1,71 @@
|
||||
<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML3.2 EN">
|
||||
<HTML>
|
||||
<HEAD>
|
||||
<META NAME="GENERATOR" CONTENT="DOCTEXT">
|
||||
<TITLE>MPIX_Threadcomm_free</TITLE>
|
||||
</HEAD>
|
||||
<BODY BGCOLOR="FFFFFF">
|
||||
<H1 id="MPIX_Threadcomm_free">MPIX_Threadcomm_free</H1>
|
||||
free a thread communicator (outside thread parallel regions)
|
||||
<H2>Synopsis</H2>
|
||||
<PRE>
|
||||
</PRE>
|
||||
<PRE>
|
||||
int MPIX_Threadcomm_free(MPI_Comm *threadcomm)
|
||||
</PRE>
|
||||
|
||||
<P>
|
||||
<H2>Input/Output Parameters</H2>
|
||||
<DL>
|
||||
<DT><B>threadcomm </B> <DD> thread communicator (handle)
|
||||
</DL>
|
||||
<P>
|
||||
<H2>Thread and Interrupt Safety</H2>
|
||||
<P>
|
||||
This routine is thread-safe. This means that this routine may be
|
||||
safely used by multiple threads without the need for any user-provided
|
||||
thread locks. However, the routine is not interrupt safe. Typically,
|
||||
this is due to the use of memory allocation routines such as <tt>malloc
|
||||
</tt>or other non-MPICH runtime routines that are themselves not interrupt-safe.
|
||||
<P>
|
||||
<H2>Notes for Fortran</H2>
|
||||
All MPI routines in Fortran (except for <tt>MPI_WTIME</tt> and <tt>MPI_WTICK</tt>) have
|
||||
an additional argument <tt>ierr</tt> at the end of the argument list. <tt>ierr
|
||||
</tt>is an integer and has the same meaning as the return value of the routine
|
||||
in C. In Fortran, MPI routines are subroutines, and are invoked with the
|
||||
<tt>call</tt> statement.
|
||||
<P>
|
||||
All MPI objects (e.g., <tt>MPI_Datatype</tt>, <tt>MPI_Comm</tt>) are of type <tt>INTEGER
|
||||
</tt>in Fortran.
|
||||
<P>
|
||||
<H2>Errors</H2>
|
||||
<P>
|
||||
All MPI routines (except <tt>MPI_Wtime</tt> and <tt>MPI_Wtick</tt>) return an error value;
|
||||
C routines as the value of the function and Fortran routines in the last
|
||||
argument. Before the value is returned, the current MPI error handler is
|
||||
called. By default, this error handler aborts the MPI job. The error handler
|
||||
may be changed with <tt>MPI_Comm_set_errhandler</tt> (for communicators),
|
||||
<tt>MPI_File_set_errhandler</tt> (for files), and <tt>MPI_Win_set_errhandler</tt> (for
|
||||
RMA windows). The MPI-1 routine <tt>MPI_Errhandler_set</tt> may be used but
|
||||
its use is deprecated. The predefined error handler
|
||||
<tt>MPI_ERRORS_RETURN</tt> may be used to cause error values to be returned.
|
||||
Note that MPI does <em>not</em> guarantee that an MPI program can continue past
|
||||
an error; however, MPI implementations will attempt to continue whenever
|
||||
possible.
|
||||
<P>
|
||||
<DL>
|
||||
<DT><B>MPI_SUCCESS </B> <DD> No error; MPI routine completed successfully.
|
||||
</DL>
|
||||
<DL>
|
||||
<DT><B>MPI_ERR_COMM </B> <DD> Invalid communicator. A common error is to use a null
|
||||
communicator in a call (not even allowed in <tt>MPI_Comm_rank</tt>).
|
||||
</DL>
|
||||
<DL>
|
||||
<DT><B>MPI_ERR_OTHER </B> <DD> Other error; use <tt>MPI_Error_string</tt> to get more information
|
||||
about this error code.
|
||||
</DL>
|
||||
<P>
|
||||
<H2>See Also</H2>
|
||||
MPIX_Threadcomm_init, MPIX_Threadcomm_start, MPIX_Threadcomm_finish
|
||||
<br>
|
||||
</BODY></HTML>
|
||||
@@ -0,0 +1,83 @@
|
||||
<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML3.2 EN">
|
||||
<HTML>
|
||||
<HEAD>
|
||||
<META NAME="GENERATOR" CONTENT="DOCTEXT">
|
||||
<TITLE>MPIX_Threadcomm_init</TITLE>
|
||||
</HEAD>
|
||||
<BODY BGCOLOR="FFFFFF">
|
||||
<H1 id="MPIX_Threadcomm_init">MPIX_Threadcomm_init</H1>
|
||||
initialize a thread communicator (outside thread parallel regions)
|
||||
<H2>Synopsis</H2>
|
||||
<PRE>
|
||||
</PRE>
|
||||
<PRE>
|
||||
int MPIX_Threadcomm_init(MPI_Comm comm, int num_threads,
|
||||
MPI_Comm *newthreadcomm)
|
||||
</PRE>
|
||||
|
||||
<P>
|
||||
<H2>Input Parameters</H2>
|
||||
<DL>
|
||||
<DT><B>comm </B> <DD> communicator (handle)
|
||||
|
||||
<DT><B>num_threads </B> <DD> number of participating threads (non-negative integer)
|
||||
</DL>
|
||||
<P>
|
||||
<H2>Output Parameters</H2>
|
||||
<DL>
|
||||
<DT><B>newthreadcomm </B> <DD> new thread communicator (handle)
|
||||
</DL>
|
||||
<P>
|
||||
<H2>Thread and Interrupt Safety</H2>
|
||||
<P>
|
||||
This routine is thread-safe. This means that this routine may be
|
||||
safely used by multiple threads without the need for any user-provided
|
||||
thread locks. However, the routine is not interrupt safe. Typically,
|
||||
this is due to the use of memory allocation routines such as <tt>malloc
|
||||
</tt>or other non-MPICH runtime routines that are themselves not interrupt-safe.
|
||||
<P>
|
||||
<H2>Notes for Fortran</H2>
|
||||
All MPI routines in Fortran (except for <tt>MPI_WTIME</tt> and <tt>MPI_WTICK</tt>) have
|
||||
an additional argument <tt>ierr</tt> at the end of the argument list. <tt>ierr
|
||||
</tt>is an integer and has the same meaning as the return value of the routine
|
||||
in C. In Fortran, MPI routines are subroutines, and are invoked with the
|
||||
<tt>call</tt> statement.
|
||||
<P>
|
||||
All MPI objects (e.g., <tt>MPI_Datatype</tt>, <tt>MPI_Comm</tt>) are of type <tt>INTEGER
|
||||
</tt>in Fortran.
|
||||
<P>
|
||||
<H2>Errors</H2>
|
||||
<P>
|
||||
All MPI routines (except <tt>MPI_Wtime</tt> and <tt>MPI_Wtick</tt>) return an error value;
|
||||
C routines as the value of the function and Fortran routines in the last
|
||||
argument. Before the value is returned, the current MPI error handler is
|
||||
called. By default, this error handler aborts the MPI job. The error handler
|
||||
may be changed with <tt>MPI_Comm_set_errhandler</tt> (for communicators),
|
||||
<tt>MPI_File_set_errhandler</tt> (for files), and <tt>MPI_Win_set_errhandler</tt> (for
|
||||
RMA windows). The MPI-1 routine <tt>MPI_Errhandler_set</tt> may be used but
|
||||
its use is deprecated. The predefined error handler
|
||||
<tt>MPI_ERRORS_RETURN</tt> may be used to cause error values to be returned.
|
||||
Note that MPI does <em>not</em> guarantee that an MPI program can continue past
|
||||
an error; however, MPI implementations will attempt to continue whenever
|
||||
possible.
|
||||
<P>
|
||||
<DL>
|
||||
<DT><B>MPI_SUCCESS </B> <DD> No error; MPI routine completed successfully.
|
||||
</DL>
|
||||
<DL>
|
||||
<DT><B>MPI_ERR_ARG </B> <DD> Invalid argument. Some argument is invalid and is not
|
||||
identified by a specific error class (e.g., <tt>MPI_ERR_RANK</tt>).
|
||||
</DL>
|
||||
<DL>
|
||||
<DT><B>MPI_ERR_COMM </B> <DD> Invalid communicator. A common error is to use a null
|
||||
communicator in a call (not even allowed in <tt>MPI_Comm_rank</tt>).
|
||||
</DL>
|
||||
<DL>
|
||||
<DT><B>MPI_ERR_OTHER </B> <DD> Other error; use <tt>MPI_Error_string</tt> to get more information
|
||||
about this error code.
|
||||
</DL>
|
||||
<P>
|
||||
<H2>See Also</H2>
|
||||
MPIX_Threadcomm_start, MPIX_Threadcomm_finish, MPIX_Threadcomm_free
|
||||
<br>
|
||||
</BODY></HTML>
|
||||
@@ -0,0 +1,71 @@
|
||||
<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML3.2 EN">
|
||||
<HTML>
|
||||
<HEAD>
|
||||
<META NAME="GENERATOR" CONTENT="DOCTEXT">
|
||||
<TITLE>MPIX_Threadcomm_start</TITLE>
|
||||
</HEAD>
|
||||
<BODY BGCOLOR="FFFFFF">
|
||||
<H1 id="MPIX_Threadcomm_start">MPIX_Threadcomm_start</H1>
|
||||
start/activiate a thread communicator (inside thread parallel regions)
|
||||
<H2>Synopsis</H2>
|
||||
<PRE>
|
||||
</PRE>
|
||||
<PRE>
|
||||
int MPIX_Threadcomm_start(MPI_Comm threadcomm)
|
||||
</PRE>
|
||||
|
||||
<P>
|
||||
<H2>Input Parameters</H2>
|
||||
<DL>
|
||||
<DT><B>threadcomm </B> <DD> thread communicator (handle)
|
||||
</DL>
|
||||
<P>
|
||||
<H2>Thread and Interrupt Safety</H2>
|
||||
<P>
|
||||
This routine is thread-safe. This means that this routine may be
|
||||
safely used by multiple threads without the need for any user-provided
|
||||
thread locks. However, the routine is not interrupt safe. Typically,
|
||||
this is due to the use of memory allocation routines such as <tt>malloc
|
||||
</tt>or other non-MPICH runtime routines that are themselves not interrupt-safe.
|
||||
<P>
|
||||
<H2>Notes for Fortran</H2>
|
||||
All MPI routines in Fortran (except for <tt>MPI_WTIME</tt> and <tt>MPI_WTICK</tt>) have
|
||||
an additional argument <tt>ierr</tt> at the end of the argument list. <tt>ierr
|
||||
</tt>is an integer and has the same meaning as the return value of the routine
|
||||
in C. In Fortran, MPI routines are subroutines, and are invoked with the
|
||||
<tt>call</tt> statement.
|
||||
<P>
|
||||
All MPI objects (e.g., <tt>MPI_Datatype</tt>, <tt>MPI_Comm</tt>) are of type <tt>INTEGER
|
||||
</tt>in Fortran.
|
||||
<P>
|
||||
<H2>Errors</H2>
|
||||
<P>
|
||||
All MPI routines (except <tt>MPI_Wtime</tt> and <tt>MPI_Wtick</tt>) return an error value;
|
||||
C routines as the value of the function and Fortran routines in the last
|
||||
argument. Before the value is returned, the current MPI error handler is
|
||||
called. By default, this error handler aborts the MPI job. The error handler
|
||||
may be changed with <tt>MPI_Comm_set_errhandler</tt> (for communicators),
|
||||
<tt>MPI_File_set_errhandler</tt> (for files), and <tt>MPI_Win_set_errhandler</tt> (for
|
||||
RMA windows). The MPI-1 routine <tt>MPI_Errhandler_set</tt> may be used but
|
||||
its use is deprecated. The predefined error handler
|
||||
<tt>MPI_ERRORS_RETURN</tt> may be used to cause error values to be returned.
|
||||
Note that MPI does <em>not</em> guarantee that an MPI program can continue past
|
||||
an error; however, MPI implementations will attempt to continue whenever
|
||||
possible.
|
||||
<P>
|
||||
<DL>
|
||||
<DT><B>MPI_SUCCESS </B> <DD> No error; MPI routine completed successfully.
|
||||
</DL>
|
||||
<DL>
|
||||
<DT><B>MPI_ERR_COMM </B> <DD> Invalid communicator. A common error is to use a null
|
||||
communicator in a call (not even allowed in <tt>MPI_Comm_rank</tt>).
|
||||
</DL>
|
||||
<DL>
|
||||
<DT><B>MPI_ERR_OTHER </B> <DD> Other error; use <tt>MPI_Error_string</tt> to get more information
|
||||
about this error code.
|
||||
</DL>
|
||||
<P>
|
||||
<H2>See Also</H2>
|
||||
MPIX_Threadcomm_init, MPIX_Threadcomm_finish, MPIX_Threadcomm_free
|
||||
<br>
|
||||
</BODY></HTML>
|
||||
85
macx64/mpi/mpich/share/doc/mpich/www3/MPIX_Type_iov.html
Normal file
85
macx64/mpi/mpich/share/doc/mpich/www3/MPIX_Type_iov.html
Normal file
@@ -0,0 +1,85 @@
|
||||
<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML3.2 EN">
|
||||
<HTML>
|
||||
<HEAD>
|
||||
<META NAME="GENERATOR" CONTENT="DOCTEXT">
|
||||
<TITLE>MPIX_Type_iov</TITLE>
|
||||
</HEAD>
|
||||
<BODY BGCOLOR="FFFFFF">
|
||||
<H1 id="MPIX_Type_iov">MPIX_Type_iov</H1>
|
||||
Return contiguous segments starting from an iov offset
|
||||
<H2>Synopsis</H2>
|
||||
<PRE>
|
||||
</PRE>
|
||||
<PRE>
|
||||
int MPIX_Type_iov(MPI_Datatype datatype, MPI_Count iov_offset, MPIX_Iov *iov,
|
||||
MPI_Count max_iov_len, MPI_Count *actual_iov_len)
|
||||
</PRE>
|
||||
|
||||
<P>
|
||||
<H2>Input Parameters</H2>
|
||||
<DL>
|
||||
<DT><B>datatype </B> <DD> datatype (handle)
|
||||
|
||||
<DT><B>iov_offset </B> <DD> number of contiguous segments to skip (integer)
|
||||
|
||||
<DT><B>max_iov_len </B> <DD> capacity for the segments array (integer)
|
||||
</DL>
|
||||
<P>
|
||||
<H2>Output Parameters</H2>
|
||||
<DL>
|
||||
<DT><B>iov </B> <DD> contiguous segments array for output (None)
|
||||
|
||||
<DT><B>actual_iov_len </B> <DD> actual number of segments in output (integer)
|
||||
</DL>
|
||||
<P>
|
||||
<H2>Thread and Interrupt Safety</H2>
|
||||
<P>
|
||||
This routine is thread-safe. This means that this routine may be
|
||||
safely used by multiple threads without the need for any user-provided
|
||||
thread locks. However, the routine is not interrupt safe. Typically,
|
||||
this is due to the use of memory allocation routines such as <tt>malloc
|
||||
</tt>or other non-MPICH runtime routines that are themselves not interrupt-safe.
|
||||
<P>
|
||||
<H2>Notes for Fortran</H2>
|
||||
All MPI routines in Fortran (except for <tt>MPI_WTIME</tt> and <tt>MPI_WTICK</tt>) have
|
||||
an additional argument <tt>ierr</tt> at the end of the argument list. <tt>ierr
|
||||
</tt>is an integer and has the same meaning as the return value of the routine
|
||||
in C. In Fortran, MPI routines are subroutines, and are invoked with the
|
||||
<tt>call</tt> statement.
|
||||
<P>
|
||||
All MPI objects (e.g., <tt>MPI_Datatype</tt>, <tt>MPI_Comm</tt>) are of type <tt>INTEGER
|
||||
</tt>in Fortran.
|
||||
<P>
|
||||
<H2>Errors</H2>
|
||||
<P>
|
||||
All MPI routines (except <tt>MPI_Wtime</tt> and <tt>MPI_Wtick</tt>) return an error value;
|
||||
C routines as the value of the function and Fortran routines in the last
|
||||
argument. Before the value is returned, the current MPI error handler is
|
||||
called. By default, this error handler aborts the MPI job. The error handler
|
||||
may be changed with <tt>MPI_Comm_set_errhandler</tt> (for communicators),
|
||||
<tt>MPI_File_set_errhandler</tt> (for files), and <tt>MPI_Win_set_errhandler</tt> (for
|
||||
RMA windows). The MPI-1 routine <tt>MPI_Errhandler_set</tt> may be used but
|
||||
its use is deprecated. The predefined error handler
|
||||
<tt>MPI_ERRORS_RETURN</tt> may be used to cause error values to be returned.
|
||||
Note that MPI does <em>not</em> guarantee that an MPI program can continue past
|
||||
an error; however, MPI implementations will attempt to continue whenever
|
||||
possible.
|
||||
<P>
|
||||
<DL>
|
||||
<DT><B>MPI_SUCCESS </B> <DD> No error; MPI routine completed successfully.
|
||||
</DL>
|
||||
<DL>
|
||||
<DT><B>MPI_ERR_ARG </B> <DD> Invalid argument. Some argument is invalid and is not
|
||||
identified by a specific error class (e.g., <tt>MPI_ERR_RANK</tt>).
|
||||
</DL>
|
||||
<DL>
|
||||
<DT><B>MPI_ERR_TYPE </B> <DD> Invalid datatype argument. Additionally, this error can
|
||||
occur if an uncommitted MPI_Datatype (see <tt>MPI_Type_commit</tt>) is used
|
||||
in a communication call.
|
||||
</DL>
|
||||
<DL>
|
||||
<DT><B>MPI_ERR_OTHER </B> <DD> Other error; use <tt>MPI_Error_string</tt> to get more information
|
||||
about this error code.
|
||||
</DL>
|
||||
<P>
|
||||
</BODY></HTML>
|
||||
83
macx64/mpi/mpich/share/doc/mpich/www3/MPIX_Type_iov_len.html
Normal file
83
macx64/mpi/mpich/share/doc/mpich/www3/MPIX_Type_iov_len.html
Normal file
@@ -0,0 +1,83 @@
|
||||
<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML3.2 EN">
|
||||
<HTML>
|
||||
<HEAD>
|
||||
<META NAME="GENERATOR" CONTENT="DOCTEXT">
|
||||
<TITLE>MPIX_Type_iov_len</TITLE>
|
||||
</HEAD>
|
||||
<BODY BGCOLOR="FFFFFF">
|
||||
<H1 id="MPIX_Type_iov_len">MPIX_Type_iov_len</H1>
|
||||
Return the number of contiguous segments within max_iov_bytes
|
||||
<H2>Synopsis</H2>
|
||||
<PRE>
|
||||
</PRE>
|
||||
<PRE>
|
||||
int MPIX_Type_iov_len(MPI_Datatype datatype, MPI_Count max_iov_bytes,
|
||||
MPI_Count *iov_len, MPI_Count *actual_iov_bytes)
|
||||
</PRE>
|
||||
|
||||
<P>
|
||||
<H2>Input Parameters</H2>
|
||||
<DL>
|
||||
<DT><B>datatype </B> <DD> datatype (handle)
|
||||
|
||||
<DT><B>max_iov_bytes </B> <DD> maximum number bytes in the iovs (integer)
|
||||
</DL>
|
||||
<P>
|
||||
<H2>Output Parameters</H2>
|
||||
<DL>
|
||||
<DT><B>iov_len </B> <DD> number of iovs within max_iov_bytes (integer)
|
||||
|
||||
<DT><B>actual_iov_bytes </B> <DD> actual number of bytes in the iovs (integer)
|
||||
</DL>
|
||||
<P>
|
||||
<H2>Thread and Interrupt Safety</H2>
|
||||
<P>
|
||||
This routine is thread-safe. This means that this routine may be
|
||||
safely used by multiple threads without the need for any user-provided
|
||||
thread locks. However, the routine is not interrupt safe. Typically,
|
||||
this is due to the use of memory allocation routines such as <tt>malloc
|
||||
</tt>or other non-MPICH runtime routines that are themselves not interrupt-safe.
|
||||
<P>
|
||||
<H2>Notes for Fortran</H2>
|
||||
All MPI routines in Fortran (except for <tt>MPI_WTIME</tt> and <tt>MPI_WTICK</tt>) have
|
||||
an additional argument <tt>ierr</tt> at the end of the argument list. <tt>ierr
|
||||
</tt>is an integer and has the same meaning as the return value of the routine
|
||||
in C. In Fortran, MPI routines are subroutines, and are invoked with the
|
||||
<tt>call</tt> statement.
|
||||
<P>
|
||||
All MPI objects (e.g., <tt>MPI_Datatype</tt>, <tt>MPI_Comm</tt>) are of type <tt>INTEGER
|
||||
</tt>in Fortran.
|
||||
<P>
|
||||
<H2>Errors</H2>
|
||||
<P>
|
||||
All MPI routines (except <tt>MPI_Wtime</tt> and <tt>MPI_Wtick</tt>) return an error value;
|
||||
C routines as the value of the function and Fortran routines in the last
|
||||
argument. Before the value is returned, the current MPI error handler is
|
||||
called. By default, this error handler aborts the MPI job. The error handler
|
||||
may be changed with <tt>MPI_Comm_set_errhandler</tt> (for communicators),
|
||||
<tt>MPI_File_set_errhandler</tt> (for files), and <tt>MPI_Win_set_errhandler</tt> (for
|
||||
RMA windows). The MPI-1 routine <tt>MPI_Errhandler_set</tt> may be used but
|
||||
its use is deprecated. The predefined error handler
|
||||
<tt>MPI_ERRORS_RETURN</tt> may be used to cause error values to be returned.
|
||||
Note that MPI does <em>not</em> guarantee that an MPI program can continue past
|
||||
an error; however, MPI implementations will attempt to continue whenever
|
||||
possible.
|
||||
<P>
|
||||
<DL>
|
||||
<DT><B>MPI_SUCCESS </B> <DD> No error; MPI routine completed successfully.
|
||||
</DL>
|
||||
<DL>
|
||||
<DT><B>MPI_ERR_ARG </B> <DD> Invalid argument. Some argument is invalid and is not
|
||||
identified by a specific error class (e.g., <tt>MPI_ERR_RANK</tt>).
|
||||
</DL>
|
||||
<DL>
|
||||
<DT><B>MPI_ERR_TYPE </B> <DD> Invalid datatype argument. Additionally, this error can
|
||||
occur if an uncommitted MPI_Datatype (see <tt>MPI_Type_commit</tt>) is used
|
||||
in a communication call.
|
||||
</DL>
|
||||
<DL>
|
||||
<DT><B>MPI_ERR_OTHER </B> <DD> Other error; use <tt>MPI_Error_string</tt> to get more information
|
||||
about this error code.
|
||||
</DL>
|
||||
<P>
|
||||
</BODY></HTML>
|
||||
77
macx64/mpi/mpich/share/doc/mpich/www3/MPIX_Wait_enqueue.html
Normal file
77
macx64/mpi/mpich/share/doc/mpich/www3/MPIX_Wait_enqueue.html
Normal file
@@ -0,0 +1,77 @@
|
||||
<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML3.2 EN">
|
||||
<HTML>
|
||||
<HEAD>
|
||||
<META NAME="GENERATOR" CONTENT="DOCTEXT">
|
||||
<TITLE>MPIX_Wait_enqueue</TITLE>
|
||||
</HEAD>
|
||||
<BODY BGCOLOR="FFFFFF">
|
||||
<H1 id="MPIX_Wait_enqueue">MPIX_Wait_enqueue</H1>
|
||||
Enqueue a wait operation to a GPU stream that is associated with the local stream
|
||||
<H2>Synopsis</H2>
|
||||
<PRE>
|
||||
</PRE>
|
||||
<PRE>
|
||||
int MPIX_Wait_enqueue(MPI_Request *request, MPI_Status *status)
|
||||
</PRE>
|
||||
|
||||
<P>
|
||||
<H2>Input/Output Parameters</H2>
|
||||
<DL>
|
||||
<DT><B>request </B> <DD> request (handle)
|
||||
</DL>
|
||||
<P>
|
||||
<H2>Output Parameters</H2>
|
||||
<DL>
|
||||
<DT><B>status </B> <DD> status object (Status)
|
||||
</DL>
|
||||
<P>
|
||||
<H2>Thread and Interrupt Safety</H2>
|
||||
<P>
|
||||
This routine is thread-safe. This means that this routine may be
|
||||
safely used by multiple threads without the need for any user-provided
|
||||
thread locks. However, the routine is not interrupt safe. Typically,
|
||||
this is due to the use of memory allocation routines such as <tt>malloc
|
||||
</tt>or other non-MPICH runtime routines that are themselves not interrupt-safe.
|
||||
<P>
|
||||
<H2>Notes for Fortran</H2>
|
||||
All MPI routines in Fortran (except for <tt>MPI_WTIME</tt> and <tt>MPI_WTICK</tt>) have
|
||||
an additional argument <tt>ierr</tt> at the end of the argument list. <tt>ierr
|
||||
</tt>is an integer and has the same meaning as the return value of the routine
|
||||
in C. In Fortran, MPI routines are subroutines, and are invoked with the
|
||||
<tt>call</tt> statement.
|
||||
<P>
|
||||
All MPI objects (e.g., <tt>MPI_Datatype</tt>, <tt>MPI_Comm</tt>) are of type <tt>INTEGER
|
||||
</tt>in Fortran.
|
||||
<P>
|
||||
<H2>Errors</H2>
|
||||
<P>
|
||||
All MPI routines (except <tt>MPI_Wtime</tt> and <tt>MPI_Wtick</tt>) return an error value;
|
||||
C routines as the value of the function and Fortran routines in the last
|
||||
argument. Before the value is returned, the current MPI error handler is
|
||||
called. By default, this error handler aborts the MPI job. The error handler
|
||||
may be changed with <tt>MPI_Comm_set_errhandler</tt> (for communicators),
|
||||
<tt>MPI_File_set_errhandler</tt> (for files), and <tt>MPI_Win_set_errhandler</tt> (for
|
||||
RMA windows). The MPI-1 routine <tt>MPI_Errhandler_set</tt> may be used but
|
||||
its use is deprecated. The predefined error handler
|
||||
<tt>MPI_ERRORS_RETURN</tt> may be used to cause error values to be returned.
|
||||
Note that MPI does <em>not</em> guarantee that an MPI program can continue past
|
||||
an error; however, MPI implementations will attempt to continue whenever
|
||||
possible.
|
||||
<P>
|
||||
<DL>
|
||||
<DT><B>MPI_SUCCESS </B> <DD> No error; MPI routine completed successfully.
|
||||
</DL>
|
||||
<DL>
|
||||
<DT><B>MPI_ERR_ARG </B> <DD> Invalid argument. Some argument is invalid and is not
|
||||
identified by a specific error class (e.g., <tt>MPI_ERR_RANK</tt>).
|
||||
</DL>
|
||||
<DL>
|
||||
<DT><B>MPI_ERR_REQUEST </B> <DD> Invalid <tt>MPI_Request</tt>. Either null or, in the case of a
|
||||
<tt>MPI_Start</tt> or <tt>MPI_Startall</tt>, not a persistent request.
|
||||
</DL>
|
||||
<DL>
|
||||
<DT><B>MPI_ERR_OTHER </B> <DD> Other error; use <tt>MPI_Error_string</tt> to get more information
|
||||
about this error code.
|
||||
</DL>
|
||||
<P>
|
||||
</BODY></HTML>
|
||||
@@ -0,0 +1,83 @@
|
||||
<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML3.2 EN">
|
||||
<HTML>
|
||||
<HEAD>
|
||||
<META NAME="GENERATOR" CONTENT="DOCTEXT">
|
||||
<TITLE>MPIX_Waitall_enqueue</TITLE>
|
||||
</HEAD>
|
||||
<BODY BGCOLOR="FFFFFF">
|
||||
<H1 id="MPIX_Waitall_enqueue">MPIX_Waitall_enqueue</H1>
|
||||
Enqueue a waitall operation to a GPU stream that is associated with the local stream
|
||||
<H2>Synopsis</H2>
|
||||
<PRE>
|
||||
</PRE>
|
||||
<PRE>
|
||||
int MPIX_Waitall_enqueue(int count, MPI_Request array_of_requests[],
|
||||
MPI_Status *array_of_statuses)
|
||||
</PRE>
|
||||
|
||||
<P>
|
||||
<H2>Input Parameters</H2>
|
||||
<DL>
|
||||
<DT><B>count </B> <DD> lists length (non-negative integer)
|
||||
</DL>
|
||||
<P>
|
||||
<H2>Input/Output Parameters</H2>
|
||||
<DL>
|
||||
<DT><B>array_of_requests </B> <DD> array of requests (handle)
|
||||
</DL>
|
||||
<P>
|
||||
<H2>Output Parameters</H2>
|
||||
<DL>
|
||||
<DT><B>array_of_statuses </B> <DD> array of status objects (Status)
|
||||
</DL>
|
||||
<P>
|
||||
<H2>Thread and Interrupt Safety</H2>
|
||||
<P>
|
||||
This routine is thread-safe. This means that this routine may be
|
||||
safely used by multiple threads without the need for any user-provided
|
||||
thread locks. However, the routine is not interrupt safe. Typically,
|
||||
this is due to the use of memory allocation routines such as <tt>malloc
|
||||
</tt>or other non-MPICH runtime routines that are themselves not interrupt-safe.
|
||||
<P>
|
||||
<H2>Notes for Fortran</H2>
|
||||
All MPI routines in Fortran (except for <tt>MPI_WTIME</tt> and <tt>MPI_WTICK</tt>) have
|
||||
an additional argument <tt>ierr</tt> at the end of the argument list. <tt>ierr
|
||||
</tt>is an integer and has the same meaning as the return value of the routine
|
||||
in C. In Fortran, MPI routines are subroutines, and are invoked with the
|
||||
<tt>call</tt> statement.
|
||||
<P>
|
||||
All MPI objects (e.g., <tt>MPI_Datatype</tt>, <tt>MPI_Comm</tt>) are of type <tt>INTEGER
|
||||
</tt>in Fortran.
|
||||
<P>
|
||||
<H2>Errors</H2>
|
||||
<P>
|
||||
All MPI routines (except <tt>MPI_Wtime</tt> and <tt>MPI_Wtick</tt>) return an error value;
|
||||
C routines as the value of the function and Fortran routines in the last
|
||||
argument. Before the value is returned, the current MPI error handler is
|
||||
called. By default, this error handler aborts the MPI job. The error handler
|
||||
may be changed with <tt>MPI_Comm_set_errhandler</tt> (for communicators),
|
||||
<tt>MPI_File_set_errhandler</tt> (for files), and <tt>MPI_Win_set_errhandler</tt> (for
|
||||
RMA windows). The MPI-1 routine <tt>MPI_Errhandler_set</tt> may be used but
|
||||
its use is deprecated. The predefined error handler
|
||||
<tt>MPI_ERRORS_RETURN</tt> may be used to cause error values to be returned.
|
||||
Note that MPI does <em>not</em> guarantee that an MPI program can continue past
|
||||
an error; however, MPI implementations will attempt to continue whenever
|
||||
possible.
|
||||
<P>
|
||||
<DL>
|
||||
<DT><B>MPI_SUCCESS </B> <DD> No error; MPI routine completed successfully.
|
||||
</DL>
|
||||
<DL>
|
||||
<DT><B>MPI_ERR_COUNT </B> <DD> Invalid count argument. Count arguments must be
|
||||
non-negative; a count of zero is often valid.
|
||||
</DL>
|
||||
<DL>
|
||||
<DT><B>MPI_ERR_REQUEST </B> <DD> Invalid <tt>MPI_Request</tt>. Either null or, in the case of a
|
||||
<tt>MPI_Start</tt> or <tt>MPI_Startall</tt>, not a persistent request.
|
||||
</DL>
|
||||
<DL>
|
||||
<DT><B>MPI_ERR_OTHER </B> <DD> Other error; use <tt>MPI_Error_string</tt> to get more information
|
||||
about this error code.
|
||||
</DL>
|
||||
<P>
|
||||
</BODY></HTML>
|
||||
@@ -0,0 +1,79 @@
|
||||
<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML3.2 EN">
|
||||
<HTML>
|
||||
<HEAD>
|
||||
<META NAME="GENERATOR" CONTENT="DOCTEXT">
|
||||
<TITLE>MPIX_Win_create_errhandler_x</TITLE>
|
||||
</HEAD>
|
||||
<BODY BGCOLOR="FFFFFF">
|
||||
<H1 id="MPIX_Win_create_errhandler_x">MPIX_Win_create_errhandler_x</H1>
|
||||
Creates an MPI-style window errorhandler with an extra_state
|
||||
<H2>Synopsis</H2>
|
||||
<PRE>
|
||||
</PRE>
|
||||
<PRE>
|
||||
int MPIX_Win_create_errhandler_x(MPIX_Win_errhandler_function_x *comm_errhandler_fn_x,
|
||||
MPIX_Destructor_function *destructor_fn,
|
||||
void *extra_state, MPI_Errhandler *errhandler)
|
||||
</PRE>
|
||||
|
||||
<P>
|
||||
<H2>Input Parameters</H2>
|
||||
<DL>
|
||||
<DT><B>comm_errhandler_fn_x </B> <DD> user defined error handling procedure with extra_state (function)
|
||||
|
||||
<DT><B>destructor_fn </B> <DD> callback when op is freed (function)
|
||||
|
||||
<DT><B>extra_state </B> <DD> extra state (None)
|
||||
</DL>
|
||||
<P>
|
||||
<H2>Output Parameters</H2>
|
||||
<DL>
|
||||
<DT><B>errhandler </B> <DD> MPI error handler (handle)
|
||||
</DL>
|
||||
<P>
|
||||
<H2>Thread and Interrupt Safety</H2>
|
||||
<P>
|
||||
This routine is thread-safe. This means that this routine may be
|
||||
safely used by multiple threads without the need for any user-provided
|
||||
thread locks. However, the routine is not interrupt safe. Typically,
|
||||
this is due to the use of memory allocation routines such as <tt>malloc
|
||||
</tt>or other non-MPICH runtime routines that are themselves not interrupt-safe.
|
||||
<P>
|
||||
<H2>Notes for Fortran</H2>
|
||||
All MPI routines in Fortran (except for <tt>MPI_WTIME</tt> and <tt>MPI_WTICK</tt>) have
|
||||
an additional argument <tt>ierr</tt> at the end of the argument list. <tt>ierr
|
||||
</tt>is an integer and has the same meaning as the return value of the routine
|
||||
in C. In Fortran, MPI routines are subroutines, and are invoked with the
|
||||
<tt>call</tt> statement.
|
||||
<P>
|
||||
All MPI objects (e.g., <tt>MPI_Datatype</tt>, <tt>MPI_Comm</tt>) are of type <tt>INTEGER
|
||||
</tt>in Fortran.
|
||||
<P>
|
||||
<H2>Errors</H2>
|
||||
<P>
|
||||
All MPI routines (except <tt>MPI_Wtime</tt> and <tt>MPI_Wtick</tt>) return an error value;
|
||||
C routines as the value of the function and Fortran routines in the last
|
||||
argument. Before the value is returned, the current MPI error handler is
|
||||
called. By default, this error handler aborts the MPI job. The error handler
|
||||
may be changed with <tt>MPI_Comm_set_errhandler</tt> (for communicators),
|
||||
<tt>MPI_File_set_errhandler</tt> (for files), and <tt>MPI_Win_set_errhandler</tt> (for
|
||||
RMA windows). The MPI-1 routine <tt>MPI_Errhandler_set</tt> may be used but
|
||||
its use is deprecated. The predefined error handler
|
||||
<tt>MPI_ERRORS_RETURN</tt> may be used to cause error values to be returned.
|
||||
Note that MPI does <em>not</em> guarantee that an MPI program can continue past
|
||||
an error; however, MPI implementations will attempt to continue whenever
|
||||
possible.
|
||||
<P>
|
||||
<DL>
|
||||
<DT><B>MPI_SUCCESS </B> <DD> No error; MPI routine completed successfully.
|
||||
</DL>
|
||||
<DL>
|
||||
<DT><B>MPI_ERR_ARG </B> <DD> Invalid argument. Some argument is invalid and is not
|
||||
identified by a specific error class (e.g., <tt>MPI_ERR_RANK</tt>).
|
||||
</DL>
|
||||
<DL>
|
||||
<DT><B>MPI_ERR_OTHER </B> <DD> Other error; use <tt>MPI_Error_string</tt> to get more information
|
||||
about this error code.
|
||||
</DL>
|
||||
<P>
|
||||
</BODY></HTML>
|
||||
@@ -5,22 +5,26 @@
|
||||
<TITLE>MPI_Abort</TITLE>
|
||||
</HEAD>
|
||||
<BODY BGCOLOR="FFFFFF">
|
||||
<A NAME="MPI_Abort"><H1>MPI_Abort</H1></A>
|
||||
<H1 id="MPI_Abort">MPI_Abort</H1>
|
||||
Terminates MPI execution environment
|
||||
<H2>Synopsis</H2>
|
||||
<PRE>
|
||||
</PRE>
|
||||
<PRE>
|
||||
int MPI_Abort(MPI_Comm comm, int errorcode)
|
||||
</PRE>
|
||||
|
||||
<P>
|
||||
<H2>Input Parameters</H2>
|
||||
<DL>
|
||||
<DT><B>comm </B><DD>communicator of tasks to abort
|
||||
<DT><B>comm </B> <DD> communicator of tasks to abort (handle)
|
||||
|
||||
<DT><B>errorcode </B><DD>error code to return to invoking environment
|
||||
<DT><B>errorcode </B> <DD> error code to return to invoking environment (integer)
|
||||
</DL>
|
||||
<P>
|
||||
<H2>Notes</H2>
|
||||
Terminates all MPI processes associated with the communicator <TT>comm</TT>; in
|
||||
most systems (all to date), terminates <EM>all</EM> processes.
|
||||
Terminates all MPI processes associated with the communicator <tt>comm</tt>; in
|
||||
most systems (all to date), terminates <em>all</em> processes.
|
||||
<P>
|
||||
<H2>Thread and Interrupt Safety</H2>
|
||||
<P>
|
||||
@@ -31,38 +35,48 @@ not be used from within a signal handler.
|
||||
The MPI standard defined a thread-safe interface but this does not
|
||||
mean that all routines may be called without any thread locks. For
|
||||
example, two threads must not attempt to change the contents of the
|
||||
same <TT>MPI_Info</TT> object concurrently. The user is responsible in this
|
||||
same <tt>MPI_Info</tt> object concurrently. The user is responsible in this
|
||||
case for using some mechanism, such as thread locks, to ensure that
|
||||
only one thread at a time makes use of this routine.
|
||||
Because the <TT>MPI_Abort</TT> routine is intended to ensure that an MPI
|
||||
Because the <tt>MPI_Abort</tt> routine is intended to ensure that an MPI
|
||||
process (and possibly an entire job), it cannot wait for a thread to
|
||||
release a lock or other mechanism for atomic access.
|
||||
<P>
|
||||
<H2>Notes for Fortran</H2>
|
||||
All MPI routines in Fortran (except for <TT>MPI_WTIME</TT> and <TT>MPI_WTICK</TT>) have
|
||||
an additional argument <TT>ierr</TT> at the end of the argument list. <TT>ierr
|
||||
</TT>is an integer and has the same meaning as the return value of the routine
|
||||
All MPI routines in Fortran (except for <tt>MPI_WTIME</tt> and <tt>MPI_WTICK</tt>) have
|
||||
an additional argument <tt>ierr</tt> at the end of the argument list. <tt>ierr
|
||||
</tt>is an integer and has the same meaning as the return value of the routine
|
||||
in C. In Fortran, MPI routines are subroutines, and are invoked with the
|
||||
<TT>call</TT> statement.
|
||||
<tt>call</tt> statement.
|
||||
<P>
|
||||
All MPI objects (e.g., <TT>MPI_Datatype</TT>, <TT>MPI_Comm</TT>) are of type <TT>INTEGER
|
||||
</TT>in Fortran.
|
||||
All MPI objects (e.g., <tt>MPI_Datatype</tt>, <tt>MPI_Comm</tt>) are of type <tt>INTEGER
|
||||
</tt>in Fortran.
|
||||
<P>
|
||||
<H2>Errors</H2>
|
||||
<P>
|
||||
All MPI routines (except <TT>MPI_Wtime</TT> and <TT>MPI_Wtick</TT>) return an error value;
|
||||
All MPI routines (except <tt>MPI_Wtime</tt> and <tt>MPI_Wtick</tt>) return an error value;
|
||||
C routines as the value of the function and Fortran routines in the last
|
||||
argument. Before the value is returned, the current MPI error handler is
|
||||
called. By default, this error handler aborts the MPI job. The error handler
|
||||
may be changed with <TT>MPI_Comm_set_errhandler</TT> (for communicators),
|
||||
<TT>MPI_File_set_errhandler</TT> (for files), and <TT>MPI_Win_set_errhandler</TT> (for
|
||||
RMA windows). The MPI-1 routine <TT>MPI_Errhandler_set</TT> may be used but
|
||||
may be changed with <tt>MPI_Comm_set_errhandler</tt> (for communicators),
|
||||
<tt>MPI_File_set_errhandler</tt> (for files), and <tt>MPI_Win_set_errhandler</tt> (for
|
||||
RMA windows). The MPI-1 routine <tt>MPI_Errhandler_set</tt> may be used but
|
||||
its use is deprecated. The predefined error handler
|
||||
<TT>MPI_ERRORS_RETURN</TT> may be used to cause error values to be returned.
|
||||
Note that MPI does <EM>not</EM> guarentee that an MPI program can continue past
|
||||
<tt>MPI_ERRORS_RETURN</tt> may be used to cause error values to be returned.
|
||||
Note that MPI does <em>not</em> guarantee that an MPI program can continue past
|
||||
an error; however, MPI implementations will attempt to continue whenever
|
||||
possible.
|
||||
<P>
|
||||
<DL><DT><B>MPI_SUCCESS </B> <DD> No error; MPI routine completed successfully.
|
||||
<DL>
|
||||
<DT><B>MPI_SUCCESS </B> <DD> No error; MPI routine completed successfully.
|
||||
</DL>
|
||||
<DL>
|
||||
<DT><B>MPI_ERR_COMM </B> <DD> Invalid communicator. A common error is to use a null
|
||||
communicator in a call (not even allowed in <tt>MPI_Comm_rank</tt>).
|
||||
</DL>
|
||||
<DL>
|
||||
<DT><B>MPI_ERR_OTHER </B> <DD> Other error; use <tt>MPI_Error_string</tt> to get more information
|
||||
about this error code.
|
||||
</DL>
|
||||
<P>
|
||||
</BODY></HTML>
|
||||
|
||||
@@ -5,86 +5,105 @@
|
||||
<TITLE>MPI_Accumulate</TITLE>
|
||||
</HEAD>
|
||||
<BODY BGCOLOR="FFFFFF">
|
||||
<A NAME="MPI_Accumulate"><H1>MPI_Accumulate</H1></A>
|
||||
<H1 id="MPI_Accumulate">MPI_Accumulate</H1>
|
||||
Accumulate data into the target process using remote memory access
|
||||
<H2>Synopsis</H2>
|
||||
<PRE>
|
||||
int MPI_Accumulate(const void *origin_addr, int origin_count, MPI_Datatype
|
||||
origin_datatype, int target_rank, MPI_Aint
|
||||
target_disp, int target_count, MPI_Datatype
|
||||
target_datatype, MPI_Op op, MPI_Win win)
|
||||
</PRE>
|
||||
<PRE>
|
||||
int MPI_Accumulate(const void *origin_addr, int origin_count,
|
||||
MPI_Datatype origin_datatype, int target_rank,
|
||||
MPI_Aint target_disp, int target_count,
|
||||
MPI_Datatype target_datatype, MPI_Op op, MPI_Win win)
|
||||
</PRE>
|
||||
|
||||
<PRE>
|
||||
int MPI_Accumulate_c(const void *origin_addr, MPI_Count origin_count,
|
||||
MPI_Datatype origin_datatype, int target_rank,
|
||||
MPI_Aint target_disp, MPI_Count target_count,
|
||||
MPI_Datatype target_datatype, MPI_Op op, MPI_Win win)
|
||||
</PRE>
|
||||
|
||||
<P>
|
||||
<H2>Input Parameters</H2>
|
||||
<DL>
|
||||
<DT><B>origin_addr </B><DD>initial address of buffer (choice)
|
||||
<DT><B>origin_addr </B> <DD> initial address of buffer (choice)
|
||||
|
||||
<DT><B>origin_count </B><DD>number of entries in buffer (nonnegative integer)
|
||||
<DT><B>origin_count </B> <DD> number of entries in buffer (non-negative integer)
|
||||
|
||||
<DT><B>origin_datatype </B><DD>datatype of each buffer entry (handle)
|
||||
<DT><B>origin_datatype </B> <DD> datatype of each entry (handle)
|
||||
|
||||
<DT><B>target_rank </B><DD>rank of target (nonnegative integer)
|
||||
<DT><B>target_rank </B> <DD> rank of target (non-negative integer)
|
||||
|
||||
<DT><B>target_disp </B><DD>displacement from start of window to beginning of target
|
||||
buffer (nonnegative integer)
|
||||
<DT><B>target_disp </B> <DD> displacement from start of window to beginning of target buffer (non-negative integer)
|
||||
|
||||
<DT><B>target_count </B><DD>number of entries in target buffer (nonnegative integer)
|
||||
<DT><B>target_count </B> <DD> number of entries in target buffer (non-negative integer)
|
||||
|
||||
<DT><B>target_datatype </B><DD>datatype of each entry in target buffer (handle)
|
||||
<DT><B>target_datatype </B> <DD> datatype of each entry in target buffer (handle)
|
||||
|
||||
<DT><B>op </B><DD>predefined reduce operation (handle)
|
||||
<DT><B>op </B> <DD> reduce operation (handle)
|
||||
|
||||
<DT><B>win </B><DD>window object (handle)
|
||||
<DT><B>win </B> <DD> window object (handle)
|
||||
</DL>
|
||||
<P>
|
||||
<H2>Notes</H2>
|
||||
The basic components of both the origin and target datatype must be the same
|
||||
predefined datatype (e.g., all <TT>MPI_INT</TT> or all <TT>MPI_DOUBLE_PRECISION</TT>).
|
||||
<P>
|
||||
<H2>Notes for Fortran</H2>
|
||||
All MPI routines in Fortran (except for <TT>MPI_WTIME</TT> and <TT>MPI_WTICK</TT>) have
|
||||
an additional argument <TT>ierr</TT> at the end of the argument list. <TT>ierr
|
||||
</TT>is an integer and has the same meaning as the return value of the routine
|
||||
All MPI routines in Fortran (except for <tt>MPI_WTIME</tt> and <tt>MPI_WTICK</tt>) have
|
||||
an additional argument <tt>ierr</tt> at the end of the argument list. <tt>ierr
|
||||
</tt>is an integer and has the same meaning as the return value of the routine
|
||||
in C. In Fortran, MPI routines are subroutines, and are invoked with the
|
||||
<TT>call</TT> statement.
|
||||
<tt>call</tt> statement.
|
||||
<P>
|
||||
All MPI objects (e.g., <TT>MPI_Datatype</TT>, <TT>MPI_Comm</TT>) are of type <TT>INTEGER
|
||||
</TT>in Fortran.
|
||||
All MPI objects (e.g., <tt>MPI_Datatype</tt>, <tt>MPI_Comm</tt>) are of type <tt>INTEGER
|
||||
</tt>in Fortran.
|
||||
<P>
|
||||
<H2>Errors</H2>
|
||||
<P>
|
||||
All MPI routines (except <TT>MPI_Wtime</TT> and <TT>MPI_Wtick</TT>) return an error value;
|
||||
All MPI routines (except <tt>MPI_Wtime</tt> and <tt>MPI_Wtick</tt>) return an error value;
|
||||
C routines as the value of the function and Fortran routines in the last
|
||||
argument. Before the value is returned, the current MPI error handler is
|
||||
called. By default, this error handler aborts the MPI job. The error handler
|
||||
may be changed with <TT>MPI_Comm_set_errhandler</TT> (for communicators),
|
||||
<TT>MPI_File_set_errhandler</TT> (for files), and <TT>MPI_Win_set_errhandler</TT> (for
|
||||
RMA windows). The MPI-1 routine <TT>MPI_Errhandler_set</TT> may be used but
|
||||
may be changed with <tt>MPI_Comm_set_errhandler</tt> (for communicators),
|
||||
<tt>MPI_File_set_errhandler</tt> (for files), and <tt>MPI_Win_set_errhandler</tt> (for
|
||||
RMA windows). The MPI-1 routine <tt>MPI_Errhandler_set</tt> may be used but
|
||||
its use is deprecated. The predefined error handler
|
||||
<TT>MPI_ERRORS_RETURN</TT> may be used to cause error values to be returned.
|
||||
Note that MPI does <EM>not</EM> guarentee that an MPI program can continue past
|
||||
<tt>MPI_ERRORS_RETURN</tt> may be used to cause error values to be returned.
|
||||
Note that MPI does <em>not</em> guarantee that an MPI program can continue past
|
||||
an error; however, MPI implementations will attempt to continue whenever
|
||||
possible.
|
||||
<P>
|
||||
<DL><DT><B>MPI_SUCCESS </B> <DD> No error; MPI routine completed successfully.
|
||||
<DL>
|
||||
<DT><B>MPI_SUCCESS </B> <DD> No error; MPI routine completed successfully.
|
||||
</DL>
|
||||
<DL><DT><B>MPI_ERR_ARG </B> <DD> Invalid argument. Some argument is invalid and is not
|
||||
identified by a specific error class (e.g., <TT>MPI_ERR_RANK</TT>).
|
||||
<DL>
|
||||
<DT><B>MPI_ERR_BUFFER </B> <DD> Invalid buffer pointer. Usually a null buffer where
|
||||
one is not valid.
|
||||
</DL>
|
||||
<DL><DT><B>MPI_ERR_COUNT </B> <DD> Invalid count argument. Count arguments must be
|
||||
<DL>
|
||||
<DT><B>MPI_ERR_COUNT </B> <DD> Invalid count argument. Count arguments must be
|
||||
non-negative; a count of zero is often valid.
|
||||
</DL>
|
||||
<DL><DT><B>MPI_ERR_RANK </B> <DD> Invalid source or destination rank. Ranks must be between
|
||||
zero and the size of the communicator minus one; ranks in a receive
|
||||
(<TT>MPI_Recv</TT>, <TT>MPI_Irecv</TT>, <TT>MPI_Sendrecv</TT>, etc.) may also be <TT>MPI_ANY_SOURCE</TT>.
|
||||
<DL>
|
||||
<DT><B>MPI_ERR_DISP </B> <DD>
|
||||
</DL>
|
||||
<DL><DT><B>MPI_ERR_TYPE </B> <DD> Invalid datatype argument. Additionally, this error can
|
||||
occur if an uncommitted MPI_Datatype (see <TT>MPI_Type_commit</TT>) is used
|
||||
<DL>
|
||||
<DT><B>MPI_ERR_RANK </B> <DD> Invalid source or destination rank. Ranks must be between
|
||||
zero and the size of the communicator minus one; ranks in a receive
|
||||
(<tt>MPI_Recv</tt>, <tt>MPI_Irecv</tt>, <tt>MPI_Sendrecv</tt>, etc.) may also be <tt>MPI_ANY_SOURCE</tt>.
|
||||
</DL>
|
||||
<DL>
|
||||
<DT><B>MPI_ERR_TYPE </B> <DD> Invalid datatype argument. Additionally, this error can
|
||||
occur if an uncommitted MPI_Datatype (see <tt>MPI_Type_commit</tt>) is used
|
||||
in a communication call.
|
||||
</DL>
|
||||
<DL><DT><B>MPI_ERR_WIN </B> <DD> Invalid MPI window object
|
||||
<DL>
|
||||
<DT><B>MPI_ERR_WIN </B> <DD> Invalid MPI window object
|
||||
</DL>
|
||||
<DL>
|
||||
<DT><B>MPI_ERR_OTHER </B> <DD> Other error; use <tt>MPI_Error_string</tt> to get more information
|
||||
about this error code.
|
||||
</DL>
|
||||
<P>
|
||||
<H2>See Also</H2>
|
||||
MPI_Raccumulate
|
||||
<BR>
|
||||
<br>
|
||||
</BODY></HTML>
|
||||
|
||||
@@ -0,0 +1 @@
|
||||
<meta http-equiv="refresh" content="0; url=MPI_Accumulate.html">
|
||||
@@ -5,14 +5,19 @@
|
||||
<TITLE>MPI_Add_error_class</TITLE>
|
||||
</HEAD>
|
||||
<BODY BGCOLOR="FFFFFF">
|
||||
<A NAME="MPI_Add_error_class"><H1>MPI_Add_error_class</H1></A>
|
||||
<H1 id="MPI_Add_error_class">MPI_Add_error_class</H1>
|
||||
Add an MPI error class to the known classes
|
||||
<H2>Synopsis</H2>
|
||||
<PRE>
|
||||
</PRE>
|
||||
<PRE>
|
||||
int MPI_Add_error_class(int *errorclass)
|
||||
</PRE>
|
||||
|
||||
<P>
|
||||
<H2>Output Parameters</H2>
|
||||
<DL><DT><B>errorclass </B> <DD> New error class
|
||||
<DL>
|
||||
<DT><B>errorclass </B> <DD> value for the new error class (integer)
|
||||
</DL>
|
||||
<P>
|
||||
<H2>Thread and Interrupt Safety</H2>
|
||||
@@ -20,37 +25,44 @@ int MPI_Add_error_class(int *errorclass)
|
||||
This routine is thread-safe. This means that this routine may be
|
||||
safely used by multiple threads without the need for any user-provided
|
||||
thread locks. However, the routine is not interrupt safe. Typically,
|
||||
this is due to the use of memory allocation routines such as <TT>malloc
|
||||
</TT>or other non-MPICH runtime routines that are themselves not interrupt-safe.
|
||||
this is due to the use of memory allocation routines such as <tt>malloc
|
||||
</tt>or other non-MPICH runtime routines that are themselves not interrupt-safe.
|
||||
<P>
|
||||
<H2>Notes for Fortran</H2>
|
||||
All MPI routines in Fortran (except for <TT>MPI_WTIME</TT> and <TT>MPI_WTICK</TT>) have
|
||||
an additional argument <TT>ierr</TT> at the end of the argument list. <TT>ierr
|
||||
</TT>is an integer and has the same meaning as the return value of the routine
|
||||
All MPI routines in Fortran (except for <tt>MPI_WTIME</tt> and <tt>MPI_WTICK</tt>) have
|
||||
an additional argument <tt>ierr</tt> at the end of the argument list. <tt>ierr
|
||||
</tt>is an integer and has the same meaning as the return value of the routine
|
||||
in C. In Fortran, MPI routines are subroutines, and are invoked with the
|
||||
<TT>call</TT> statement.
|
||||
<tt>call</tt> statement.
|
||||
<P>
|
||||
All MPI objects (e.g., <TT>MPI_Datatype</TT>, <TT>MPI_Comm</TT>) are of type <TT>INTEGER
|
||||
</TT>in Fortran.
|
||||
All MPI objects (e.g., <tt>MPI_Datatype</tt>, <tt>MPI_Comm</tt>) are of type <tt>INTEGER
|
||||
</tt>in Fortran.
|
||||
<P>
|
||||
<H2>Errors</H2>
|
||||
<P>
|
||||
All MPI routines (except <TT>MPI_Wtime</TT> and <TT>MPI_Wtick</TT>) return an error value;
|
||||
All MPI routines (except <tt>MPI_Wtime</tt> and <tt>MPI_Wtick</tt>) return an error value;
|
||||
C routines as the value of the function and Fortran routines in the last
|
||||
argument. Before the value is returned, the current MPI error handler is
|
||||
called. By default, this error handler aborts the MPI job. The error handler
|
||||
may be changed with <TT>MPI_Comm_set_errhandler</TT> (for communicators),
|
||||
<TT>MPI_File_set_errhandler</TT> (for files), and <TT>MPI_Win_set_errhandler</TT> (for
|
||||
RMA windows). The MPI-1 routine <TT>MPI_Errhandler_set</TT> may be used but
|
||||
may be changed with <tt>MPI_Comm_set_errhandler</tt> (for communicators),
|
||||
<tt>MPI_File_set_errhandler</tt> (for files), and <tt>MPI_Win_set_errhandler</tt> (for
|
||||
RMA windows). The MPI-1 routine <tt>MPI_Errhandler_set</tt> may be used but
|
||||
its use is deprecated. The predefined error handler
|
||||
<TT>MPI_ERRORS_RETURN</TT> may be used to cause error values to be returned.
|
||||
Note that MPI does <EM>not</EM> guarentee that an MPI program can continue past
|
||||
<tt>MPI_ERRORS_RETURN</tt> may be used to cause error values to be returned.
|
||||
Note that MPI does <em>not</em> guarantee that an MPI program can continue past
|
||||
an error; however, MPI implementations will attempt to continue whenever
|
||||
possible.
|
||||
<P>
|
||||
<DL><DT><B>MPI_SUCCESS </B> <DD> No error; MPI routine completed successfully.
|
||||
<DL>
|
||||
<DT><B>MPI_SUCCESS </B> <DD> No error; MPI routine completed successfully.
|
||||
</DL>
|
||||
<DL><DT><B>MPI_ERR_OTHER </B> <DD> Other error; use <TT>MPI_Error_string</TT> to get more information
|
||||
<DL>
|
||||
<DT><B>MPI_ERR_ARG </B> <DD> Invalid argument. Some argument is invalid and is not
|
||||
identified by a specific error class (e.g., <tt>MPI_ERR_RANK</tt>).
|
||||
</DL>
|
||||
<DL>
|
||||
<DT><B>MPI_ERR_OTHER </B> <DD> Other error; use <tt>MPI_Error_string</tt> to get more information
|
||||
about this error code.
|
||||
</DL>
|
||||
<P>
|
||||
</BODY></HTML>
|
||||
|
||||
@@ -5,18 +5,24 @@
|
||||
<TITLE>MPI_Add_error_code</TITLE>
|
||||
</HEAD>
|
||||
<BODY BGCOLOR="FFFFFF">
|
||||
<A NAME="MPI_Add_error_code"><H1>MPI_Add_error_code</H1></A>
|
||||
<H1 id="MPI_Add_error_code">MPI_Add_error_code</H1>
|
||||
Add an MPI error code to an MPI error class
|
||||
<H2>Synopsis</H2>
|
||||
<PRE>
|
||||
</PRE>
|
||||
<PRE>
|
||||
int MPI_Add_error_code(int errorclass, int *errorcode)
|
||||
</PRE>
|
||||
|
||||
<P>
|
||||
<H2>Input Parameters</H2>
|
||||
<DL><DT><B>errorclass </B> <DD> Error class to add an error code.
|
||||
<DL>
|
||||
<DT><B>errorclass </B> <DD> error class (integer)
|
||||
</DL>
|
||||
<P>
|
||||
<H2>Output Parameters</H2>
|
||||
<DL><DT><B>errorcode </B> <DD> New error code for this error class.
|
||||
<DL>
|
||||
<DT><B>errorcode </B> <DD> new error code to be associated with errorclass (integer)
|
||||
</DL>
|
||||
<P>
|
||||
<H2>Thread and Interrupt Safety</H2>
|
||||
@@ -24,37 +30,44 @@ int MPI_Add_error_code(int errorclass, int *errorcode)
|
||||
This routine is thread-safe. This means that this routine may be
|
||||
safely used by multiple threads without the need for any user-provided
|
||||
thread locks. However, the routine is not interrupt safe. Typically,
|
||||
this is due to the use of memory allocation routines such as <TT>malloc
|
||||
</TT>or other non-MPICH runtime routines that are themselves not interrupt-safe.
|
||||
this is due to the use of memory allocation routines such as <tt>malloc
|
||||
</tt>or other non-MPICH runtime routines that are themselves not interrupt-safe.
|
||||
<P>
|
||||
<H2>Notes for Fortran</H2>
|
||||
All MPI routines in Fortran (except for <TT>MPI_WTIME</TT> and <TT>MPI_WTICK</TT>) have
|
||||
an additional argument <TT>ierr</TT> at the end of the argument list. <TT>ierr
|
||||
</TT>is an integer and has the same meaning as the return value of the routine
|
||||
All MPI routines in Fortran (except for <tt>MPI_WTIME</tt> and <tt>MPI_WTICK</tt>) have
|
||||
an additional argument <tt>ierr</tt> at the end of the argument list. <tt>ierr
|
||||
</tt>is an integer and has the same meaning as the return value of the routine
|
||||
in C. In Fortran, MPI routines are subroutines, and are invoked with the
|
||||
<TT>call</TT> statement.
|
||||
<tt>call</tt> statement.
|
||||
<P>
|
||||
All MPI objects (e.g., <TT>MPI_Datatype</TT>, <TT>MPI_Comm</TT>) are of type <TT>INTEGER
|
||||
</TT>in Fortran.
|
||||
All MPI objects (e.g., <tt>MPI_Datatype</tt>, <tt>MPI_Comm</tt>) are of type <tt>INTEGER
|
||||
</tt>in Fortran.
|
||||
<P>
|
||||
<H2>Errors</H2>
|
||||
<P>
|
||||
All MPI routines (except <TT>MPI_Wtime</TT> and <TT>MPI_Wtick</TT>) return an error value;
|
||||
All MPI routines (except <tt>MPI_Wtime</tt> and <tt>MPI_Wtick</tt>) return an error value;
|
||||
C routines as the value of the function and Fortran routines in the last
|
||||
argument. Before the value is returned, the current MPI error handler is
|
||||
called. By default, this error handler aborts the MPI job. The error handler
|
||||
may be changed with <TT>MPI_Comm_set_errhandler</TT> (for communicators),
|
||||
<TT>MPI_File_set_errhandler</TT> (for files), and <TT>MPI_Win_set_errhandler</TT> (for
|
||||
RMA windows). The MPI-1 routine <TT>MPI_Errhandler_set</TT> may be used but
|
||||
may be changed with <tt>MPI_Comm_set_errhandler</tt> (for communicators),
|
||||
<tt>MPI_File_set_errhandler</tt> (for files), and <tt>MPI_Win_set_errhandler</tt> (for
|
||||
RMA windows). The MPI-1 routine <tt>MPI_Errhandler_set</tt> may be used but
|
||||
its use is deprecated. The predefined error handler
|
||||
<TT>MPI_ERRORS_RETURN</TT> may be used to cause error values to be returned.
|
||||
Note that MPI does <EM>not</EM> guarentee that an MPI program can continue past
|
||||
<tt>MPI_ERRORS_RETURN</tt> may be used to cause error values to be returned.
|
||||
Note that MPI does <em>not</em> guarantee that an MPI program can continue past
|
||||
an error; however, MPI implementations will attempt to continue whenever
|
||||
possible.
|
||||
<P>
|
||||
<DL><DT><B>MPI_SUCCESS </B> <DD> No error; MPI routine completed successfully.
|
||||
<DL>
|
||||
<DT><B>MPI_SUCCESS </B> <DD> No error; MPI routine completed successfully.
|
||||
</DL>
|
||||
<DL><DT><B>MPI_ERR_OTHER </B> <DD> Other error; use <TT>MPI_Error_string</TT> to get more information
|
||||
<DL>
|
||||
<DT><B>MPI_ERR_ARG </B> <DD> Invalid argument. Some argument is invalid and is not
|
||||
identified by a specific error class (e.g., <tt>MPI_ERR_RANK</tt>).
|
||||
</DL>
|
||||
<DL>
|
||||
<DT><B>MPI_ERR_OTHER </B> <DD> Other error; use <tt>MPI_Error_string</tt> to get more information
|
||||
about this error code.
|
||||
</DL>
|
||||
<P>
|
||||
</BODY></HTML>
|
||||
|
||||
@@ -5,29 +5,33 @@
|
||||
<TITLE>MPI_Add_error_string</TITLE>
|
||||
</HEAD>
|
||||
<BODY BGCOLOR="FFFFFF">
|
||||
<A NAME="MPI_Add_error_string"><H1>MPI_Add_error_string</H1></A>
|
||||
<H1 id="MPI_Add_error_string">MPI_Add_error_string</H1>
|
||||
Associates an error string with an MPI error code or class
|
||||
<H2>Synopsis</H2>
|
||||
<PRE>
|
||||
</PRE>
|
||||
<PRE>
|
||||
int MPI_Add_error_string(int errorcode, const char *string)
|
||||
</PRE>
|
||||
|
||||
<P>
|
||||
<H2>Input Parameters</H2>
|
||||
<DL>
|
||||
<DT><B>errorcode </B><DD>error code or class (integer)
|
||||
<DT><B>errorcode </B> <DD> error code or class (integer)
|
||||
|
||||
<DT><B>string </B><DD>text corresponding to errorcode (string)
|
||||
<DT><B>string </B> <DD> text corresponding to errorcode (string)
|
||||
</DL>
|
||||
<P>
|
||||
<H2>Notes</H2>
|
||||
The string must be no more than <TT>MPI_MAX_ERROR_STRING</TT> characters long.
|
||||
The string must be no more than <tt>MPI_MAX_ERROR_STRING</tt> characters long.
|
||||
The length of the string is as defined in the calling language.
|
||||
The length of the string does not include the null terminator in C or C++.
|
||||
Note that the string is <TT>const</TT> even though the MPI standard does not
|
||||
Note that the string is <tt>const</tt> even though the MPI standard does not
|
||||
specify it that way.
|
||||
<P>
|
||||
According to the MPI-2 standard, it is erroneous to call <TT>MPI_Add_error_string
|
||||
</TT>for an error code or class with a value less than or equal
|
||||
to <TT>MPI_ERR_LASTCODE</TT>. Thus, you cannot replace the predefined error messages
|
||||
According to the MPI-2 standard, it is erroneous to call <tt>MPI_Add_error_string
|
||||
</tt>for an error code or class with a value less than or equal
|
||||
to <tt>MPI_ERR_LASTCODE</tt>. Thus, you cannot replace the predefined error messages
|
||||
with this routine.
|
||||
<P>
|
||||
<H2>Thread and Interrupt Safety</H2>
|
||||
@@ -35,34 +39,44 @@ with this routine.
|
||||
This routine is thread-safe. This means that this routine may be
|
||||
safely used by multiple threads without the need for any user-provided
|
||||
thread locks. However, the routine is not interrupt safe. Typically,
|
||||
this is due to the use of memory allocation routines such as <TT>malloc
|
||||
</TT>or other non-MPICH runtime routines that are themselves not interrupt-safe.
|
||||
this is due to the use of memory allocation routines such as <tt>malloc
|
||||
</tt>or other non-MPICH runtime routines that are themselves not interrupt-safe.
|
||||
<P>
|
||||
<H2>Notes for Fortran</H2>
|
||||
All MPI routines in Fortran (except for <TT>MPI_WTIME</TT> and <TT>MPI_WTICK</TT>) have
|
||||
an additional argument <TT>ierr</TT> at the end of the argument list. <TT>ierr
|
||||
</TT>is an integer and has the same meaning as the return value of the routine
|
||||
All MPI routines in Fortran (except for <tt>MPI_WTIME</tt> and <tt>MPI_WTICK</tt>) have
|
||||
an additional argument <tt>ierr</tt> at the end of the argument list. <tt>ierr
|
||||
</tt>is an integer and has the same meaning as the return value of the routine
|
||||
in C. In Fortran, MPI routines are subroutines, and are invoked with the
|
||||
<TT>call</TT> statement.
|
||||
<tt>call</tt> statement.
|
||||
<P>
|
||||
All MPI objects (e.g., <TT>MPI_Datatype</TT>, <TT>MPI_Comm</TT>) are of type <TT>INTEGER
|
||||
</TT>in Fortran.
|
||||
All MPI objects (e.g., <tt>MPI_Datatype</tt>, <tt>MPI_Comm</tt>) are of type <tt>INTEGER
|
||||
</tt>in Fortran.
|
||||
<P>
|
||||
<H2>Errors</H2>
|
||||
<P>
|
||||
All MPI routines (except <TT>MPI_Wtime</TT> and <TT>MPI_Wtick</TT>) return an error value;
|
||||
All MPI routines (except <tt>MPI_Wtime</tt> and <tt>MPI_Wtick</tt>) return an error value;
|
||||
C routines as the value of the function and Fortran routines in the last
|
||||
argument. Before the value is returned, the current MPI error handler is
|
||||
called. By default, this error handler aborts the MPI job. The error handler
|
||||
may be changed with <TT>MPI_Comm_set_errhandler</TT> (for communicators),
|
||||
<TT>MPI_File_set_errhandler</TT> (for files), and <TT>MPI_Win_set_errhandler</TT> (for
|
||||
RMA windows). The MPI-1 routine <TT>MPI_Errhandler_set</TT> may be used but
|
||||
may be changed with <tt>MPI_Comm_set_errhandler</tt> (for communicators),
|
||||
<tt>MPI_File_set_errhandler</tt> (for files), and <tt>MPI_Win_set_errhandler</tt> (for
|
||||
RMA windows). The MPI-1 routine <tt>MPI_Errhandler_set</tt> may be used but
|
||||
its use is deprecated. The predefined error handler
|
||||
<TT>MPI_ERRORS_RETURN</TT> may be used to cause error values to be returned.
|
||||
Note that MPI does <EM>not</EM> guarentee that an MPI program can continue past
|
||||
<tt>MPI_ERRORS_RETURN</tt> may be used to cause error values to be returned.
|
||||
Note that MPI does <em>not</em> guarantee that an MPI program can continue past
|
||||
an error; however, MPI implementations will attempt to continue whenever
|
||||
possible.
|
||||
<P>
|
||||
<DL><DT><B>MPI_SUCCESS </B> <DD> No error; MPI routine completed successfully.
|
||||
<DL>
|
||||
<DT><B>MPI_SUCCESS </B> <DD> No error; MPI routine completed successfully.
|
||||
</DL>
|
||||
<DL>
|
||||
<DT><B>MPI_ERR_ARG </B> <DD> Invalid argument. Some argument is invalid and is not
|
||||
identified by a specific error class (e.g., <tt>MPI_ERR_RANK</tt>).
|
||||
</DL>
|
||||
<DL>
|
||||
<DT><B>MPI_ERR_OTHER </B> <DD> Other error; use <tt>MPI_Error_string</tt> to get more information
|
||||
about this error code.
|
||||
</DL>
|
||||
<P>
|
||||
</BODY></HTML>
|
||||
|
||||
@@ -5,68 +5,74 @@
|
||||
<TITLE>MPI_Address</TITLE>
|
||||
</HEAD>
|
||||
<BODY BGCOLOR="FFFFFF">
|
||||
<A NAME="MPI_Address"><H1>MPI_Address</H1></A>
|
||||
<H1 id="MPI_Address">MPI_Address</H1>
|
||||
Gets the address of a location in memory
|
||||
<H2>Synopsis</H2>
|
||||
<PRE>
|
||||
int MPI_Address(void *location, MPI_Aint * address)
|
||||
</PRE>
|
||||
<PRE>
|
||||
int MPI_Address(void *location, MPI_Aint *address)
|
||||
</PRE>
|
||||
|
||||
<P>
|
||||
<H2>Input Parameters</H2>
|
||||
<DL><DT><B>location </B> <DD> location in caller memory (choice)
|
||||
<DL>
|
||||
<DT><B>location </B> <DD> location in caller memory (choice)
|
||||
</DL>
|
||||
<P>
|
||||
<H2>Output Parameters</H2>
|
||||
<DL><DT><B>address </B> <DD> address of location (address integer)
|
||||
<DL>
|
||||
<DT><B>address </B> <DD> address of location (integer)
|
||||
</DL>
|
||||
<P>
|
||||
<H2>Note</H2>
|
||||
This routine is provided for both the Fortran and C programmers.
|
||||
On many systems, the address returned by this routine will be the same
|
||||
as produced by the C <TT>&</TT> operator, but this is not required in C and
|
||||
may not be true of systems with word- rather than byte-oriented
|
||||
instructions or systems with segmented address spaces.
|
||||
<H2>Removed Function</H2>
|
||||
The current MPI standard defines this routine as removed. The user should use
|
||||
the replacement routine.
|
||||
The replacement for this routine is <tt>MPI_Get_address</tt>.
|
||||
<P>
|
||||
<H2>Thread and Interrupt Safety</H2>
|
||||
<P>
|
||||
This routine is both thread- and interrupt-safe.
|
||||
This means that this routine may safely be used by multiple threads and
|
||||
from within a signal handler.
|
||||
<P>
|
||||
<H2>Deprecated Function</H2>
|
||||
The MPI-2 standard deprecated a number of routines because MPI-2 provides
|
||||
better versions. This routine is one of those that was deprecated. The
|
||||
routine may continue to be used, but new code should use the replacement
|
||||
routine.
|
||||
The replacement for this routine is <TT>MPI_Get_address</TT>.
|
||||
This routine is thread-safe. This means that this routine may be
|
||||
safely used by multiple threads without the need for any user-provided
|
||||
thread locks. However, the routine is not interrupt safe. Typically,
|
||||
this is due to the use of memory allocation routines such as <tt>malloc
|
||||
</tt>or other non-MPICH runtime routines that are themselves not interrupt-safe.
|
||||
<P>
|
||||
<H2>Notes for Fortran</H2>
|
||||
All MPI routines in Fortran (except for <TT>MPI_WTIME</TT> and <TT>MPI_WTICK</TT>) have
|
||||
an additional argument <TT>ierr</TT> at the end of the argument list. <TT>ierr
|
||||
</TT>is an integer and has the same meaning as the return value of the routine
|
||||
All MPI routines in Fortran (except for <tt>MPI_WTIME</tt> and <tt>MPI_WTICK</tt>) have
|
||||
an additional argument <tt>ierr</tt> at the end of the argument list. <tt>ierr
|
||||
</tt>is an integer and has the same meaning as the return value of the routine
|
||||
in C. In Fortran, MPI routines are subroutines, and are invoked with the
|
||||
<TT>call</TT> statement.
|
||||
<tt>call</tt> statement.
|
||||
<P>
|
||||
All MPI objects (e.g., <TT>MPI_Datatype</TT>, <TT>MPI_Comm</TT>) are of type <TT>INTEGER
|
||||
</TT>in Fortran.
|
||||
All MPI objects (e.g., <tt>MPI_Datatype</tt>, <tt>MPI_Comm</tt>) are of type <tt>INTEGER
|
||||
</tt>in Fortran.
|
||||
<P>
|
||||
<H2>Errors</H2>
|
||||
<P>
|
||||
All MPI routines (except <TT>MPI_Wtime</TT> and <TT>MPI_Wtick</TT>) return an error value;
|
||||
All MPI routines (except <tt>MPI_Wtime</tt> and <tt>MPI_Wtick</tt>) return an error value;
|
||||
C routines as the value of the function and Fortran routines in the last
|
||||
argument. Before the value is returned, the current MPI error handler is
|
||||
called. By default, this error handler aborts the MPI job. The error handler
|
||||
may be changed with <TT>MPI_Comm_set_errhandler</TT> (for communicators),
|
||||
<TT>MPI_File_set_errhandler</TT> (for files), and <TT>MPI_Win_set_errhandler</TT> (for
|
||||
RMA windows). The MPI-1 routine <TT>MPI_Errhandler_set</TT> may be used but
|
||||
may be changed with <tt>MPI_Comm_set_errhandler</tt> (for communicators),
|
||||
<tt>MPI_File_set_errhandler</tt> (for files), and <tt>MPI_Win_set_errhandler</tt> (for
|
||||
RMA windows). The MPI-1 routine <tt>MPI_Errhandler_set</tt> may be used but
|
||||
its use is deprecated. The predefined error handler
|
||||
<TT>MPI_ERRORS_RETURN</TT> may be used to cause error values to be returned.
|
||||
Note that MPI does <EM>not</EM> guarentee that an MPI program can continue past
|
||||
<tt>MPI_ERRORS_RETURN</tt> may be used to cause error values to be returned.
|
||||
Note that MPI does <em>not</em> guarantee that an MPI program can continue past
|
||||
an error; however, MPI implementations will attempt to continue whenever
|
||||
possible.
|
||||
<P>
|
||||
<DL><DT><B>MPI_SUCCESS </B> <DD> No error; MPI routine completed successfully.
|
||||
<DL>
|
||||
<DT><B>MPI_SUCCESS </B> <DD> No error; MPI routine completed successfully.
|
||||
</DL>
|
||||
<DL><DT><B>MPI_ERR_OTHER </B> <DD> Other error; use <TT>MPI_Error_string</TT> to get more information
|
||||
<DL>
|
||||
<DT><B>MPI_ERR_ARG </B> <DD> Invalid argument. Some argument is invalid and is not
|
||||
identified by a specific error class (e.g., <tt>MPI_ERR_RANK</tt>).
|
||||
</DL>
|
||||
<DL>
|
||||
<DT><B>MPI_ERR_OTHER </B> <DD> Other error; use <tt>MPI_Error_string</tt> to get more information
|
||||
about this error code.
|
||||
</DL>
|
||||
<P>
|
||||
</BODY></HTML>
|
||||
|
||||
@@ -5,22 +5,23 @@
|
||||
<TITLE>MPI_Aint_add</TITLE>
|
||||
</HEAD>
|
||||
<BODY BGCOLOR="FFFFFF">
|
||||
<A NAME="MPI_Aint_add"><H1>MPI_Aint_add</H1></A>
|
||||
<H1 id="MPI_Aint_add">MPI_Aint_add</H1>
|
||||
Returns the sum of base and disp
|
||||
<H2>Synopsis</H2>
|
||||
<PRE>
|
||||
</PRE>
|
||||
<PRE>
|
||||
MPI_Aint MPI_Aint_add(MPI_Aint base, MPI_Aint disp)
|
||||
</PRE>
|
||||
|
||||
<P>
|
||||
<H2>Input Parameters</H2>
|
||||
<DL>
|
||||
<DT><B>base </B><DD>base address (integer)
|
||||
<DT><B>base </B> <DD> base address (integer)
|
||||
|
||||
<DT><B>disp </B><DD>displacement (integer)
|
||||
<DT><B>disp </B> <DD> displacement (integer)
|
||||
</DL>
|
||||
<P>
|
||||
<H2>Return value</H2>
|
||||
Sum of the base and disp argument
|
||||
<P>
|
||||
<H2>Notes</H2>
|
||||
MPI_Aint_Add produces a new MPI_Aint value that is equivalent to the sum of the
|
||||
base and disp arguments, where base represents a base address returned by a call
|
||||
@@ -28,7 +29,7 @@ to MPI_GET_ADDRESS and disp represents a signed integer displacement. The result
|
||||
address is valid only at the process that generated base, and it must correspond
|
||||
to a location in the same object referenced by base. The addition is performed in
|
||||
a manner that results in the correct MPI_Aint representation of the output address,
|
||||
as if the process that originally produced base had called:
|
||||
as if the process that originally produced base had called
|
||||
<PRE>
|
||||
MPI_Get_address((char *) base + disp, &result)
|
||||
</PRE>
|
||||
@@ -36,5 +37,5 @@ as if the process that originally produced base had called:
|
||||
<P>
|
||||
<H2>See Also</H2>
|
||||
MPI_Aint_diff
|
||||
<BR>
|
||||
<br>
|
||||
</BODY></HTML>
|
||||
|
||||
@@ -5,22 +5,23 @@
|
||||
<TITLE>MPI_Aint_diff</TITLE>
|
||||
</HEAD>
|
||||
<BODY BGCOLOR="FFFFFF">
|
||||
<A NAME="MPI_Aint_diff"><H1>MPI_Aint_diff</H1></A>
|
||||
<H1 id="MPI_Aint_diff">MPI_Aint_diff</H1>
|
||||
Returns the difference between addr1 and addr2
|
||||
<H2>Synopsis</H2>
|
||||
<PRE>
|
||||
</PRE>
|
||||
<PRE>
|
||||
MPI_Aint MPI_Aint_diff(MPI_Aint addr1, MPI_Aint addr2)
|
||||
</PRE>
|
||||
|
||||
<P>
|
||||
<H2>Input Parameters</H2>
|
||||
<DL>
|
||||
<DT><B>addr1 </B><DD>minuend address (integer)
|
||||
<DT><B>addr1 </B> <DD> minuend address (integer)
|
||||
|
||||
<DT><B>addr2 </B><DD>subtrahend address (integer)
|
||||
<DT><B>addr2 </B> <DD> subtrahend address (integer)
|
||||
</DL>
|
||||
<P>
|
||||
<H2>Return value</H2>
|
||||
Difference between addr1 and addr2
|
||||
<P>
|
||||
<H2>Notes</H2>
|
||||
MPI_Aint_diff produces a new MPI_Aint value that is equivalent to the difference
|
||||
between addr1 and addr2 arguments, where addr1 and addr2 represent addresses
|
||||
@@ -37,5 +38,5 @@ on the addresses initially passed to MPI_GET_ADDRESS.
|
||||
<P>
|
||||
<H2>See Also</H2>
|
||||
MPI_Aint_add
|
||||
<BR>
|
||||
<br>
|
||||
</BODY></HTML>
|
||||
|
||||
@@ -5,54 +5,66 @@
|
||||
<TITLE>MPI_Allgather</TITLE>
|
||||
</HEAD>
|
||||
<BODY BGCOLOR="FFFFFF">
|
||||
<A NAME="MPI_Allgather"><H1>MPI_Allgather</H1></A>
|
||||
<H1 id="MPI_Allgather">MPI_Allgather</H1>
|
||||
Gathers data from all tasks and distribute the combined data to all tasks
|
||||
<H2>Synopsis</H2>
|
||||
<PRE>
|
||||
int MPI_Allgather(const void *sendbuf, int sendcount, MPI_Datatype sendtype,
|
||||
void *recvbuf, int recvcount, MPI_Datatype recvtype, MPI_Comm comm)
|
||||
</PRE>
|
||||
<PRE>
|
||||
int MPI_Allgather(const void *sendbuf, int sendcount, MPI_Datatype sendtype,
|
||||
void *recvbuf, int recvcount, MPI_Datatype recvtype,
|
||||
MPI_Comm comm)
|
||||
</PRE>
|
||||
|
||||
<PRE>
|
||||
int MPI_Allgather_c(const void *sendbuf, MPI_Count sendcount,
|
||||
MPI_Datatype sendtype, void *recvbuf, MPI_Count recvcount,
|
||||
MPI_Datatype recvtype, MPI_Comm comm)
|
||||
</PRE>
|
||||
|
||||
<P>
|
||||
<H2>Input Parameters</H2>
|
||||
<DL>
|
||||
<DT><B>sendbuf </B><DD>starting address of send buffer (choice)
|
||||
<DT><B>sendbuf </B> <DD> starting address of send buffer (choice)
|
||||
|
||||
<DT><B>sendcount </B><DD>number of elements in send buffer (integer)
|
||||
<DT><B>sendcount </B> <DD> number of elements in send buffer (non-negative integer)
|
||||
|
||||
<DT><B>sendtype </B><DD>data type of send buffer elements (handle)
|
||||
<DT><B>sendtype </B> <DD> data type of send buffer elements (handle)
|
||||
|
||||
<DT><B>recvcount </B><DD>number of elements received from any process (integer)
|
||||
<DT><B>recvcount </B> <DD> number of elements received from any process (non-negative integer)
|
||||
|
||||
<DT><B>recvtype </B><DD>data type of receive buffer elements (handle)
|
||||
<DT><B>recvtype </B> <DD> data type of receive buffer elements (handle)
|
||||
|
||||
<DT><B>comm </B><DD>communicator (handle)
|
||||
<DT><B>comm </B> <DD> communicator (handle)
|
||||
</DL>
|
||||
<P>
|
||||
<H2>Output Parameters</H2>
|
||||
<DL><DT><B>recvbuf </B> <DD> address of receive buffer (choice)
|
||||
<DL>
|
||||
<DT><B>recvbuf </B> <DD> address of receive buffer (choice)
|
||||
</DL>
|
||||
<P>
|
||||
<H2>Notes</H2>
|
||||
The MPI standard (1.0 and 1.1) says that
|
||||
<BR>
|
||||
<br>
|
||||
<P>
|
||||
<BR>
|
||||
<br>
|
||||
<P>
|
||||
The jth block of data sent from each process is received by every process
|
||||
and placed in the jth block of the buffer <TT>recvbuf</TT>.
|
||||
<BR>
|
||||
and placed in the jth block of the buffer <tt>recvbuf</tt>.
|
||||
<br>
|
||||
<P>
|
||||
<BR>
|
||||
<br>
|
||||
<P>
|
||||
This is misleading; a better description is
|
||||
<BR>
|
||||
<br>
|
||||
<P>
|
||||
<BR>
|
||||
<br>
|
||||
<P>
|
||||
The block of data sent from the jth process is received by every
|
||||
process and placed in the jth block of the buffer <TT>recvbuf</TT>.
|
||||
<BR>
|
||||
process and placed in the jth block of the buffer <tt>recvbuf</tt>.
|
||||
<br>
|
||||
<P>
|
||||
<BR>
|
||||
<br>
|
||||
<P>
|
||||
This text was suggested by Rajeev Thakur and has been adopted as a
|
||||
clarification by the MPI Forum.
|
||||
@@ -62,45 +74,57 @@ clarification by the MPI Forum.
|
||||
This routine is thread-safe. This means that this routine may be
|
||||
safely used by multiple threads without the need for any user-provided
|
||||
thread locks. However, the routine is not interrupt safe. Typically,
|
||||
this is due to the use of memory allocation routines such as <TT>malloc
|
||||
</TT>or other non-MPICH runtime routines that are themselves not interrupt-safe.
|
||||
this is due to the use of memory allocation routines such as <tt>malloc
|
||||
</tt>or other non-MPICH runtime routines that are themselves not interrupt-safe.
|
||||
<P>
|
||||
<H2>Notes for Fortran</H2>
|
||||
All MPI routines in Fortran (except for <TT>MPI_WTIME</TT> and <TT>MPI_WTICK</TT>) have
|
||||
an additional argument <TT>ierr</TT> at the end of the argument list. <TT>ierr
|
||||
</TT>is an integer and has the same meaning as the return value of the routine
|
||||
All MPI routines in Fortran (except for <tt>MPI_WTIME</tt> and <tt>MPI_WTICK</tt>) have
|
||||
an additional argument <tt>ierr</tt> at the end of the argument list. <tt>ierr
|
||||
</tt>is an integer and has the same meaning as the return value of the routine
|
||||
in C. In Fortran, MPI routines are subroutines, and are invoked with the
|
||||
<TT>call</TT> statement.
|
||||
<tt>call</tt> statement.
|
||||
<P>
|
||||
All MPI objects (e.g., <TT>MPI_Datatype</TT>, <TT>MPI_Comm</TT>) are of type <TT>INTEGER
|
||||
</TT>in Fortran.
|
||||
All MPI objects (e.g., <tt>MPI_Datatype</tt>, <tt>MPI_Comm</tt>) are of type <tt>INTEGER
|
||||
</tt>in Fortran.
|
||||
<P>
|
||||
<H2>Errors</H2>
|
||||
<P>
|
||||
All MPI routines (except <TT>MPI_Wtime</TT> and <TT>MPI_Wtick</TT>) return an error value;
|
||||
All MPI routines (except <tt>MPI_Wtime</tt> and <tt>MPI_Wtick</tt>) return an error value;
|
||||
C routines as the value of the function and Fortran routines in the last
|
||||
argument. Before the value is returned, the current MPI error handler is
|
||||
called. By default, this error handler aborts the MPI job. The error handler
|
||||
may be changed with <TT>MPI_Comm_set_errhandler</TT> (for communicators),
|
||||
<TT>MPI_File_set_errhandler</TT> (for files), and <TT>MPI_Win_set_errhandler</TT> (for
|
||||
RMA windows). The MPI-1 routine <TT>MPI_Errhandler_set</TT> may be used but
|
||||
may be changed with <tt>MPI_Comm_set_errhandler</tt> (for communicators),
|
||||
<tt>MPI_File_set_errhandler</tt> (for files), and <tt>MPI_Win_set_errhandler</tt> (for
|
||||
RMA windows). The MPI-1 routine <tt>MPI_Errhandler_set</tt> may be used but
|
||||
its use is deprecated. The predefined error handler
|
||||
<TT>MPI_ERRORS_RETURN</TT> may be used to cause error values to be returned.
|
||||
Note that MPI does <EM>not</EM> guarentee that an MPI program can continue past
|
||||
<tt>MPI_ERRORS_RETURN</tt> may be used to cause error values to be returned.
|
||||
Note that MPI does <em>not</em> guarantee that an MPI program can continue past
|
||||
an error; however, MPI implementations will attempt to continue whenever
|
||||
possible.
|
||||
<P>
|
||||
<DL><DT><B>MPI_ERR_COMM </B> <DD> Invalid communicator. A common error is to use a null
|
||||
communicator in a call (not even allowed in <TT>MPI_Comm_rank</TT>).
|
||||
<DL>
|
||||
<DT><B>MPI_SUCCESS </B> <DD> No error; MPI routine completed successfully.
|
||||
</DL>
|
||||
<DL><DT><B>MPI_ERR_COUNT </B> <DD> Invalid count argument. Count arguments must be
|
||||
non-negative; a count of zero is often valid.
|
||||
</DL>
|
||||
<DL><DT><B>MPI_ERR_TYPE </B> <DD> Invalid datatype argument. Additionally, this error can
|
||||
occur if an uncommitted MPI_Datatype (see <TT>MPI_Type_commit</TT>) is used
|
||||
in a communication call.
|
||||
</DL>
|
||||
<DL><DT><B>MPI_ERR_BUFFER </B> <DD> Invalid buffer pointer. Usually a null buffer where
|
||||
<DL>
|
||||
<DT><B>MPI_ERR_BUFFER </B> <DD> Invalid buffer pointer. Usually a null buffer where
|
||||
one is not valid.
|
||||
</DL>
|
||||
<DL>
|
||||
<DT><B>MPI_ERR_COMM </B> <DD> Invalid communicator. A common error is to use a null
|
||||
communicator in a call (not even allowed in <tt>MPI_Comm_rank</tt>).
|
||||
</DL>
|
||||
<DL>
|
||||
<DT><B>MPI_ERR_COUNT </B> <DD> Invalid count argument. Count arguments must be
|
||||
non-negative; a count of zero is often valid.
|
||||
</DL>
|
||||
<DL>
|
||||
<DT><B>MPI_ERR_TYPE </B> <DD> Invalid datatype argument. Additionally, this error can
|
||||
occur if an uncommitted MPI_Datatype (see <tt>MPI_Type_commit</tt>) is used
|
||||
in a communication call.
|
||||
</DL>
|
||||
<DL>
|
||||
<DT><B>MPI_ERR_OTHER </B> <DD> Other error; use <tt>MPI_Error_string</tt> to get more information
|
||||
about this error code.
|
||||
</DL>
|
||||
<P>
|
||||
</BODY></HTML>
|
||||
|
||||
@@ -0,0 +1 @@
|
||||
<meta http-equiv="refresh" content="0; url=MPI_Allgather.html">
|
||||
117
macx64/mpi/mpich/share/doc/mpich/www3/MPI_Allgather_init.html
Normal file
117
macx64/mpi/mpich/share/doc/mpich/www3/MPI_Allgather_init.html
Normal file
@@ -0,0 +1,117 @@
|
||||
<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML3.2 EN">
|
||||
<HTML>
|
||||
<HEAD>
|
||||
<META NAME="GENERATOR" CONTENT="DOCTEXT">
|
||||
<TITLE>MPI_Allgather_init</TITLE>
|
||||
</HEAD>
|
||||
<BODY BGCOLOR="FFFFFF">
|
||||
<H1 id="MPI_Allgather_init">MPI_Allgather_init</H1>
|
||||
Create a persistent request for allgather.
|
||||
<H2>Synopsis</H2>
|
||||
<PRE>
|
||||
</PRE>
|
||||
<PRE>
|
||||
int MPI_Allgather_init(const void *sendbuf, int sendcount,
|
||||
MPI_Datatype sendtype, void *recvbuf, int recvcount,
|
||||
MPI_Datatype recvtype, MPI_Comm comm, MPI_Info info,
|
||||
MPI_Request *request)
|
||||
</PRE>
|
||||
|
||||
<PRE>
|
||||
int MPI_Allgather_init_c(const void *sendbuf, MPI_Count sendcount,
|
||||
MPI_Datatype sendtype, void *recvbuf,
|
||||
MPI_Count recvcount, MPI_Datatype recvtype,
|
||||
MPI_Comm comm, MPI_Info info, MPI_Request *request)
|
||||
</PRE>
|
||||
|
||||
<P>
|
||||
<H2>Input Parameters</H2>
|
||||
<DL>
|
||||
<DT><B>sendbuf </B> <DD> starting address of send buffer (choice)
|
||||
|
||||
<DT><B>sendcount </B> <DD> number of elements in send buffer (non-negative integer)
|
||||
|
||||
<DT><B>sendtype </B> <DD> data type of send buffer elements (handle)
|
||||
|
||||
<DT><B>recvcount </B> <DD> number of elements received from any process (non-negative integer)
|
||||
|
||||
<DT><B>recvtype </B> <DD> data type of receive buffer elements (handle)
|
||||
|
||||
<DT><B>comm </B> <DD> communicator (handle)
|
||||
|
||||
<DT><B>info </B> <DD> info argument (handle)
|
||||
</DL>
|
||||
<P>
|
||||
<H2>Output Parameters</H2>
|
||||
<DL>
|
||||
<DT><B>recvbuf </B> <DD> address of receive buffer (choice)
|
||||
|
||||
<DT><B>request </B> <DD> communication request (handle)
|
||||
</DL>
|
||||
<P>
|
||||
<H2>Thread and Interrupt Safety</H2>
|
||||
<P>
|
||||
This routine is thread-safe. This means that this routine may be
|
||||
safely used by multiple threads without the need for any user-provided
|
||||
thread locks. However, the routine is not interrupt safe. Typically,
|
||||
this is due to the use of memory allocation routines such as <tt>malloc
|
||||
</tt>or other non-MPICH runtime routines that are themselves not interrupt-safe.
|
||||
<P>
|
||||
<H2>Notes for Fortran</H2>
|
||||
All MPI routines in Fortran (except for <tt>MPI_WTIME</tt> and <tt>MPI_WTICK</tt>) have
|
||||
an additional argument <tt>ierr</tt> at the end of the argument list. <tt>ierr
|
||||
</tt>is an integer and has the same meaning as the return value of the routine
|
||||
in C. In Fortran, MPI routines are subroutines, and are invoked with the
|
||||
<tt>call</tt> statement.
|
||||
<P>
|
||||
All MPI objects (e.g., <tt>MPI_Datatype</tt>, <tt>MPI_Comm</tt>) are of type <tt>INTEGER
|
||||
</tt>in Fortran.
|
||||
<P>
|
||||
<H2>Errors</H2>
|
||||
<P>
|
||||
All MPI routines (except <tt>MPI_Wtime</tt> and <tt>MPI_Wtick</tt>) return an error value;
|
||||
C routines as the value of the function and Fortran routines in the last
|
||||
argument. Before the value is returned, the current MPI error handler is
|
||||
called. By default, this error handler aborts the MPI job. The error handler
|
||||
may be changed with <tt>MPI_Comm_set_errhandler</tt> (for communicators),
|
||||
<tt>MPI_File_set_errhandler</tt> (for files), and <tt>MPI_Win_set_errhandler</tt> (for
|
||||
RMA windows). The MPI-1 routine <tt>MPI_Errhandler_set</tt> may be used but
|
||||
its use is deprecated. The predefined error handler
|
||||
<tt>MPI_ERRORS_RETURN</tt> may be used to cause error values to be returned.
|
||||
Note that MPI does <em>not</em> guarantee that an MPI program can continue past
|
||||
an error; however, MPI implementations will attempt to continue whenever
|
||||
possible.
|
||||
<P>
|
||||
<DL>
|
||||
<DT><B>MPI_SUCCESS </B> <DD> No error; MPI routine completed successfully.
|
||||
</DL>
|
||||
<DL>
|
||||
<DT><B>MPI_ERR_ARG </B> <DD> Invalid argument. Some argument is invalid and is not
|
||||
identified by a specific error class (e.g., <tt>MPI_ERR_RANK</tt>).
|
||||
</DL>
|
||||
<DL>
|
||||
<DT><B>MPI_ERR_BUFFER </B> <DD> Invalid buffer pointer. Usually a null buffer where
|
||||
one is not valid.
|
||||
</DL>
|
||||
<DL>
|
||||
<DT><B>MPI_ERR_COMM </B> <DD> Invalid communicator. A common error is to use a null
|
||||
communicator in a call (not even allowed in <tt>MPI_Comm_rank</tt>).
|
||||
</DL>
|
||||
<DL>
|
||||
<DT><B>MPI_ERR_COUNT </B> <DD> Invalid count argument. Count arguments must be
|
||||
non-negative; a count of zero is often valid.
|
||||
</DL>
|
||||
<DL>
|
||||
<DT><B>MPI_ERR_INFO </B> <DD> Invalid Info
|
||||
</DL>
|
||||
<DL>
|
||||
<DT><B>MPI_ERR_TYPE </B> <DD> Invalid datatype argument. Additionally, this error can
|
||||
occur if an uncommitted MPI_Datatype (see <tt>MPI_Type_commit</tt>) is used
|
||||
in a communication call.
|
||||
</DL>
|
||||
<DL>
|
||||
<DT><B>MPI_ERR_OTHER </B> <DD> Other error; use <tt>MPI_Error_string</tt> to get more information
|
||||
about this error code.
|
||||
</DL>
|
||||
<P>
|
||||
</BODY></HTML>
|
||||
@@ -0,0 +1 @@
|
||||
<meta http-equiv="refresh" content="0; url=MPI_Allgather_init.html">
|
||||
@@ -5,61 +5,70 @@
|
||||
<TITLE>MPI_Allgatherv</TITLE>
|
||||
</HEAD>
|
||||
<BODY BGCOLOR="FFFFFF">
|
||||
<A NAME="MPI_Allgatherv"><H1>MPI_Allgatherv</H1></A>
|
||||
<H1 id="MPI_Allgatherv">MPI_Allgatherv</H1>
|
||||
Gathers data from all tasks and deliver the combined data to all tasks
|
||||
<H2>Synopsis</H2>
|
||||
<PRE>
|
||||
</PRE>
|
||||
<PRE>
|
||||
int MPI_Allgatherv(const void *sendbuf, int sendcount, MPI_Datatype sendtype,
|
||||
void *recvbuf, const int *recvcounts, const int *displs,
|
||||
void *recvbuf, const int recvcounts[], const int displs[],
|
||||
MPI_Datatype recvtype, MPI_Comm comm)
|
||||
</PRE>
|
||||
|
||||
<PRE>
|
||||
int MPI_Allgatherv_c(const void *sendbuf, MPI_Count sendcount,
|
||||
MPI_Datatype sendtype, void *recvbuf,
|
||||
const MPI_Count recvcounts[], const MPI_Aint displs[],
|
||||
MPI_Datatype recvtype, MPI_Comm comm)
|
||||
</PRE>
|
||||
|
||||
<P>
|
||||
<H2>Input Parameters</H2>
|
||||
<DL>
|
||||
<DT><B>sendbuf </B><DD>starting address of send buffer (choice)
|
||||
<DT><B>sendbuf </B> <DD> starting address of send buffer (choice)
|
||||
|
||||
<DT><B>sendcount </B><DD>number of elements in send buffer (integer)
|
||||
<DT><B>sendcount </B> <DD> number of elements in send buffer (non-negative integer)
|
||||
|
||||
<DT><B>sendtype </B><DD>data type of send buffer elements (handle)
|
||||
<DT><B>sendtype </B> <DD> data type of send buffer elements (handle)
|
||||
|
||||
<DT><B>recvcounts </B><DD>integer array (of length group size)
|
||||
containing the number of elements that are to be received from each process
|
||||
<DT><B>recvcounts </B> <DD> non-negative integer array (of length group size) containing the number of elements that are received from each process (non-negative integer)
|
||||
|
||||
<DT><B>displs </B><DD>integer array (of length group size). Entry
|
||||
<TT>i</TT> specifies the displacement (relative to recvbuf) at
|
||||
which to place the incoming data from process <TT>i
|
||||
</TT>
|
||||
<DT><B>recvtype </B><DD>data type of receive buffer elements (handle)
|
||||
<DT><B>displs </B> <DD> integer array (of length group size). Entry i specifies the displacement (relative to recvbuf) at which to place the incoming data from process i (integer)
|
||||
|
||||
<DT><B>comm </B><DD>communicator (handle)
|
||||
<DT><B>recvtype </B> <DD> data type of receive buffer elements (handle)
|
||||
|
||||
<DT><B>comm </B> <DD> communicator (handle)
|
||||
</DL>
|
||||
<P>
|
||||
<H2>Output Parameters</H2>
|
||||
<DL><DT><B>recvbuf </B> <DD> address of receive buffer (choice)
|
||||
<DL>
|
||||
<DT><B>recvbuf </B> <DD> address of receive buffer (choice)
|
||||
</DL>
|
||||
<P>
|
||||
<H2>Notes</H2>
|
||||
The MPI standard (1.0 and 1.1) says that
|
||||
<BR>
|
||||
<br>
|
||||
<P>
|
||||
<BR>
|
||||
<br>
|
||||
<P>
|
||||
The jth block of data sent from
|
||||
each process is received by every process and placed in the jth block of the
|
||||
buffer <TT>recvbuf</TT>.
|
||||
<BR>
|
||||
buffer <tt>recvbuf</tt>.
|
||||
<br>
|
||||
<P>
|
||||
<BR>
|
||||
<br>
|
||||
<P>
|
||||
This is misleading; a better description is
|
||||
<BR>
|
||||
<br>
|
||||
<P>
|
||||
<BR>
|
||||
<br>
|
||||
<P>
|
||||
The block of data sent from the jth process is received by every
|
||||
process and placed in the jth block of the buffer <TT>recvbuf</TT>.
|
||||
<BR>
|
||||
process and placed in the jth block of the buffer <tt>recvbuf</tt>.
|
||||
<br>
|
||||
<P>
|
||||
<BR>
|
||||
<br>
|
||||
<P>
|
||||
This text was suggested by Rajeev Thakur, and has been adopted as a
|
||||
clarification to the MPI standard by the MPI-Forum.
|
||||
@@ -69,42 +78,57 @@ clarification to the MPI standard by the MPI-Forum.
|
||||
This routine is thread-safe. This means that this routine may be
|
||||
safely used by multiple threads without the need for any user-provided
|
||||
thread locks. However, the routine is not interrupt safe. Typically,
|
||||
this is due to the use of memory allocation routines such as <TT>malloc
|
||||
</TT>or other non-MPICH runtime routines that are themselves not interrupt-safe.
|
||||
this is due to the use of memory allocation routines such as <tt>malloc
|
||||
</tt>or other non-MPICH runtime routines that are themselves not interrupt-safe.
|
||||
<P>
|
||||
<H2>Notes for Fortran</H2>
|
||||
All MPI routines in Fortran (except for <TT>MPI_WTIME</TT> and <TT>MPI_WTICK</TT>) have
|
||||
an additional argument <TT>ierr</TT> at the end of the argument list. <TT>ierr
|
||||
</TT>is an integer and has the same meaning as the return value of the routine
|
||||
All MPI routines in Fortran (except for <tt>MPI_WTIME</tt> and <tt>MPI_WTICK</tt>) have
|
||||
an additional argument <tt>ierr</tt> at the end of the argument list. <tt>ierr
|
||||
</tt>is an integer and has the same meaning as the return value of the routine
|
||||
in C. In Fortran, MPI routines are subroutines, and are invoked with the
|
||||
<TT>call</TT> statement.
|
||||
<tt>call</tt> statement.
|
||||
<P>
|
||||
All MPI objects (e.g., <TT>MPI_Datatype</TT>, <TT>MPI_Comm</TT>) are of type <TT>INTEGER
|
||||
</TT>in Fortran.
|
||||
All MPI objects (e.g., <tt>MPI_Datatype</tt>, <tt>MPI_Comm</tt>) are of type <tt>INTEGER
|
||||
</tt>in Fortran.
|
||||
<P>
|
||||
<H2>Errors</H2>
|
||||
<P>
|
||||
All MPI routines (except <TT>MPI_Wtime</TT> and <TT>MPI_Wtick</TT>) return an error value;
|
||||
All MPI routines (except <tt>MPI_Wtime</tt> and <tt>MPI_Wtick</tt>) return an error value;
|
||||
C routines as the value of the function and Fortran routines in the last
|
||||
argument. Before the value is returned, the current MPI error handler is
|
||||
called. By default, this error handler aborts the MPI job. The error handler
|
||||
may be changed with <TT>MPI_Comm_set_errhandler</TT> (for communicators),
|
||||
<TT>MPI_File_set_errhandler</TT> (for files), and <TT>MPI_Win_set_errhandler</TT> (for
|
||||
RMA windows). The MPI-1 routine <TT>MPI_Errhandler_set</TT> may be used but
|
||||
may be changed with <tt>MPI_Comm_set_errhandler</tt> (for communicators),
|
||||
<tt>MPI_File_set_errhandler</tt> (for files), and <tt>MPI_Win_set_errhandler</tt> (for
|
||||
RMA windows). The MPI-1 routine <tt>MPI_Errhandler_set</tt> may be used but
|
||||
its use is deprecated. The predefined error handler
|
||||
<TT>MPI_ERRORS_RETURN</TT> may be used to cause error values to be returned.
|
||||
Note that MPI does <EM>not</EM> guarentee that an MPI program can continue past
|
||||
<tt>MPI_ERRORS_RETURN</tt> may be used to cause error values to be returned.
|
||||
Note that MPI does <em>not</em> guarantee that an MPI program can continue past
|
||||
an error; however, MPI implementations will attempt to continue whenever
|
||||
possible.
|
||||
<P>
|
||||
<DL><DT><B>MPI_ERR_BUFFER </B> <DD> Invalid buffer pointer. Usually a null buffer where
|
||||
<DL>
|
||||
<DT><B>MPI_SUCCESS </B> <DD> No error; MPI routine completed successfully.
|
||||
</DL>
|
||||
<DL>
|
||||
<DT><B>MPI_ERR_BUFFER </B> <DD> Invalid buffer pointer. Usually a null buffer where
|
||||
one is not valid.
|
||||
</DL>
|
||||
<DL><DT><B>MPI_ERR_COUNT </B> <DD> Invalid count argument. Count arguments must be
|
||||
<DL>
|
||||
<DT><B>MPI_ERR_COMM </B> <DD> Invalid communicator. A common error is to use a null
|
||||
communicator in a call (not even allowed in <tt>MPI_Comm_rank</tt>).
|
||||
</DL>
|
||||
<DL>
|
||||
<DT><B>MPI_ERR_COUNT </B> <DD> Invalid count argument. Count arguments must be
|
||||
non-negative; a count of zero is often valid.
|
||||
</DL>
|
||||
<DL><DT><B>MPI_ERR_TYPE </B> <DD> Invalid datatype argument. Additionally, this error can
|
||||
occur if an uncommitted MPI_Datatype (see <TT>MPI_Type_commit</TT>) is used
|
||||
<DL>
|
||||
<DT><B>MPI_ERR_TYPE </B> <DD> Invalid datatype argument. Additionally, this error can
|
||||
occur if an uncommitted MPI_Datatype (see <tt>MPI_Type_commit</tt>) is used
|
||||
in a communication call.
|
||||
</DL>
|
||||
<DL>
|
||||
<DT><B>MPI_ERR_OTHER </B> <DD> Other error; use <tt>MPI_Error_string</tt> to get more information
|
||||
about this error code.
|
||||
</DL>
|
||||
<P>
|
||||
</BODY></HTML>
|
||||
|
||||
@@ -0,0 +1 @@
|
||||
<meta http-equiv="refresh" content="0; url=MPI_Allgatherv.html">
|
||||
121
macx64/mpi/mpich/share/doc/mpich/www3/MPI_Allgatherv_init.html
Normal file
121
macx64/mpi/mpich/share/doc/mpich/www3/MPI_Allgatherv_init.html
Normal file
@@ -0,0 +1,121 @@
|
||||
<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML3.2 EN">
|
||||
<HTML>
|
||||
<HEAD>
|
||||
<META NAME="GENERATOR" CONTENT="DOCTEXT">
|
||||
<TITLE>MPI_Allgatherv_init</TITLE>
|
||||
</HEAD>
|
||||
<BODY BGCOLOR="FFFFFF">
|
||||
<H1 id="MPI_Allgatherv_init">MPI_Allgatherv_init</H1>
|
||||
Create a persistent request for allgatherv.
|
||||
<H2>Synopsis</H2>
|
||||
<PRE>
|
||||
</PRE>
|
||||
<PRE>
|
||||
int MPI_Allgatherv_init(const void *sendbuf, int sendcount,
|
||||
MPI_Datatype sendtype, void *recvbuf,
|
||||
const int recvcounts[], const int displs[],
|
||||
MPI_Datatype recvtype, MPI_Comm comm, MPI_Info info,
|
||||
MPI_Request *request)
|
||||
</PRE>
|
||||
|
||||
<PRE>
|
||||
int MPI_Allgatherv_init_c(const void *sendbuf, MPI_Count sendcount,
|
||||
MPI_Datatype sendtype, void *recvbuf,
|
||||
const MPI_Count recvcounts[], const MPI_Aint displs[],
|
||||
MPI_Datatype recvtype, MPI_Comm comm, MPI_Info info,
|
||||
MPI_Request *request)
|
||||
</PRE>
|
||||
|
||||
<P>
|
||||
<H2>Input Parameters</H2>
|
||||
<DL>
|
||||
<DT><B>sendbuf </B> <DD> starting address of send buffer (choice)
|
||||
|
||||
<DT><B>sendcount </B> <DD> number of elements in send buffer (non-negative integer)
|
||||
|
||||
<DT><B>sendtype </B> <DD> data type of send buffer elements (handle)
|
||||
|
||||
<DT><B>recvcounts </B> <DD> non-negative integer array (of length group size) containing the number of elements that are received from each process (non-negative integer)
|
||||
|
||||
<DT><B>displs </B> <DD> integer array (of length group size). Entry i specifies the displacement (relative to recvbuf) at which to place the incoming data from process i (integer)
|
||||
|
||||
<DT><B>recvtype </B> <DD> data type of receive buffer elements (handle)
|
||||
|
||||
<DT><B>comm </B> <DD> communicator (handle)
|
||||
|
||||
<DT><B>info </B> <DD> info argument (handle)
|
||||
</DL>
|
||||
<P>
|
||||
<H2>Output Parameters</H2>
|
||||
<DL>
|
||||
<DT><B>recvbuf </B> <DD> address of receive buffer (choice)
|
||||
|
||||
<DT><B>request </B> <DD> communication request (handle)
|
||||
</DL>
|
||||
<P>
|
||||
<H2>Thread and Interrupt Safety</H2>
|
||||
<P>
|
||||
This routine is thread-safe. This means that this routine may be
|
||||
safely used by multiple threads without the need for any user-provided
|
||||
thread locks. However, the routine is not interrupt safe. Typically,
|
||||
this is due to the use of memory allocation routines such as <tt>malloc
|
||||
</tt>or other non-MPICH runtime routines that are themselves not interrupt-safe.
|
||||
<P>
|
||||
<H2>Notes for Fortran</H2>
|
||||
All MPI routines in Fortran (except for <tt>MPI_WTIME</tt> and <tt>MPI_WTICK</tt>) have
|
||||
an additional argument <tt>ierr</tt> at the end of the argument list. <tt>ierr
|
||||
</tt>is an integer and has the same meaning as the return value of the routine
|
||||
in C. In Fortran, MPI routines are subroutines, and are invoked with the
|
||||
<tt>call</tt> statement.
|
||||
<P>
|
||||
All MPI objects (e.g., <tt>MPI_Datatype</tt>, <tt>MPI_Comm</tt>) are of type <tt>INTEGER
|
||||
</tt>in Fortran.
|
||||
<P>
|
||||
<H2>Errors</H2>
|
||||
<P>
|
||||
All MPI routines (except <tt>MPI_Wtime</tt> and <tt>MPI_Wtick</tt>) return an error value;
|
||||
C routines as the value of the function and Fortran routines in the last
|
||||
argument. Before the value is returned, the current MPI error handler is
|
||||
called. By default, this error handler aborts the MPI job. The error handler
|
||||
may be changed with <tt>MPI_Comm_set_errhandler</tt> (for communicators),
|
||||
<tt>MPI_File_set_errhandler</tt> (for files), and <tt>MPI_Win_set_errhandler</tt> (for
|
||||
RMA windows). The MPI-1 routine <tt>MPI_Errhandler_set</tt> may be used but
|
||||
its use is deprecated. The predefined error handler
|
||||
<tt>MPI_ERRORS_RETURN</tt> may be used to cause error values to be returned.
|
||||
Note that MPI does <em>not</em> guarantee that an MPI program can continue past
|
||||
an error; however, MPI implementations will attempt to continue whenever
|
||||
possible.
|
||||
<P>
|
||||
<DL>
|
||||
<DT><B>MPI_SUCCESS </B> <DD> No error; MPI routine completed successfully.
|
||||
</DL>
|
||||
<DL>
|
||||
<DT><B>MPI_ERR_ARG </B> <DD> Invalid argument. Some argument is invalid and is not
|
||||
identified by a specific error class (e.g., <tt>MPI_ERR_RANK</tt>).
|
||||
</DL>
|
||||
<DL>
|
||||
<DT><B>MPI_ERR_BUFFER </B> <DD> Invalid buffer pointer. Usually a null buffer where
|
||||
one is not valid.
|
||||
</DL>
|
||||
<DL>
|
||||
<DT><B>MPI_ERR_COMM </B> <DD> Invalid communicator. A common error is to use a null
|
||||
communicator in a call (not even allowed in <tt>MPI_Comm_rank</tt>).
|
||||
</DL>
|
||||
<DL>
|
||||
<DT><B>MPI_ERR_COUNT </B> <DD> Invalid count argument. Count arguments must be
|
||||
non-negative; a count of zero is often valid.
|
||||
</DL>
|
||||
<DL>
|
||||
<DT><B>MPI_ERR_INFO </B> <DD> Invalid Info
|
||||
</DL>
|
||||
<DL>
|
||||
<DT><B>MPI_ERR_TYPE </B> <DD> Invalid datatype argument. Additionally, this error can
|
||||
occur if an uncommitted MPI_Datatype (see <tt>MPI_Type_commit</tt>) is used
|
||||
in a communication call.
|
||||
</DL>
|
||||
<DL>
|
||||
<DT><B>MPI_ERR_OTHER </B> <DD> Other error; use <tt>MPI_Error_string</tt> to get more information
|
||||
about this error code.
|
||||
</DL>
|
||||
<P>
|
||||
</BODY></HTML>
|
||||
@@ -0,0 +1 @@
|
||||
<meta http-equiv="refresh" content="0; url=MPI_Allgatherv_init.html">
|
||||
@@ -5,21 +5,26 @@
|
||||
<TITLE>MPI_Alloc_mem</TITLE>
|
||||
</HEAD>
|
||||
<BODY BGCOLOR="FFFFFF">
|
||||
<A NAME="MPI_Alloc_mem"><H1>MPI_Alloc_mem</H1></A>
|
||||
<H1 id="MPI_Alloc_mem">MPI_Alloc_mem</H1>
|
||||
Allocate memory for message passing and RMA
|
||||
<H2>Synopsis</H2>
|
||||
<PRE>
|
||||
</PRE>
|
||||
<PRE>
|
||||
int MPI_Alloc_mem(MPI_Aint size, MPI_Info info, void *baseptr)
|
||||
</PRE>
|
||||
|
||||
<P>
|
||||
<H2>Input Parameters</H2>
|
||||
<DL>
|
||||
<DT><B>size </B><DD>size of memory segment in bytes (nonnegative integer)
|
||||
<DT><B>size </B> <DD> size of memory segment in bytes (non-negative integer)
|
||||
|
||||
<DT><B>info </B><DD>info argument (handle)
|
||||
<DT><B>info </B> <DD> info argument (handle)
|
||||
</DL>
|
||||
<P>
|
||||
<H2>Output Parameters</H2>
|
||||
<DL><DT><B>baseptr </B> <DD> pointer to beginning of memory segment allocated
|
||||
<DL>
|
||||
<DT><B>baseptr </B> <DD> pointer to beginning of memory segment allocated (choice)
|
||||
</DL>
|
||||
<P>
|
||||
<H2>Notes</H2>
|
||||
@@ -27,9 +32,9 @@ Using this routine from Fortran requires that the Fortran compiler accept
|
||||
a common pointer extension. See Section 4.11 (Memory Allocation) in the
|
||||
MPI-2 standard for more information and examples.
|
||||
<P>
|
||||
Also note that while <TT>baseptr</TT> is a <TT>void *</TT> type, this is
|
||||
Also note that while <tt>baseptr</tt> is a <tt>void *</tt> type, this is
|
||||
simply to allow easy use of any pointer object for this parameter.
|
||||
In fact, this argument is really a <TT>void **</TT> type, that is, a
|
||||
In fact, this argument is really a <tt>void **</tt> type, that is, a
|
||||
pointer to a pointer.
|
||||
<P>
|
||||
<H2>Thread and Interrupt Safety</H2>
|
||||
@@ -37,43 +42,52 @@ pointer to a pointer.
|
||||
This routine is thread-safe. This means that this routine may be
|
||||
safely used by multiple threads without the need for any user-provided
|
||||
thread locks. However, the routine is not interrupt safe. Typically,
|
||||
this is due to the use of memory allocation routines such as <TT>malloc
|
||||
</TT>or other non-MPICH runtime routines that are themselves not interrupt-safe.
|
||||
this is due to the use of memory allocation routines such as <tt>malloc
|
||||
</tt>or other non-MPICH runtime routines that are themselves not interrupt-safe.
|
||||
<P>
|
||||
<H2>Notes for Fortran</H2>
|
||||
All MPI routines in Fortran (except for <TT>MPI_WTIME</TT> and <TT>MPI_WTICK</TT>) have
|
||||
an additional argument <TT>ierr</TT> at the end of the argument list. <TT>ierr
|
||||
</TT>is an integer and has the same meaning as the return value of the routine
|
||||
All MPI routines in Fortran (except for <tt>MPI_WTIME</tt> and <tt>MPI_WTICK</tt>) have
|
||||
an additional argument <tt>ierr</tt> at the end of the argument list. <tt>ierr
|
||||
</tt>is an integer and has the same meaning as the return value of the routine
|
||||
in C. In Fortran, MPI routines are subroutines, and are invoked with the
|
||||
<TT>call</TT> statement.
|
||||
<tt>call</tt> statement.
|
||||
<P>
|
||||
All MPI objects (e.g., <TT>MPI_Datatype</TT>, <TT>MPI_Comm</TT>) are of type <TT>INTEGER
|
||||
</TT>in Fortran.
|
||||
All MPI objects (e.g., <tt>MPI_Datatype</tt>, <tt>MPI_Comm</tt>) are of type <tt>INTEGER
|
||||
</tt>in Fortran.
|
||||
<P>
|
||||
<H2>Errors</H2>
|
||||
<P>
|
||||
All MPI routines (except <TT>MPI_Wtime</TT> and <TT>MPI_Wtick</TT>) return an error value;
|
||||
All MPI routines (except <tt>MPI_Wtime</tt> and <tt>MPI_Wtick</tt>) return an error value;
|
||||
C routines as the value of the function and Fortran routines in the last
|
||||
argument. Before the value is returned, the current MPI error handler is
|
||||
called. By default, this error handler aborts the MPI job. The error handler
|
||||
may be changed with <TT>MPI_Comm_set_errhandler</TT> (for communicators),
|
||||
<TT>MPI_File_set_errhandler</TT> (for files), and <TT>MPI_Win_set_errhandler</TT> (for
|
||||
RMA windows). The MPI-1 routine <TT>MPI_Errhandler_set</TT> may be used but
|
||||
may be changed with <tt>MPI_Comm_set_errhandler</tt> (for communicators),
|
||||
<tt>MPI_File_set_errhandler</tt> (for files), and <tt>MPI_Win_set_errhandler</tt> (for
|
||||
RMA windows). The MPI-1 routine <tt>MPI_Errhandler_set</tt> may be used but
|
||||
its use is deprecated. The predefined error handler
|
||||
<TT>MPI_ERRORS_RETURN</TT> may be used to cause error values to be returned.
|
||||
Note that MPI does <EM>not</EM> guarentee that an MPI program can continue past
|
||||
<tt>MPI_ERRORS_RETURN</tt> may be used to cause error values to be returned.
|
||||
Note that MPI does <em>not</em> guarantee that an MPI program can continue past
|
||||
an error; however, MPI implementations will attempt to continue whenever
|
||||
possible.
|
||||
<P>
|
||||
<DL><DT><B>MPI_SUCCESS </B> <DD> No error; MPI routine completed successfully.
|
||||
<DL>
|
||||
<DT><B>MPI_SUCCESS </B> <DD> No error; MPI routine completed successfully.
|
||||
</DL>
|
||||
<DL><DT><B>MPI_ERR_INFO </B> <DD> Invalid Info
|
||||
<DL>
|
||||
<DT><B>MPI_ERR_ARG </B> <DD> Invalid argument. Some argument is invalid and is not
|
||||
identified by a specific error class (e.g., <tt>MPI_ERR_RANK</tt>).
|
||||
</DL>
|
||||
<DL><DT><B>MPI_ERR_ARG </B> <DD> Invalid argument. Some argument is invalid and is not
|
||||
identified by a specific error class (e.g., <TT>MPI_ERR_RANK</TT>).
|
||||
<DL>
|
||||
<DT><B>MPI_ERR_INFO </B> <DD> Invalid Info
|
||||
</DL>
|
||||
<DL><DT><B>MPI_ERR_NO_MEM </B> <DD> Insufficient memory available for allocation by
|
||||
<TT>MPI_Alloc_mem
|
||||
</TT>
|
||||
<DL>
|
||||
<DT><B>MPI_ERR_NO_MEM </B> <DD> Insufficient memory available for allocation by
|
||||
<tt>MPI_Alloc_mem
|
||||
</tt>
|
||||
</DL>
|
||||
<DL>
|
||||
<DT><B>MPI_ERR_OTHER </B> <DD> Other error; use <tt>MPI_Error_string</tt> to get more information
|
||||
about this error code.
|
||||
</DL>
|
||||
<P>
|
||||
</BODY></HTML>
|
||||
|
||||
@@ -5,89 +5,112 @@
|
||||
<TITLE>MPI_Allreduce</TITLE>
|
||||
</HEAD>
|
||||
<BODY BGCOLOR="FFFFFF">
|
||||
<A NAME="MPI_Allreduce"><H1>MPI_Allreduce</H1></A>
|
||||
<H1 id="MPI_Allreduce">MPI_Allreduce</H1>
|
||||
Combines values from all processes and distributes the result back to all processes
|
||||
<H2>Synopsis</H2>
|
||||
<PRE>
|
||||
</PRE>
|
||||
<PRE>
|
||||
int MPI_Allreduce(const void *sendbuf, void *recvbuf, int count,
|
||||
MPI_Datatype datatype, MPI_Op op, MPI_Comm comm)
|
||||
</PRE>
|
||||
|
||||
<PRE>
|
||||
int MPI_Allreduce_c(const void *sendbuf, void *recvbuf, MPI_Count count,
|
||||
MPI_Datatype datatype, MPI_Op op, MPI_Comm comm)
|
||||
</PRE>
|
||||
|
||||
<P>
|
||||
<H2>Input Parameters</H2>
|
||||
<DL>
|
||||
<DT><B>sendbuf </B><DD>starting address of send buffer (choice)
|
||||
<DT><B>sendbuf </B> <DD> starting address of send buffer (choice)
|
||||
|
||||
<DT><B>count </B><DD>number of elements in send buffer (integer)
|
||||
<DT><B>count </B> <DD> number of elements in send buffer (non-negative integer)
|
||||
|
||||
<DT><B>datatype </B><DD>data type of elements of send buffer (handle)
|
||||
<DT><B>datatype </B> <DD> data type of elements of send buffer (handle)
|
||||
|
||||
<DT><B>op </B><DD>operation (handle)
|
||||
<DT><B>op </B> <DD> operation (handle)
|
||||
|
||||
<DT><B>comm </B><DD>communicator (handle)
|
||||
<DT><B>comm </B> <DD> communicator (handle)
|
||||
</DL>
|
||||
<P>
|
||||
<H2>Output Parameters</H2>
|
||||
<DL><DT><B>recvbuf </B> <DD> starting address of receive buffer (choice)
|
||||
<DL>
|
||||
<DT><B>recvbuf </B> <DD> starting address of receive buffer (choice)
|
||||
</DL>
|
||||
<P>
|
||||
<H2>Notes on collective operations</H2>
|
||||
<P>
|
||||
The reduction functions (<tt>MPI_Op</tt>) do not return an error value. As a result,
|
||||
if the functions detect an error, all they can do is either call <tt>MPI_Abort
|
||||
</tt>or silently skip the problem. Thus, if you change the error handler from
|
||||
<tt>MPI_ERRORS_ARE_FATAL</tt> to something else, for example, <tt>MPI_ERRORS_RETURN</tt>,
|
||||
then no error may be indicated.
|
||||
<P>
|
||||
The reason for this is the performance problems in ensuring that
|
||||
all collective routines return the same error value.
|
||||
<P>
|
||||
<H2>Thread and Interrupt Safety</H2>
|
||||
<P>
|
||||
This routine is thread-safe. This means that this routine may be
|
||||
safely used by multiple threads without the need for any user-provided
|
||||
thread locks. However, the routine is not interrupt safe. Typically,
|
||||
this is due to the use of memory allocation routines such as <TT>malloc
|
||||
</TT>or other non-MPICH runtime routines that are themselves not interrupt-safe.
|
||||
this is due to the use of memory allocation routines such as <tt>malloc
|
||||
</tt>or other non-MPICH runtime routines that are themselves not interrupt-safe.
|
||||
<P>
|
||||
<H2>Notes for Fortran</H2>
|
||||
All MPI routines in Fortran (except for <TT>MPI_WTIME</TT> and <TT>MPI_WTICK</TT>) have
|
||||
an additional argument <TT>ierr</TT> at the end of the argument list. <TT>ierr
|
||||
</TT>is an integer and has the same meaning as the return value of the routine
|
||||
All MPI routines in Fortran (except for <tt>MPI_WTIME</tt> and <tt>MPI_WTICK</tt>) have
|
||||
an additional argument <tt>ierr</tt> at the end of the argument list. <tt>ierr
|
||||
</tt>is an integer and has the same meaning as the return value of the routine
|
||||
in C. In Fortran, MPI routines are subroutines, and are invoked with the
|
||||
<TT>call</TT> statement.
|
||||
<tt>call</tt> statement.
|
||||
<P>
|
||||
All MPI objects (e.g., <TT>MPI_Datatype</TT>, <TT>MPI_Comm</TT>) are of type <TT>INTEGER
|
||||
</TT>in Fortran.
|
||||
<P>
|
||||
<H2>Notes on collective operations</H2>
|
||||
<P>
|
||||
The reduction functions (<TT>MPI_Op</TT>) do not return an error value. As a result,
|
||||
if the functions detect an error, all they can do is either call <TT>MPI_Abort
|
||||
</TT>or silently skip the problem. Thus, if you change the error handler from
|
||||
<TT>MPI_ERRORS_ARE_FATAL</TT> to something else, for example, <TT>MPI_ERRORS_RETURN</TT>,
|
||||
then no error may be indicated.
|
||||
<P>
|
||||
The reason for this is the performance problems in ensuring that
|
||||
all collective routines return the same error value.
|
||||
All MPI objects (e.g., <tt>MPI_Datatype</tt>, <tt>MPI_Comm</tt>) are of type <tt>INTEGER
|
||||
</tt>in Fortran.
|
||||
<P>
|
||||
<H2>Errors</H2>
|
||||
<P>
|
||||
All MPI routines (except <TT>MPI_Wtime</TT> and <TT>MPI_Wtick</TT>) return an error value;
|
||||
All MPI routines (except <tt>MPI_Wtime</tt> and <tt>MPI_Wtick</tt>) return an error value;
|
||||
C routines as the value of the function and Fortran routines in the last
|
||||
argument. Before the value is returned, the current MPI error handler is
|
||||
called. By default, this error handler aborts the MPI job. The error handler
|
||||
may be changed with <TT>MPI_Comm_set_errhandler</TT> (for communicators),
|
||||
<TT>MPI_File_set_errhandler</TT> (for files), and <TT>MPI_Win_set_errhandler</TT> (for
|
||||
RMA windows). The MPI-1 routine <TT>MPI_Errhandler_set</TT> may be used but
|
||||
may be changed with <tt>MPI_Comm_set_errhandler</tt> (for communicators),
|
||||
<tt>MPI_File_set_errhandler</tt> (for files), and <tt>MPI_Win_set_errhandler</tt> (for
|
||||
RMA windows). The MPI-1 routine <tt>MPI_Errhandler_set</tt> may be used but
|
||||
its use is deprecated. The predefined error handler
|
||||
<TT>MPI_ERRORS_RETURN</TT> may be used to cause error values to be returned.
|
||||
Note that MPI does <EM>not</EM> guarentee that an MPI program can continue past
|
||||
<tt>MPI_ERRORS_RETURN</tt> may be used to cause error values to be returned.
|
||||
Note that MPI does <em>not</em> guarantee that an MPI program can continue past
|
||||
an error; however, MPI implementations will attempt to continue whenever
|
||||
possible.
|
||||
<P>
|
||||
<DL><DT><B>MPI_ERR_BUFFER </B> <DD> Invalid buffer pointer. Usually a null buffer where
|
||||
<DL>
|
||||
<DT><B>MPI_SUCCESS </B> <DD> No error; MPI routine completed successfully.
|
||||
</DL>
|
||||
<DL>
|
||||
<DT><B>MPI_ERR_BUFFER </B> <DD> Invalid buffer pointer. Usually a null buffer where
|
||||
one is not valid.
|
||||
</DL>
|
||||
<DL><DT><B>MPI_ERR_COUNT </B> <DD> Invalid count argument. Count arguments must be
|
||||
<DL>
|
||||
<DT><B>MPI_ERR_COMM </B> <DD> Invalid communicator. A common error is to use a null
|
||||
communicator in a call (not even allowed in <tt>MPI_Comm_rank</tt>).
|
||||
</DL>
|
||||
<DL>
|
||||
<DT><B>MPI_ERR_COUNT </B> <DD> Invalid count argument. Count arguments must be
|
||||
non-negative; a count of zero is often valid.
|
||||
</DL>
|
||||
<DL><DT><B>MPI_ERR_TYPE </B> <DD> Invalid datatype argument. Additionally, this error can
|
||||
occur if an uncommitted MPI_Datatype (see <TT>MPI_Type_commit</TT>) is used
|
||||
<DL>
|
||||
<DT><B>MPI_ERR_OP </B> <DD> Invalid operation. MPI operations (objects of type <tt>MPI_Op</tt>)
|
||||
must either be one of the predefined operations (e.g., <tt>MPI_SUM</tt>) or
|
||||
created with <tt>MPI_Op_create</tt>.
|
||||
</DL>
|
||||
<DL>
|
||||
<DT><B>MPI_ERR_TYPE </B> <DD> Invalid datatype argument. Additionally, this error can
|
||||
occur if an uncommitted MPI_Datatype (see <tt>MPI_Type_commit</tt>) is used
|
||||
in a communication call.
|
||||
</DL>
|
||||
<DL><DT><B>MPI_ERR_OP </B> <DD> Invalid operation. MPI operations (objects of type <TT>MPI_Op</TT>)
|
||||
must either be one of the predefined operations (e.g., <TT>MPI_SUM</TT>) or
|
||||
created with <TT>MPI_Op_create</TT>.
|
||||
</DL>
|
||||
<DL><DT><B>MPI_ERR_COMM </B> <DD> Invalid communicator. A common error is to use a null
|
||||
communicator in a call (not even allowed in <TT>MPI_Comm_rank</TT>).
|
||||
<DL>
|
||||
<DT><B>MPI_ERR_OTHER </B> <DD> Other error; use <tt>MPI_Error_string</tt> to get more information
|
||||
about this error code.
|
||||
</DL>
|
||||
<P>
|
||||
</BODY></HTML>
|
||||
|
||||
@@ -0,0 +1 @@
|
||||
<meta http-equiv="refresh" content="0; url=MPI_Allreduce.html">
|
||||
118
macx64/mpi/mpich/share/doc/mpich/www3/MPI_Allreduce_init.html
Normal file
118
macx64/mpi/mpich/share/doc/mpich/www3/MPI_Allreduce_init.html
Normal file
@@ -0,0 +1,118 @@
|
||||
<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML3.2 EN">
|
||||
<HTML>
|
||||
<HEAD>
|
||||
<META NAME="GENERATOR" CONTENT="DOCTEXT">
|
||||
<TITLE>MPI_Allreduce_init</TITLE>
|
||||
</HEAD>
|
||||
<BODY BGCOLOR="FFFFFF">
|
||||
<H1 id="MPI_Allreduce_init">MPI_Allreduce_init</H1>
|
||||
Create a persistent request for allreduce
|
||||
<H2>Synopsis</H2>
|
||||
<PRE>
|
||||
</PRE>
|
||||
<PRE>
|
||||
int MPI_Allreduce_init(const void *sendbuf, void *recvbuf, int count,
|
||||
MPI_Datatype datatype, MPI_Op op, MPI_Comm comm,
|
||||
MPI_Info info, MPI_Request *request)
|
||||
</PRE>
|
||||
|
||||
<PRE>
|
||||
int MPI_Allreduce_init_c(const void *sendbuf, void *recvbuf, MPI_Count count,
|
||||
MPI_Datatype datatype, MPI_Op op, MPI_Comm comm,
|
||||
MPI_Info info, MPI_Request *request)
|
||||
</PRE>
|
||||
|
||||
<P>
|
||||
<H2>Input Parameters</H2>
|
||||
<DL>
|
||||
<DT><B>sendbuf </B> <DD> starting address of send buffer (choice)
|
||||
|
||||
<DT><B>count </B> <DD> number of elements in send buffer (non-negative integer)
|
||||
|
||||
<DT><B>datatype </B> <DD> data type of elements of send buffer (handle)
|
||||
|
||||
<DT><B>op </B> <DD> operation (handle)
|
||||
|
||||
<DT><B>comm </B> <DD> communicator (handle)
|
||||
|
||||
<DT><B>info </B> <DD> info argument (handle)
|
||||
</DL>
|
||||
<P>
|
||||
<H2>Output Parameters</H2>
|
||||
<DL>
|
||||
<DT><B>recvbuf </B> <DD> starting address of receive buffer (choice)
|
||||
|
||||
<DT><B>request </B> <DD> communication request (handle)
|
||||
</DL>
|
||||
<P>
|
||||
<H2>Thread and Interrupt Safety</H2>
|
||||
<P>
|
||||
This routine is thread-safe. This means that this routine may be
|
||||
safely used by multiple threads without the need for any user-provided
|
||||
thread locks. However, the routine is not interrupt safe. Typically,
|
||||
this is due to the use of memory allocation routines such as <tt>malloc
|
||||
</tt>or other non-MPICH runtime routines that are themselves not interrupt-safe.
|
||||
<P>
|
||||
<H2>Notes for Fortran</H2>
|
||||
All MPI routines in Fortran (except for <tt>MPI_WTIME</tt> and <tt>MPI_WTICK</tt>) have
|
||||
an additional argument <tt>ierr</tt> at the end of the argument list. <tt>ierr
|
||||
</tt>is an integer and has the same meaning as the return value of the routine
|
||||
in C. In Fortran, MPI routines are subroutines, and are invoked with the
|
||||
<tt>call</tt> statement.
|
||||
<P>
|
||||
All MPI objects (e.g., <tt>MPI_Datatype</tt>, <tt>MPI_Comm</tt>) are of type <tt>INTEGER
|
||||
</tt>in Fortran.
|
||||
<P>
|
||||
<H2>Errors</H2>
|
||||
<P>
|
||||
All MPI routines (except <tt>MPI_Wtime</tt> and <tt>MPI_Wtick</tt>) return an error value;
|
||||
C routines as the value of the function and Fortran routines in the last
|
||||
argument. Before the value is returned, the current MPI error handler is
|
||||
called. By default, this error handler aborts the MPI job. The error handler
|
||||
may be changed with <tt>MPI_Comm_set_errhandler</tt> (for communicators),
|
||||
<tt>MPI_File_set_errhandler</tt> (for files), and <tt>MPI_Win_set_errhandler</tt> (for
|
||||
RMA windows). The MPI-1 routine <tt>MPI_Errhandler_set</tt> may be used but
|
||||
its use is deprecated. The predefined error handler
|
||||
<tt>MPI_ERRORS_RETURN</tt> may be used to cause error values to be returned.
|
||||
Note that MPI does <em>not</em> guarantee that an MPI program can continue past
|
||||
an error; however, MPI implementations will attempt to continue whenever
|
||||
possible.
|
||||
<P>
|
||||
<DL>
|
||||
<DT><B>MPI_SUCCESS </B> <DD> No error; MPI routine completed successfully.
|
||||
</DL>
|
||||
<DL>
|
||||
<DT><B>MPI_ERR_ARG </B> <DD> Invalid argument. Some argument is invalid and is not
|
||||
identified by a specific error class (e.g., <tt>MPI_ERR_RANK</tt>).
|
||||
</DL>
|
||||
<DL>
|
||||
<DT><B>MPI_ERR_BUFFER </B> <DD> Invalid buffer pointer. Usually a null buffer where
|
||||
one is not valid.
|
||||
</DL>
|
||||
<DL>
|
||||
<DT><B>MPI_ERR_COMM </B> <DD> Invalid communicator. A common error is to use a null
|
||||
communicator in a call (not even allowed in <tt>MPI_Comm_rank</tt>).
|
||||
</DL>
|
||||
<DL>
|
||||
<DT><B>MPI_ERR_COUNT </B> <DD> Invalid count argument. Count arguments must be
|
||||
non-negative; a count of zero is often valid.
|
||||
</DL>
|
||||
<DL>
|
||||
<DT><B>MPI_ERR_INFO </B> <DD> Invalid Info
|
||||
</DL>
|
||||
<DL>
|
||||
<DT><B>MPI_ERR_OP </B> <DD> Invalid operation. MPI operations (objects of type <tt>MPI_Op</tt>)
|
||||
must either be one of the predefined operations (e.g., <tt>MPI_SUM</tt>) or
|
||||
created with <tt>MPI_Op_create</tt>.
|
||||
</DL>
|
||||
<DL>
|
||||
<DT><B>MPI_ERR_TYPE </B> <DD> Invalid datatype argument. Additionally, this error can
|
||||
occur if an uncommitted MPI_Datatype (see <tt>MPI_Type_commit</tt>) is used
|
||||
in a communication call.
|
||||
</DL>
|
||||
<DL>
|
||||
<DT><B>MPI_ERR_OTHER </B> <DD> Other error; use <tt>MPI_Error_string</tt> to get more information
|
||||
about this error code.
|
||||
</DL>
|
||||
<P>
|
||||
</BODY></HTML>
|
||||
@@ -0,0 +1 @@
|
||||
<meta http-equiv="refresh" content="0; url=MPI_Allreduce_init.html">
|
||||
@@ -5,30 +5,42 @@
|
||||
<TITLE>MPI_Alltoall</TITLE>
|
||||
</HEAD>
|
||||
<BODY BGCOLOR="FFFFFF">
|
||||
<A NAME="MPI_Alltoall"><H1>MPI_Alltoall</H1></A>
|
||||
<H1 id="MPI_Alltoall">MPI_Alltoall</H1>
|
||||
Sends data from all to all processes
|
||||
<H2>Synopsis</H2>
|
||||
<PRE>
|
||||
int MPI_Alltoall(const void *sendbuf, int sendcount, MPI_Datatype sendtype,
|
||||
void *recvbuf, int recvcount, MPI_Datatype recvtype, MPI_Comm comm)
|
||||
</PRE>
|
||||
<PRE>
|
||||
int MPI_Alltoall(const void *sendbuf, int sendcount, MPI_Datatype sendtype,
|
||||
void *recvbuf, int recvcount, MPI_Datatype recvtype,
|
||||
MPI_Comm comm)
|
||||
</PRE>
|
||||
|
||||
<PRE>
|
||||
int MPI_Alltoall_c(const void *sendbuf, MPI_Count sendcount,
|
||||
MPI_Datatype sendtype, void *recvbuf, MPI_Count recvcount,
|
||||
MPI_Datatype recvtype, MPI_Comm comm)
|
||||
</PRE>
|
||||
|
||||
<P>
|
||||
<H2>Input Parameters</H2>
|
||||
<DL>
|
||||
<DT><B>sendbuf </B><DD>starting address of send buffer (choice)
|
||||
<DT><B>sendbuf </B> <DD> starting address of send buffer (choice)
|
||||
|
||||
<DT><B>sendcount </B><DD>number of elements to send to each process (integer)
|
||||
<DT><B>sendcount </B> <DD> number of elements sent to each process (non-negative integer)
|
||||
|
||||
<DT><B>sendtype </B><DD>data type of send buffer elements (handle)
|
||||
<DT><B>sendtype </B> <DD> data type of send buffer elements (handle)
|
||||
|
||||
<DT><B>recvcount </B><DD>number of elements received from any process (integer)
|
||||
<DT><B>recvcount </B> <DD> number of elements received from any process (non-negative integer)
|
||||
|
||||
<DT><B>recvtype </B><DD>data type of receive buffer elements (handle)
|
||||
<DT><B>recvtype </B> <DD> data type of receive buffer elements (handle)
|
||||
|
||||
<DT><B>comm </B><DD>communicator (handle)
|
||||
<DT><B>comm </B> <DD> communicator (handle)
|
||||
</DL>
|
||||
<P>
|
||||
<H2>Output Parameters</H2>
|
||||
<DL><DT><B>recvbuf </B> <DD> address of receive buffer (choice)
|
||||
<DL>
|
||||
<DT><B>recvbuf </B> <DD> address of receive buffer (choice)
|
||||
</DL>
|
||||
<P>
|
||||
<H2>Thread and Interrupt Safety</H2>
|
||||
@@ -36,45 +48,57 @@ int MPI_Alltoall(const void *sendbuf, int sendcount, MPI_Datatype sendtype,
|
||||
This routine is thread-safe. This means that this routine may be
|
||||
safely used by multiple threads without the need for any user-provided
|
||||
thread locks. However, the routine is not interrupt safe. Typically,
|
||||
this is due to the use of memory allocation routines such as <TT>malloc
|
||||
</TT>or other non-MPICH runtime routines that are themselves not interrupt-safe.
|
||||
this is due to the use of memory allocation routines such as <tt>malloc
|
||||
</tt>or other non-MPICH runtime routines that are themselves not interrupt-safe.
|
||||
<P>
|
||||
<H2>Notes for Fortran</H2>
|
||||
All MPI routines in Fortran (except for <TT>MPI_WTIME</TT> and <TT>MPI_WTICK</TT>) have
|
||||
an additional argument <TT>ierr</TT> at the end of the argument list. <TT>ierr
|
||||
</TT>is an integer and has the same meaning as the return value of the routine
|
||||
All MPI routines in Fortran (except for <tt>MPI_WTIME</tt> and <tt>MPI_WTICK</tt>) have
|
||||
an additional argument <tt>ierr</tt> at the end of the argument list. <tt>ierr
|
||||
</tt>is an integer and has the same meaning as the return value of the routine
|
||||
in C. In Fortran, MPI routines are subroutines, and are invoked with the
|
||||
<TT>call</TT> statement.
|
||||
<tt>call</tt> statement.
|
||||
<P>
|
||||
All MPI objects (e.g., <TT>MPI_Datatype</TT>, <TT>MPI_Comm</TT>) are of type <TT>INTEGER
|
||||
</TT>in Fortran.
|
||||
All MPI objects (e.g., <tt>MPI_Datatype</tt>, <tt>MPI_Comm</tt>) are of type <tt>INTEGER
|
||||
</tt>in Fortran.
|
||||
<P>
|
||||
<H2>Errors</H2>
|
||||
<P>
|
||||
All MPI routines (except <TT>MPI_Wtime</TT> and <TT>MPI_Wtick</TT>) return an error value;
|
||||
All MPI routines (except <tt>MPI_Wtime</tt> and <tt>MPI_Wtick</tt>) return an error value;
|
||||
C routines as the value of the function and Fortran routines in the last
|
||||
argument. Before the value is returned, the current MPI error handler is
|
||||
called. By default, this error handler aborts the MPI job. The error handler
|
||||
may be changed with <TT>MPI_Comm_set_errhandler</TT> (for communicators),
|
||||
<TT>MPI_File_set_errhandler</TT> (for files), and <TT>MPI_Win_set_errhandler</TT> (for
|
||||
RMA windows). The MPI-1 routine <TT>MPI_Errhandler_set</TT> may be used but
|
||||
may be changed with <tt>MPI_Comm_set_errhandler</tt> (for communicators),
|
||||
<tt>MPI_File_set_errhandler</tt> (for files), and <tt>MPI_Win_set_errhandler</tt> (for
|
||||
RMA windows). The MPI-1 routine <tt>MPI_Errhandler_set</tt> may be used but
|
||||
its use is deprecated. The predefined error handler
|
||||
<TT>MPI_ERRORS_RETURN</TT> may be used to cause error values to be returned.
|
||||
Note that MPI does <EM>not</EM> guarentee that an MPI program can continue past
|
||||
<tt>MPI_ERRORS_RETURN</tt> may be used to cause error values to be returned.
|
||||
Note that MPI does <em>not</em> guarantee that an MPI program can continue past
|
||||
an error; however, MPI implementations will attempt to continue whenever
|
||||
possible.
|
||||
<P>
|
||||
<DL><DT><B>MPI_ERR_COMM </B> <DD> Invalid communicator. A common error is to use a null
|
||||
communicator in a call (not even allowed in <TT>MPI_Comm_rank</TT>).
|
||||
<DL>
|
||||
<DT><B>MPI_SUCCESS </B> <DD> No error; MPI routine completed successfully.
|
||||
</DL>
|
||||
<DL><DT><B>MPI_ERR_COUNT </B> <DD> Invalid count argument. Count arguments must be
|
||||
non-negative; a count of zero is often valid.
|
||||
</DL>
|
||||
<DL><DT><B>MPI_ERR_TYPE </B> <DD> Invalid datatype argument. Additionally, this error can
|
||||
occur if an uncommitted MPI_Datatype (see <TT>MPI_Type_commit</TT>) is used
|
||||
in a communication call.
|
||||
</DL>
|
||||
<DL><DT><B>MPI_ERR_BUFFER </B> <DD> Invalid buffer pointer. Usually a null buffer where
|
||||
<DL>
|
||||
<DT><B>MPI_ERR_BUFFER </B> <DD> Invalid buffer pointer. Usually a null buffer where
|
||||
one is not valid.
|
||||
</DL>
|
||||
<DL>
|
||||
<DT><B>MPI_ERR_COMM </B> <DD> Invalid communicator. A common error is to use a null
|
||||
communicator in a call (not even allowed in <tt>MPI_Comm_rank</tt>).
|
||||
</DL>
|
||||
<DL>
|
||||
<DT><B>MPI_ERR_COUNT </B> <DD> Invalid count argument. Count arguments must be
|
||||
non-negative; a count of zero is often valid.
|
||||
</DL>
|
||||
<DL>
|
||||
<DT><B>MPI_ERR_TYPE </B> <DD> Invalid datatype argument. Additionally, this error can
|
||||
occur if an uncommitted MPI_Datatype (see <tt>MPI_Type_commit</tt>) is used
|
||||
in a communication call.
|
||||
</DL>
|
||||
<DL>
|
||||
<DT><B>MPI_ERR_OTHER </B> <DD> Other error; use <tt>MPI_Error_string</tt> to get more information
|
||||
about this error code.
|
||||
</DL>
|
||||
<P>
|
||||
</BODY></HTML>
|
||||
|
||||
@@ -0,0 +1 @@
|
||||
<meta http-equiv="refresh" content="0; url=MPI_Alltoall.html">
|
||||
116
macx64/mpi/mpich/share/doc/mpich/www3/MPI_Alltoall_init.html
Normal file
116
macx64/mpi/mpich/share/doc/mpich/www3/MPI_Alltoall_init.html
Normal file
@@ -0,0 +1,116 @@
|
||||
<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML3.2 EN">
|
||||
<HTML>
|
||||
<HEAD>
|
||||
<META NAME="GENERATOR" CONTENT="DOCTEXT">
|
||||
<TITLE>MPI_Alltoall_init</TITLE>
|
||||
</HEAD>
|
||||
<BODY BGCOLOR="FFFFFF">
|
||||
<H1 id="MPI_Alltoall_init">MPI_Alltoall_init</H1>
|
||||
Create a persistent request for alltoall.
|
||||
<H2>Synopsis</H2>
|
||||
<PRE>
|
||||
</PRE>
|
||||
<PRE>
|
||||
int MPI_Alltoall_init(const void *sendbuf, int sendcount, MPI_Datatype sendtype,
|
||||
void *recvbuf, int recvcount, MPI_Datatype recvtype,
|
||||
MPI_Comm comm, MPI_Info info, MPI_Request *request)
|
||||
</PRE>
|
||||
|
||||
<PRE>
|
||||
int MPI_Alltoall_init_c(const void *sendbuf, MPI_Count sendcount,
|
||||
MPI_Datatype sendtype, void *recvbuf,
|
||||
MPI_Count recvcount, MPI_Datatype recvtype,
|
||||
MPI_Comm comm, MPI_Info info, MPI_Request *request)
|
||||
</PRE>
|
||||
|
||||
<P>
|
||||
<H2>Input Parameters</H2>
|
||||
<DL>
|
||||
<DT><B>sendbuf </B> <DD> starting address of send buffer (choice)
|
||||
|
||||
<DT><B>sendcount </B> <DD> number of elements sent to each process (non-negative integer)
|
||||
|
||||
<DT><B>sendtype </B> <DD> data type of send buffer elements (handle)
|
||||
|
||||
<DT><B>recvcount </B> <DD> number of elements received from any process (non-negative integer)
|
||||
|
||||
<DT><B>recvtype </B> <DD> data type of receive buffer elements (handle)
|
||||
|
||||
<DT><B>comm </B> <DD> communicator (handle)
|
||||
|
||||
<DT><B>info </B> <DD> info argument (handle)
|
||||
</DL>
|
||||
<P>
|
||||
<H2>Output Parameters</H2>
|
||||
<DL>
|
||||
<DT><B>recvbuf </B> <DD> address of receive buffer (choice)
|
||||
|
||||
<DT><B>request </B> <DD> communication request (handle)
|
||||
</DL>
|
||||
<P>
|
||||
<H2>Thread and Interrupt Safety</H2>
|
||||
<P>
|
||||
This routine is thread-safe. This means that this routine may be
|
||||
safely used by multiple threads without the need for any user-provided
|
||||
thread locks. However, the routine is not interrupt safe. Typically,
|
||||
this is due to the use of memory allocation routines such as <tt>malloc
|
||||
</tt>or other non-MPICH runtime routines that are themselves not interrupt-safe.
|
||||
<P>
|
||||
<H2>Notes for Fortran</H2>
|
||||
All MPI routines in Fortran (except for <tt>MPI_WTIME</tt> and <tt>MPI_WTICK</tt>) have
|
||||
an additional argument <tt>ierr</tt> at the end of the argument list. <tt>ierr
|
||||
</tt>is an integer and has the same meaning as the return value of the routine
|
||||
in C. In Fortran, MPI routines are subroutines, and are invoked with the
|
||||
<tt>call</tt> statement.
|
||||
<P>
|
||||
All MPI objects (e.g., <tt>MPI_Datatype</tt>, <tt>MPI_Comm</tt>) are of type <tt>INTEGER
|
||||
</tt>in Fortran.
|
||||
<P>
|
||||
<H2>Errors</H2>
|
||||
<P>
|
||||
All MPI routines (except <tt>MPI_Wtime</tt> and <tt>MPI_Wtick</tt>) return an error value;
|
||||
C routines as the value of the function and Fortran routines in the last
|
||||
argument. Before the value is returned, the current MPI error handler is
|
||||
called. By default, this error handler aborts the MPI job. The error handler
|
||||
may be changed with <tt>MPI_Comm_set_errhandler</tt> (for communicators),
|
||||
<tt>MPI_File_set_errhandler</tt> (for files), and <tt>MPI_Win_set_errhandler</tt> (for
|
||||
RMA windows). The MPI-1 routine <tt>MPI_Errhandler_set</tt> may be used but
|
||||
its use is deprecated. The predefined error handler
|
||||
<tt>MPI_ERRORS_RETURN</tt> may be used to cause error values to be returned.
|
||||
Note that MPI does <em>not</em> guarantee that an MPI program can continue past
|
||||
an error; however, MPI implementations will attempt to continue whenever
|
||||
possible.
|
||||
<P>
|
||||
<DL>
|
||||
<DT><B>MPI_SUCCESS </B> <DD> No error; MPI routine completed successfully.
|
||||
</DL>
|
||||
<DL>
|
||||
<DT><B>MPI_ERR_ARG </B> <DD> Invalid argument. Some argument is invalid and is not
|
||||
identified by a specific error class (e.g., <tt>MPI_ERR_RANK</tt>).
|
||||
</DL>
|
||||
<DL>
|
||||
<DT><B>MPI_ERR_BUFFER </B> <DD> Invalid buffer pointer. Usually a null buffer where
|
||||
one is not valid.
|
||||
</DL>
|
||||
<DL>
|
||||
<DT><B>MPI_ERR_COMM </B> <DD> Invalid communicator. A common error is to use a null
|
||||
communicator in a call (not even allowed in <tt>MPI_Comm_rank</tt>).
|
||||
</DL>
|
||||
<DL>
|
||||
<DT><B>MPI_ERR_COUNT </B> <DD> Invalid count argument. Count arguments must be
|
||||
non-negative; a count of zero is often valid.
|
||||
</DL>
|
||||
<DL>
|
||||
<DT><B>MPI_ERR_INFO </B> <DD> Invalid Info
|
||||
</DL>
|
||||
<DL>
|
||||
<DT><B>MPI_ERR_TYPE </B> <DD> Invalid datatype argument. Additionally, this error can
|
||||
occur if an uncommitted MPI_Datatype (see <tt>MPI_Type_commit</tt>) is used
|
||||
in a communication call.
|
||||
</DL>
|
||||
<DL>
|
||||
<DT><B>MPI_ERR_OTHER </B> <DD> Other error; use <tt>MPI_Error_string</tt> to get more information
|
||||
about this error code.
|
||||
</DL>
|
||||
<P>
|
||||
</BODY></HTML>
|
||||
@@ -0,0 +1 @@
|
||||
<meta http-equiv="refresh" content="0; url=MPI_Alltoall_init.html">
|
||||
@@ -5,42 +5,49 @@
|
||||
<TITLE>MPI_Alltoallv</TITLE>
|
||||
</HEAD>
|
||||
<BODY BGCOLOR="FFFFFF">
|
||||
<A NAME="MPI_Alltoallv"><H1>MPI_Alltoallv</H1></A>
|
||||
<H1 id="MPI_Alltoallv">MPI_Alltoallv</H1>
|
||||
Sends data from all to all processes; each process may send a different amount of data and provide displacements for the input and output data.
|
||||
<H2>Synopsis</H2>
|
||||
<PRE>
|
||||
int MPI_Alltoallv(const void *sendbuf, const int *sendcounts,
|
||||
const int *sdispls, MPI_Datatype sendtype, void *recvbuf,
|
||||
const int *recvcounts, const int *rdispls, MPI_Datatype recvtype, MPI_Comm comm)
|
||||
</PRE>
|
||||
<PRE>
|
||||
int MPI_Alltoallv(const void *sendbuf, const int sendcounts[],
|
||||
const int sdispls[], MPI_Datatype sendtype, void *recvbuf,
|
||||
const int recvcounts[], const int rdispls[],
|
||||
MPI_Datatype recvtype, MPI_Comm comm)
|
||||
</PRE>
|
||||
|
||||
<PRE>
|
||||
int MPI_Alltoallv_c(const void *sendbuf, const MPI_Count sendcounts[],
|
||||
const MPI_Aint sdispls[], MPI_Datatype sendtype,
|
||||
void *recvbuf, const MPI_Count recvcounts[],
|
||||
const MPI_Aint rdispls[], MPI_Datatype recvtype,
|
||||
MPI_Comm comm)
|
||||
</PRE>
|
||||
|
||||
<P>
|
||||
<H2>Input Parameters</H2>
|
||||
<DL>
|
||||
<DT><B>sendbuf </B><DD>starting address of send buffer (choice)
|
||||
<DT><B>sendbuf </B> <DD> starting address of send buffer (choice)
|
||||
|
||||
<DT><B>sendcounts </B><DD>integer array equal to the group size
|
||||
specifying the number of elements to send to each processor
|
||||
<DT><B>sendcounts </B> <DD> non-negative integer array (of length group size) specifying the number of elements to send to each rank (non-negative integer)
|
||||
|
||||
<DT><B>sdispls </B><DD>integer array (of length group size). Entry
|
||||
<TT>j</TT> specifies the displacement (relative to sendbuf from
|
||||
which to take the outgoing data destined for process <TT>j
|
||||
</TT>
|
||||
<DT><B>sendtype </B><DD>data type of send buffer elements (handle)
|
||||
<DT><B>sdispls </B> <DD> integer array (of length group size). Entry j specifies the displacement (relative to sendbuf) from which to take the outgoing data destined for process j (integer)
|
||||
|
||||
<DT><B>recvcounts </B><DD>integer array equal to the group size
|
||||
specifying the maximum number of elements that can be received from
|
||||
each processor
|
||||
<DT><B>sendtype </B> <DD> data type of send buffer elements (handle)
|
||||
|
||||
<DT><B>rdispls </B><DD>integer array (of length group size). Entry
|
||||
<TT>i</TT> specifies the displacement (relative to recvbuf at
|
||||
which to place the incoming data from process <TT>i
|
||||
</TT>
|
||||
<DT><B>recvtype </B><DD>data type of receive buffer elements (handle)
|
||||
<DT><B>recvcounts </B> <DD> non-negative integer array (of length group size) specifying the number of elements that can be received from each rank (non-negative integer)
|
||||
|
||||
<DT><B>comm </B><DD>communicator (handle)
|
||||
<DT><B>rdispls </B> <DD> integer array (of length group size). Entry i specifies the displacement (relative to recvbuf) at which to place the incoming data from process i (integer)
|
||||
|
||||
<DT><B>recvtype </B> <DD> data type of receive buffer elements (handle)
|
||||
|
||||
<DT><B>comm </B> <DD> communicator (handle)
|
||||
</DL>
|
||||
<P>
|
||||
<H2>Output Parameters</H2>
|
||||
<DL><DT><B>recvbuf </B> <DD> address of receive buffer (choice)
|
||||
<DL>
|
||||
<DT><B>recvbuf </B> <DD> address of receive buffer (choice)
|
||||
</DL>
|
||||
<P>
|
||||
<H2>Thread and Interrupt Safety</H2>
|
||||
@@ -48,45 +55,57 @@ which to place the incoming data from process <TT>i
|
||||
This routine is thread-safe. This means that this routine may be
|
||||
safely used by multiple threads without the need for any user-provided
|
||||
thread locks. However, the routine is not interrupt safe. Typically,
|
||||
this is due to the use of memory allocation routines such as <TT>malloc
|
||||
</TT>or other non-MPICH runtime routines that are themselves not interrupt-safe.
|
||||
this is due to the use of memory allocation routines such as <tt>malloc
|
||||
</tt>or other non-MPICH runtime routines that are themselves not interrupt-safe.
|
||||
<P>
|
||||
<H2>Notes for Fortran</H2>
|
||||
All MPI routines in Fortran (except for <TT>MPI_WTIME</TT> and <TT>MPI_WTICK</TT>) have
|
||||
an additional argument <TT>ierr</TT> at the end of the argument list. <TT>ierr
|
||||
</TT>is an integer and has the same meaning as the return value of the routine
|
||||
All MPI routines in Fortran (except for <tt>MPI_WTIME</tt> and <tt>MPI_WTICK</tt>) have
|
||||
an additional argument <tt>ierr</tt> at the end of the argument list. <tt>ierr
|
||||
</tt>is an integer and has the same meaning as the return value of the routine
|
||||
in C. In Fortran, MPI routines are subroutines, and are invoked with the
|
||||
<TT>call</TT> statement.
|
||||
<tt>call</tt> statement.
|
||||
<P>
|
||||
All MPI objects (e.g., <TT>MPI_Datatype</TT>, <TT>MPI_Comm</TT>) are of type <TT>INTEGER
|
||||
</TT>in Fortran.
|
||||
All MPI objects (e.g., <tt>MPI_Datatype</tt>, <tt>MPI_Comm</tt>) are of type <tt>INTEGER
|
||||
</tt>in Fortran.
|
||||
<P>
|
||||
<H2>Errors</H2>
|
||||
<P>
|
||||
All MPI routines (except <TT>MPI_Wtime</TT> and <TT>MPI_Wtick</TT>) return an error value;
|
||||
All MPI routines (except <tt>MPI_Wtime</tt> and <tt>MPI_Wtick</tt>) return an error value;
|
||||
C routines as the value of the function and Fortran routines in the last
|
||||
argument. Before the value is returned, the current MPI error handler is
|
||||
called. By default, this error handler aborts the MPI job. The error handler
|
||||
may be changed with <TT>MPI_Comm_set_errhandler</TT> (for communicators),
|
||||
<TT>MPI_File_set_errhandler</TT> (for files), and <TT>MPI_Win_set_errhandler</TT> (for
|
||||
RMA windows). The MPI-1 routine <TT>MPI_Errhandler_set</TT> may be used but
|
||||
may be changed with <tt>MPI_Comm_set_errhandler</tt> (for communicators),
|
||||
<tt>MPI_File_set_errhandler</tt> (for files), and <tt>MPI_Win_set_errhandler</tt> (for
|
||||
RMA windows). The MPI-1 routine <tt>MPI_Errhandler_set</tt> may be used but
|
||||
its use is deprecated. The predefined error handler
|
||||
<TT>MPI_ERRORS_RETURN</TT> may be used to cause error values to be returned.
|
||||
Note that MPI does <EM>not</EM> guarentee that an MPI program can continue past
|
||||
<tt>MPI_ERRORS_RETURN</tt> may be used to cause error values to be returned.
|
||||
Note that MPI does <em>not</em> guarantee that an MPI program can continue past
|
||||
an error; however, MPI implementations will attempt to continue whenever
|
||||
possible.
|
||||
<P>
|
||||
<DL><DT><B>MPI_ERR_COMM </B> <DD> Invalid communicator. A common error is to use a null
|
||||
communicator in a call (not even allowed in <TT>MPI_Comm_rank</TT>).
|
||||
<DL>
|
||||
<DT><B>MPI_SUCCESS </B> <DD> No error; MPI routine completed successfully.
|
||||
</DL>
|
||||
<DL><DT><B>MPI_ERR_COUNT </B> <DD> Invalid count argument. Count arguments must be
|
||||
non-negative; a count of zero is often valid.
|
||||
</DL>
|
||||
<DL><DT><B>MPI_ERR_TYPE </B> <DD> Invalid datatype argument. Additionally, this error can
|
||||
occur if an uncommitted MPI_Datatype (see <TT>MPI_Type_commit</TT>) is used
|
||||
in a communication call.
|
||||
</DL>
|
||||
<DL><DT><B>MPI_ERR_BUFFER </B> <DD> Invalid buffer pointer. Usually a null buffer where
|
||||
<DL>
|
||||
<DT><B>MPI_ERR_BUFFER </B> <DD> Invalid buffer pointer. Usually a null buffer where
|
||||
one is not valid.
|
||||
</DL>
|
||||
<DL>
|
||||
<DT><B>MPI_ERR_COMM </B> <DD> Invalid communicator. A common error is to use a null
|
||||
communicator in a call (not even allowed in <tt>MPI_Comm_rank</tt>).
|
||||
</DL>
|
||||
<DL>
|
||||
<DT><B>MPI_ERR_COUNT </B> <DD> Invalid count argument. Count arguments must be
|
||||
non-negative; a count of zero is often valid.
|
||||
</DL>
|
||||
<DL>
|
||||
<DT><B>MPI_ERR_TYPE </B> <DD> Invalid datatype argument. Additionally, this error can
|
||||
occur if an uncommitted MPI_Datatype (see <tt>MPI_Type_commit</tt>) is used
|
||||
in a communication call.
|
||||
</DL>
|
||||
<DL>
|
||||
<DT><B>MPI_ERR_OTHER </B> <DD> Other error; use <tt>MPI_Error_string</tt> to get more information
|
||||
about this error code.
|
||||
</DL>
|
||||
<P>
|
||||
</BODY></HTML>
|
||||
|
||||
@@ -0,0 +1 @@
|
||||
<meta http-equiv="refresh" content="0; url=MPI_Alltoallv.html">
|
||||
123
macx64/mpi/mpich/share/doc/mpich/www3/MPI_Alltoallv_init.html
Normal file
123
macx64/mpi/mpich/share/doc/mpich/www3/MPI_Alltoallv_init.html
Normal file
@@ -0,0 +1,123 @@
|
||||
<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML3.2 EN">
|
||||
<HTML>
|
||||
<HEAD>
|
||||
<META NAME="GENERATOR" CONTENT="DOCTEXT">
|
||||
<TITLE>MPI_Alltoallv_init</TITLE>
|
||||
</HEAD>
|
||||
<BODY BGCOLOR="FFFFFF">
|
||||
<H1 id="MPI_Alltoallv_init">MPI_Alltoallv_init</H1>
|
||||
Create a persistent request for alltoallv.
|
||||
<H2>Synopsis</H2>
|
||||
<PRE>
|
||||
</PRE>
|
||||
<PRE>
|
||||
int MPI_Alltoallv_init(const void *sendbuf, const int sendcounts[],
|
||||
const int sdispls[], MPI_Datatype sendtype,
|
||||
void *recvbuf, const int recvcounts[],
|
||||
const int rdispls[], MPI_Datatype recvtype,
|
||||
MPI_Comm comm, MPI_Info info, MPI_Request *request)
|
||||
</PRE>
|
||||
|
||||
<PRE>
|
||||
int MPI_Alltoallv_init_c(const void *sendbuf, const MPI_Count sendcounts[],
|
||||
const MPI_Aint sdispls[], MPI_Datatype sendtype,
|
||||
void *recvbuf, const MPI_Count recvcounts[],
|
||||
const MPI_Aint rdispls[], MPI_Datatype recvtype,
|
||||
MPI_Comm comm, MPI_Info info, MPI_Request *request)
|
||||
</PRE>
|
||||
|
||||
<P>
|
||||
<H2>Input Parameters</H2>
|
||||
<DL>
|
||||
<DT><B>sendbuf </B> <DD> starting address of send buffer (choice)
|
||||
|
||||
<DT><B>sendcounts </B> <DD> non-negative integer array (of length group size) specifying the number of elements to send to each rank (non-negative integer)
|
||||
|
||||
<DT><B>sdispls </B> <DD> Integer array (of length group size). Entry j specifies the displacement (relative to sendbuf) from which to take the outgoing data destined for process j (integer)
|
||||
|
||||
<DT><B>sendtype </B> <DD> data type of send buffer elements (handle)
|
||||
|
||||
<DT><B>recvcounts </B> <DD> non-negative integer array (of length group size) specifying the number of elements that can be received from each rank (non-negative integer)
|
||||
|
||||
<DT><B>rdispls </B> <DD> integer array (of length group size). Entry i specifies the displacement (relative to recvbuf) at which to place the incoming data from process i (integer)
|
||||
|
||||
<DT><B>recvtype </B> <DD> data type of receive buffer elements (handle)
|
||||
|
||||
<DT><B>comm </B> <DD> communicator (handle)
|
||||
|
||||
<DT><B>info </B> <DD> info argument (handle)
|
||||
</DL>
|
||||
<P>
|
||||
<H2>Output Parameters</H2>
|
||||
<DL>
|
||||
<DT><B>recvbuf </B> <DD> address of receive buffer (choice)
|
||||
|
||||
<DT><B>request </B> <DD> communication request (handle)
|
||||
</DL>
|
||||
<P>
|
||||
<H2>Thread and Interrupt Safety</H2>
|
||||
<P>
|
||||
This routine is thread-safe. This means that this routine may be
|
||||
safely used by multiple threads without the need for any user-provided
|
||||
thread locks. However, the routine is not interrupt safe. Typically,
|
||||
this is due to the use of memory allocation routines such as <tt>malloc
|
||||
</tt>or other non-MPICH runtime routines that are themselves not interrupt-safe.
|
||||
<P>
|
||||
<H2>Notes for Fortran</H2>
|
||||
All MPI routines in Fortran (except for <tt>MPI_WTIME</tt> and <tt>MPI_WTICK</tt>) have
|
||||
an additional argument <tt>ierr</tt> at the end of the argument list. <tt>ierr
|
||||
</tt>is an integer and has the same meaning as the return value of the routine
|
||||
in C. In Fortran, MPI routines are subroutines, and are invoked with the
|
||||
<tt>call</tt> statement.
|
||||
<P>
|
||||
All MPI objects (e.g., <tt>MPI_Datatype</tt>, <tt>MPI_Comm</tt>) are of type <tt>INTEGER
|
||||
</tt>in Fortran.
|
||||
<P>
|
||||
<H2>Errors</H2>
|
||||
<P>
|
||||
All MPI routines (except <tt>MPI_Wtime</tt> and <tt>MPI_Wtick</tt>) return an error value;
|
||||
C routines as the value of the function and Fortran routines in the last
|
||||
argument. Before the value is returned, the current MPI error handler is
|
||||
called. By default, this error handler aborts the MPI job. The error handler
|
||||
may be changed with <tt>MPI_Comm_set_errhandler</tt> (for communicators),
|
||||
<tt>MPI_File_set_errhandler</tt> (for files), and <tt>MPI_Win_set_errhandler</tt> (for
|
||||
RMA windows). The MPI-1 routine <tt>MPI_Errhandler_set</tt> may be used but
|
||||
its use is deprecated. The predefined error handler
|
||||
<tt>MPI_ERRORS_RETURN</tt> may be used to cause error values to be returned.
|
||||
Note that MPI does <em>not</em> guarantee that an MPI program can continue past
|
||||
an error; however, MPI implementations will attempt to continue whenever
|
||||
possible.
|
||||
<P>
|
||||
<DL>
|
||||
<DT><B>MPI_SUCCESS </B> <DD> No error; MPI routine completed successfully.
|
||||
</DL>
|
||||
<DL>
|
||||
<DT><B>MPI_ERR_ARG </B> <DD> Invalid argument. Some argument is invalid and is not
|
||||
identified by a specific error class (e.g., <tt>MPI_ERR_RANK</tt>).
|
||||
</DL>
|
||||
<DL>
|
||||
<DT><B>MPI_ERR_BUFFER </B> <DD> Invalid buffer pointer. Usually a null buffer where
|
||||
one is not valid.
|
||||
</DL>
|
||||
<DL>
|
||||
<DT><B>MPI_ERR_COMM </B> <DD> Invalid communicator. A common error is to use a null
|
||||
communicator in a call (not even allowed in <tt>MPI_Comm_rank</tt>).
|
||||
</DL>
|
||||
<DL>
|
||||
<DT><B>MPI_ERR_COUNT </B> <DD> Invalid count argument. Count arguments must be
|
||||
non-negative; a count of zero is often valid.
|
||||
</DL>
|
||||
<DL>
|
||||
<DT><B>MPI_ERR_INFO </B> <DD> Invalid Info
|
||||
</DL>
|
||||
<DL>
|
||||
<DT><B>MPI_ERR_TYPE </B> <DD> Invalid datatype argument. Additionally, this error can
|
||||
occur if an uncommitted MPI_Datatype (see <tt>MPI_Type_commit</tt>) is used
|
||||
in a communication call.
|
||||
</DL>
|
||||
<DL>
|
||||
<DT><B>MPI_ERR_OTHER </B> <DD> Other error; use <tt>MPI_Error_string</tt> to get more information
|
||||
about this error code.
|
||||
</DL>
|
||||
<P>
|
||||
</BODY></HTML>
|
||||
@@ -0,0 +1 @@
|
||||
<meta http-equiv="refresh" content="0; url=MPI_Alltoallv_init.html">
|
||||
@@ -5,44 +5,49 @@
|
||||
<TITLE>MPI_Alltoallw</TITLE>
|
||||
</HEAD>
|
||||
<BODY BGCOLOR="FFFFFF">
|
||||
<A NAME="MPI_Alltoallw"><H1>MPI_Alltoallw</H1></A>
|
||||
<H1 id="MPI_Alltoallw">MPI_Alltoallw</H1>
|
||||
Generalized all-to-all communication allowing different datatypes, counts, and displacements for each partner
|
||||
<H2>Synopsis</H2>
|
||||
<PRE>
|
||||
</PRE>
|
||||
<PRE>
|
||||
int MPI_Alltoallw(const void *sendbuf, const int sendcounts[],
|
||||
const int sdispls[], const MPI_Datatype sendtypes[],
|
||||
void *recvbuf, const int recvcounts[], const int rdispls[],
|
||||
const MPI_Datatype recvtypes[], MPI_Comm comm)
|
||||
</PRE>
|
||||
|
||||
<PRE>
|
||||
int MPI_Alltoallw_c(const void *sendbuf, const MPI_Count sendcounts[],
|
||||
const MPI_Aint sdispls[], const MPI_Datatype sendtypes[],
|
||||
void *recvbuf, const MPI_Count recvcounts[],
|
||||
const MPI_Aint rdispls[], const MPI_Datatype recvtypes[],
|
||||
MPI_Comm comm)
|
||||
</PRE>
|
||||
|
||||
<P>
|
||||
<H2>Input Parameters</H2>
|
||||
<DL>
|
||||
<DT><B>sendbuf </B><DD>starting address of send buffer (choice)
|
||||
<DT><B>sendbuf </B> <DD> starting address of send buffer (choice)
|
||||
|
||||
<DT><B>sendcounts </B><DD>integer array equal to the group size specifying the number of
|
||||
elements to send to each processor (integer)
|
||||
<DT><B>sendcounts </B> <DD> non-negative integer array (of length group size) specifying the number of elements to send to each rank (non-negative integer)
|
||||
|
||||
<DT><B>sdispls </B><DD>integer array (of length group size). Entry j specifies the
|
||||
displacement in bytes (relative to sendbuf) from which to take the outgoing
|
||||
data destined for process j
|
||||
<DT><B>sdispls </B> <DD> integer array (of length group size). Entry j specifies the displacement in bytes (relative to sendbuf) from which to take the outgoing data destined for process j (integer)
|
||||
|
||||
<DT><B>sendtypes </B><DD>array of datatypes (of length group size). Entry j specifies the
|
||||
type of data to send to process j (handle)
|
||||
<DT><B>sendtypes </B> <DD> array of datatypes (of length group size). Entry j specifies the type of data to send to process j (handle)
|
||||
|
||||
<DT><B>recvcounts </B><DD>integer array equal to the group size specifying the number of
|
||||
elements that can be received from each processor (integer)
|
||||
<DT><B>recvcounts </B> <DD> non-negative integer array (of length group size) specifying the number of elements that can be received from each rank (non-negative integer)
|
||||
|
||||
<DT><B>rdispls </B><DD>integer array (of length group size). Entry i specifies the
|
||||
displacement in bytes (relative to recvbuf) at which to place the incoming
|
||||
data from process i
|
||||
<DT><B>rdispls </B> <DD> integer array (of length group size). Entry i specifies the displacement in bytes (relative to recvbuf) at which to place the incoming data from process i (integer)
|
||||
|
||||
<DT><B>recvtypes </B><DD>array of datatypes (of length group size). Entry i specifies
|
||||
the type of data received from process i (handle)
|
||||
<DT><B>recvtypes </B> <DD> array of datatypes (of length group size). Entry i specifies the type of data received from process i (handle)
|
||||
|
||||
<DT><B>comm </B><DD>communicator (handle)
|
||||
<DT><B>comm </B> <DD> communicator (handle)
|
||||
</DL>
|
||||
<P>
|
||||
<H2>Output Parameters</H2>
|
||||
<DL><DT><B>recvbuf </B> <DD> address of receive buffer (choice)
|
||||
<DL>
|
||||
<DT><B>recvbuf </B> <DD> address of receive buffer (choice)
|
||||
</DL>
|
||||
<P>
|
||||
<H2>Thread and Interrupt Safety</H2>
|
||||
@@ -50,47 +55,57 @@ the type of data received from process i (handle)
|
||||
This routine is thread-safe. This means that this routine may be
|
||||
safely used by multiple threads without the need for any user-provided
|
||||
thread locks. However, the routine is not interrupt safe. Typically,
|
||||
this is due to the use of memory allocation routines such as <TT>malloc
|
||||
</TT>or other non-MPICH runtime routines that are themselves not interrupt-safe.
|
||||
this is due to the use of memory allocation routines such as <tt>malloc
|
||||
</tt>or other non-MPICH runtime routines that are themselves not interrupt-safe.
|
||||
<P>
|
||||
<H2>Notes for Fortran</H2>
|
||||
All MPI routines in Fortran (except for <TT>MPI_WTIME</TT> and <TT>MPI_WTICK</TT>) have
|
||||
an additional argument <TT>ierr</TT> at the end of the argument list. <TT>ierr
|
||||
</TT>is an integer and has the same meaning as the return value of the routine
|
||||
All MPI routines in Fortran (except for <tt>MPI_WTIME</tt> and <tt>MPI_WTICK</tt>) have
|
||||
an additional argument <tt>ierr</tt> at the end of the argument list. <tt>ierr
|
||||
</tt>is an integer and has the same meaning as the return value of the routine
|
||||
in C. In Fortran, MPI routines are subroutines, and are invoked with the
|
||||
<TT>call</TT> statement.
|
||||
<tt>call</tt> statement.
|
||||
<P>
|
||||
All MPI objects (e.g., <TT>MPI_Datatype</TT>, <TT>MPI_Comm</TT>) are of type <TT>INTEGER
|
||||
</TT>in Fortran.
|
||||
All MPI objects (e.g., <tt>MPI_Datatype</tt>, <tt>MPI_Comm</tt>) are of type <tt>INTEGER
|
||||
</tt>in Fortran.
|
||||
<P>
|
||||
<H2>Errors</H2>
|
||||
<P>
|
||||
All MPI routines (except <TT>MPI_Wtime</TT> and <TT>MPI_Wtick</TT>) return an error value;
|
||||
All MPI routines (except <tt>MPI_Wtime</tt> and <tt>MPI_Wtick</tt>) return an error value;
|
||||
C routines as the value of the function and Fortran routines in the last
|
||||
argument. Before the value is returned, the current MPI error handler is
|
||||
called. By default, this error handler aborts the MPI job. The error handler
|
||||
may be changed with <TT>MPI_Comm_set_errhandler</TT> (for communicators),
|
||||
<TT>MPI_File_set_errhandler</TT> (for files), and <TT>MPI_Win_set_errhandler</TT> (for
|
||||
RMA windows). The MPI-1 routine <TT>MPI_Errhandler_set</TT> may be used but
|
||||
may be changed with <tt>MPI_Comm_set_errhandler</tt> (for communicators),
|
||||
<tt>MPI_File_set_errhandler</tt> (for files), and <tt>MPI_Win_set_errhandler</tt> (for
|
||||
RMA windows). The MPI-1 routine <tt>MPI_Errhandler_set</tt> may be used but
|
||||
its use is deprecated. The predefined error handler
|
||||
<TT>MPI_ERRORS_RETURN</TT> may be used to cause error values to be returned.
|
||||
Note that MPI does <EM>not</EM> guarentee that an MPI program can continue past
|
||||
<tt>MPI_ERRORS_RETURN</tt> may be used to cause error values to be returned.
|
||||
Note that MPI does <em>not</em> guarantee that an MPI program can continue past
|
||||
an error; however, MPI implementations will attempt to continue whenever
|
||||
possible.
|
||||
<P>
|
||||
<DL><DT><B>MPI_SUCCESS </B> <DD> No error; MPI routine completed successfully.
|
||||
<DL>
|
||||
<DT><B>MPI_SUCCESS </B> <DD> No error; MPI routine completed successfully.
|
||||
</DL>
|
||||
<DL><DT><B>MPI_ERR_COMM </B> <DD> Invalid communicator. A common error is to use a null
|
||||
communicator in a call (not even allowed in <TT>MPI_Comm_rank</TT>).
|
||||
<DL>
|
||||
<DT><B>MPI_ERR_BUFFER </B> <DD> Invalid buffer pointer. Usually a null buffer where
|
||||
one is not valid.
|
||||
</DL>
|
||||
<DL><DT><B>MPI_ERR_ARG </B> <DD> Invalid argument. Some argument is invalid and is not
|
||||
identified by a specific error class (e.g., <TT>MPI_ERR_RANK</TT>).
|
||||
<DL>
|
||||
<DT><B>MPI_ERR_COMM </B> <DD> Invalid communicator. A common error is to use a null
|
||||
communicator in a call (not even allowed in <tt>MPI_Comm_rank</tt>).
|
||||
</DL>
|
||||
<DL><DT><B>MPI_ERR_COUNT </B> <DD> Invalid count argument. Count arguments must be
|
||||
<DL>
|
||||
<DT><B>MPI_ERR_COUNT </B> <DD> Invalid count argument. Count arguments must be
|
||||
non-negative; a count of zero is often valid.
|
||||
</DL>
|
||||
<DL><DT><B>MPI_ERR_TYPE </B> <DD> Invalid datatype argument. Additionally, this error can
|
||||
occur if an uncommitted MPI_Datatype (see <TT>MPI_Type_commit</TT>) is used
|
||||
<DL>
|
||||
<DT><B>MPI_ERR_TYPE </B> <DD> Invalid datatype argument. Additionally, this error can
|
||||
occur if an uncommitted MPI_Datatype (see <tt>MPI_Type_commit</tt>) is used
|
||||
in a communication call.
|
||||
</DL>
|
||||
<DL>
|
||||
<DT><B>MPI_ERR_OTHER </B> <DD> Other error; use <tt>MPI_Error_string</tt> to get more information
|
||||
about this error code.
|
||||
</DL>
|
||||
<P>
|
||||
</BODY></HTML>
|
||||
|
||||
@@ -0,0 +1 @@
|
||||
<meta http-equiv="refresh" content="0; url=MPI_Alltoallw.html">
|
||||
124
macx64/mpi/mpich/share/doc/mpich/www3/MPI_Alltoallw_init.html
Normal file
124
macx64/mpi/mpich/share/doc/mpich/www3/MPI_Alltoallw_init.html
Normal file
@@ -0,0 +1,124 @@
|
||||
<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML3.2 EN">
|
||||
<HTML>
|
||||
<HEAD>
|
||||
<META NAME="GENERATOR" CONTENT="DOCTEXT">
|
||||
<TITLE>MPI_Alltoallw_init</TITLE>
|
||||
</HEAD>
|
||||
<BODY BGCOLOR="FFFFFF">
|
||||
<H1 id="MPI_Alltoallw_init">MPI_Alltoallw_init</H1>
|
||||
Create a persistent request for alltoallw.
|
||||
<H2>Synopsis</H2>
|
||||
<PRE>
|
||||
</PRE>
|
||||
<PRE>
|
||||
int MPI_Alltoallw_init(const void *sendbuf, const int sendcounts[],
|
||||
const int sdispls[], const MPI_Datatype sendtypes[],
|
||||
void *recvbuf, const int recvcounts[],
|
||||
const int rdispls[], const MPI_Datatype recvtypes[],
|
||||
MPI_Comm comm, MPI_Info info, MPI_Request *request)
|
||||
</PRE>
|
||||
|
||||
<PRE>
|
||||
int MPI_Alltoallw_init_c(const void *sendbuf, const MPI_Count sendcounts[],
|
||||
const MPI_Aint sdispls[],
|
||||
const MPI_Datatype sendtypes[], void *recvbuf,
|
||||
const MPI_Count recvcounts[], const MPI_Aint rdispls[],
|
||||
const MPI_Datatype recvtypes[], MPI_Comm comm,
|
||||
MPI_Info info, MPI_Request *request)
|
||||
</PRE>
|
||||
|
||||
<P>
|
||||
<H2>Input Parameters</H2>
|
||||
<DL>
|
||||
<DT><B>sendbuf </B> <DD> starting address of send buffer (choice)
|
||||
|
||||
<DT><B>sendcounts </B> <DD> integer array (of length group size) specifying the number of elements to send to each rank (non-negative integer)
|
||||
|
||||
<DT><B>sdispls </B> <DD> integer array (of length group size). Entry j specifies the displacement in bytes (relative to sendbuf) from which to take the outgoing data destined for process j (integer)
|
||||
|
||||
<DT><B>sendtypes </B> <DD> Array of datatypes (of length group size). Entry j specifies the type of data to send to process j (handle)
|
||||
|
||||
<DT><B>recvcounts </B> <DD> integer array (of length group size) specifying the number of elements that can be received from each rank (non-negative integer)
|
||||
|
||||
<DT><B>rdispls </B> <DD> integer array (of length group size). Entry i specifies the displacement in bytes (relative to recvbuf) at which to place the incoming data from process i (integer)
|
||||
|
||||
<DT><B>recvtypes </B> <DD> array of datatypes (of length group size). Entry i specifies the type of data received from process i (handle)
|
||||
|
||||
<DT><B>comm </B> <DD> communicator (handle)
|
||||
|
||||
<DT><B>info </B> <DD> info argument (handle)
|
||||
</DL>
|
||||
<P>
|
||||
<H2>Output Parameters</H2>
|
||||
<DL>
|
||||
<DT><B>recvbuf </B> <DD> address of receive buffer (choice)
|
||||
|
||||
<DT><B>request </B> <DD> communication request (handle)
|
||||
</DL>
|
||||
<P>
|
||||
<H2>Thread and Interrupt Safety</H2>
|
||||
<P>
|
||||
This routine is thread-safe. This means that this routine may be
|
||||
safely used by multiple threads without the need for any user-provided
|
||||
thread locks. However, the routine is not interrupt safe. Typically,
|
||||
this is due to the use of memory allocation routines such as <tt>malloc
|
||||
</tt>or other non-MPICH runtime routines that are themselves not interrupt-safe.
|
||||
<P>
|
||||
<H2>Notes for Fortran</H2>
|
||||
All MPI routines in Fortran (except for <tt>MPI_WTIME</tt> and <tt>MPI_WTICK</tt>) have
|
||||
an additional argument <tt>ierr</tt> at the end of the argument list. <tt>ierr
|
||||
</tt>is an integer and has the same meaning as the return value of the routine
|
||||
in C. In Fortran, MPI routines are subroutines, and are invoked with the
|
||||
<tt>call</tt> statement.
|
||||
<P>
|
||||
All MPI objects (e.g., <tt>MPI_Datatype</tt>, <tt>MPI_Comm</tt>) are of type <tt>INTEGER
|
||||
</tt>in Fortran.
|
||||
<P>
|
||||
<H2>Errors</H2>
|
||||
<P>
|
||||
All MPI routines (except <tt>MPI_Wtime</tt> and <tt>MPI_Wtick</tt>) return an error value;
|
||||
C routines as the value of the function and Fortran routines in the last
|
||||
argument. Before the value is returned, the current MPI error handler is
|
||||
called. By default, this error handler aborts the MPI job. The error handler
|
||||
may be changed with <tt>MPI_Comm_set_errhandler</tt> (for communicators),
|
||||
<tt>MPI_File_set_errhandler</tt> (for files), and <tt>MPI_Win_set_errhandler</tt> (for
|
||||
RMA windows). The MPI-1 routine <tt>MPI_Errhandler_set</tt> may be used but
|
||||
its use is deprecated. The predefined error handler
|
||||
<tt>MPI_ERRORS_RETURN</tt> may be used to cause error values to be returned.
|
||||
Note that MPI does <em>not</em> guarantee that an MPI program can continue past
|
||||
an error; however, MPI implementations will attempt to continue whenever
|
||||
possible.
|
||||
<P>
|
||||
<DL>
|
||||
<DT><B>MPI_SUCCESS </B> <DD> No error; MPI routine completed successfully.
|
||||
</DL>
|
||||
<DL>
|
||||
<DT><B>MPI_ERR_ARG </B> <DD> Invalid argument. Some argument is invalid and is not
|
||||
identified by a specific error class (e.g., <tt>MPI_ERR_RANK</tt>).
|
||||
</DL>
|
||||
<DL>
|
||||
<DT><B>MPI_ERR_BUFFER </B> <DD> Invalid buffer pointer. Usually a null buffer where
|
||||
one is not valid.
|
||||
</DL>
|
||||
<DL>
|
||||
<DT><B>MPI_ERR_COMM </B> <DD> Invalid communicator. A common error is to use a null
|
||||
communicator in a call (not even allowed in <tt>MPI_Comm_rank</tt>).
|
||||
</DL>
|
||||
<DL>
|
||||
<DT><B>MPI_ERR_COUNT </B> <DD> Invalid count argument. Count arguments must be
|
||||
non-negative; a count of zero is often valid.
|
||||
</DL>
|
||||
<DL>
|
||||
<DT><B>MPI_ERR_INFO </B> <DD> Invalid Info
|
||||
</DL>
|
||||
<DL>
|
||||
<DT><B>MPI_ERR_TYPE </B> <DD> Invalid datatype argument. Additionally, this error can
|
||||
occur if an uncommitted MPI_Datatype (see <tt>MPI_Type_commit</tt>) is used
|
||||
in a communication call.
|
||||
</DL>
|
||||
<DL>
|
||||
<DT><B>MPI_ERR_OTHER </B> <DD> Other error; use <tt>MPI_Error_string</tt> to get more information
|
||||
about this error code.
|
||||
</DL>
|
||||
<P>
|
||||
</BODY></HTML>
|
||||
@@ -0,0 +1 @@
|
||||
<meta http-equiv="refresh" content="0; url=MPI_Alltoallw_init.html">
|
||||
Some files were not shown because too many files have changed in this diff Show More
Reference in New Issue
Block a user