overview.tex

刚才是说明 现在是安装程序在 LINUX环境下进行编程的MPICH安装文件

 The following are routines that a device must implement; these are used
 by the code that implements the MPI communication operations.

 Note that some of these operations may be implemented using the others; for 
 example, \texttt{MPID_Get_contig} can use \texttt{MPID_Rhcv} and \texttt{MPID_Put_contig}.  The
 routines that \emph{must} be implemented are marked as \texttt{MPID_CORE}.  The other
 routines can be implemented (at some loss in efficiency) in terms of these
 or other standard operations.  The MPICH2000 implementation will include
 an implementation of all of these routines, using \texttt{MPID_CORE} for 
 communication and other code for local operations (such as the datatype 
 operations).  

 Most "routines" may also be implemented as macros in cases (such as memory 
 allocation) where performance is critical.  Any function that must be a
 function (because a pointer to it is needed) is marked \texttt{NO MACRO ALLOWED}.
 (So far, there are no functions in this category).  For some functions, such
 as the timer routines, macros are recommended.

 In a few places, a decision hasn't been made.  These are marked as "Question".
 When answered, these will turn into "Rationales".

\subsection{Error handling and reporting}
 
 The ADI routines assume that they are provided with
 valid arguments and do no checking that 
 the arguments are valid.  The only exception is for errors that are difficult
 to check for in advance, such as an invalid buffer encountered because of a 
 complex datatype
 or message truncation.  Routines that involve communication may also return 
 errors caused by improper use (e.g., mismatched collective calls, invalid 
 ready send).  When an error is detected, an error code is created for it.
 This code contains an MPI error class and an instance-specific handle, used 
 to record more detailed information about the error.  Where an error code
 is returned, the value \texttt{0} signifies no error (\texttt{MPI_SUCCESS} is \texttt{0}).

 Where possible, all errors should be recoverable.  That is, it should be
 possible for an MPI program to continue to run correctly.  When an error has 
 significant consequences, these should be limited to the smallest communicator
 possible.  For example, the failure of a process in \texttt{MPI_COMM_WORLD}
 should make
 \texttt{MPI_COMM_WORLD} invalid, but \texttt{MPI_COMM_SELF} and communicators that do not 
 involve the failed process should remain valid.  

 Many routines have no error returns.  This is a tough call, but the reason 
 is that the routines with no error returns have no opportunity to detect
 an error that should not have been caught by some other routine (remember,
 these aren't user-level routines).

\subsection{Semantics of Routines}
 The semantics of these routines normally follow the semantics of the 
 related MPI routines, and the MPI standard should be consulted for any 
 details.  Differences in the semantics are noted in the "Notes" section
 of each routine.