NAME

       MPI_Waitall - Waits for all given communications to complete.

SYNTAX

C Syntax

       #include <mpi.h>
       int MPI_Waitall(int count, MPI_Request array_of_requests[],
            MPI_Status *array_of_statuses)

Fortran Syntax

       USE MPI
       ! or the older form: INCLUDE 'mpif.h'
       MPI_WAITALL(COUNT, ARRAY_OF_REQUESTS, ARRAY_OF_STATUSES, IERROR)
            INTEGER   COUNT, ARRAY_OF_REQUESTS(*)
            INTEGER   ARRAY_OF_STATUSES(MPI_STATUS_SIZE,*), IERROR

Fortran 2008 Syntax

       USE mpi_f08
       MPI_Waitall(count, array_of_requests, array_of_statuses, ierror)
            INTEGER, INTENT(IN) :: count
            TYPE(MPI_Request), INTENT(INOUT) :: array_of_requests(count)
            TYPE(MPI_Status) :: array_of_statuses(*)
            INTEGER, OPTIONAL, INTENT(OUT) :: ierror

C++ Syntax

       #include <mpi.h>
       static void Request::Waitall(int count, Request array_of_requests[],
            Status array_of_statuses[])

       static void Request::Waitall(int count, Request array_of_requests[])

INPUT PARAMETERS

       count     Lists length (integer).

       array_of_requests
                 Array of requests (array of handles).

OUTPUT PARAMETERS

       array_of_statuses
                 Array of status objects (array of status).

       IERROR    Fortran only: Error status (integer).

DESCRIPTION

       Blocks  until  all  communication  operations  associated  with  active handles in the list complete, and
       returns the status of all these operations (this includes the  case  where  no  handle  in  the  list  is
       active).  Both arrays have the same number of valid entries. The ith entry in array_of_statuses is set to
       the return status of  the  ith  operation.  Requests  that  were  created  by  nonblocking  communication
       operations  are  deallocated, and the corresponding handles in the array are set to MPI_REQUEST_NULL. The
       list may contain null or inactive handles. The call sets to empty the status of each such entry.

       The error-free execution of MPI_Waitall(count, array_of_requests, array_of_statuses) has the same  effect
       as  the execution of  MPI_Wait(&array_of_request[i], &array_of_statuses[i]), for i=0,...,count-1, in some
       arbitrary order. MPI_Waitall with an array of length 1 is equivalent to MPI_Wait.

       When one or more of the communications completed by a call to MPI_Waitall fail, it is desirable to return
       specific  information  on each communication. The function MPI_Waitall will return in such case the error
       code MPI_ERR_IN_STATUS and will set the error field of each status to a specific error  code.  This  code
       will be MPI_SUCCESS if the specific communication completed; it will be another specific error code if it
       failed; or it can be MPI_ERR_PENDING if it has neither failed nor  completed.  The  function  MPI_Waitall
       will  return  MPI_SUCCESS  if no request had an error, or will return another error code if it failed for
       other reasons (such as invalid arguments). In such cases, it will not update  the  error  fields  of  the
       statuses.

       If your application does not need to examine the array_of_statuses field, you can save resources by using
       the predefined constant MPI_STATUSES_IGNORE can be used as a  special  value  for  the  array_of_statuses
       argument.

ERRORS

       For each invocation of MPI_Waitall, if one or more requests generate an MPI exception, only the first MPI
       request that caused an exception will be passed to its  corresponding  error  handler.   No  other  error
       handlers  will  be  invoked (even if multiple requests generated exceptions).  However, all requests that
       generate an exception will have a relevant error code set in  the  corresponding  status.MPI_ERROR  field
       (unless MPI_STATUSES_IGNORE was used).

       The  default  error  handler aborts the MPI job, except for I/O function errors. The error handler may be
       changed with MPI_Comm_set_errhandler, MPI_File_set_errhandler, or  MPI_Win_set_errhandler  (depending  on
       the  type  of  MPI handle that generated the MPI request); the predefined error handler MPI_ERRORS_RETURN
       may be used to cause error values to be returned. Note that MPI does not guarantee that  an  MPI  program
       can continue past an error.

       If the invoked error handler allows MPI_Waitall to return to the caller, the value MPI_ERR_IN_STATUS will
       be  returned  in  the  C  and  Fortran   bindings.    In   C++,   if   the   predefined   error   handler
       MPI::ERRORS_THROW_EXCEPTIONS   is   used,   the   value  MPI::ERR_IN_STATUS  will  be  contained  in  the
       MPI::Exception object.  The MPI_ERROR field can then be examined in the array  of  returned  statuses  to
       determine exactly which request(s) generated an exception.

SEE ALSO

       MPI_Comm_set_errhandler
       MPI_File_set_errhandler
       MPI_Test
       MPI_Testall
       MPI_Testany
       MPI_Testsome
       MPI_Wait
       MPI_Waitany
       MPI_Waitsome
       MPI_Win_set_errhandler