plucky (3) MPI_Finalize.openmpi.3.gz

SYNTAX

   C Syntax
          #include <mpi.h>

          int MPI_Finalize()

   Fortran Syntax
          USE MPI
          ! or the older form: INCLUDE 'mpif.h'

          MPI_FINALIZE(IERROR)
              INTEGER IERROR

   Fortran 2008 Syntax
          USE mpi_f08

          MPI_Finalize(ierror)
              INTEGER, OPTIONAL, INTENT(OUT) :: ierror

OUTPUT PARAMETER

       • ierror : Fortran only: Error status (integer).

DESCRIPTION

       This  routine  cleans  up all MPI states. Once this routine is called, no MPI routine (not even MPI_Init)
       may be called, except for MPI_Get_version, MPI_Initialized, and MPI_Finalized. Unless there  has  been  a
       call  to  MPI_Abort,  you  must  ensure  that all pending communications involving a process are complete
       before the process calls MPI_Finalize. If the call  returns,  each  process  may  either  continue  local
       computations  or  exit without participating in further communication with other processes. At the moment
       when the last process calls MPI_Finalize, all pending sends must be matched by a receive, and all pending
       receives must be matched by a send.

       MPI_Finalize  is  collective  over  all  connected  processes. If no processes were spawned, accepted, or
       connected, then this means it is collective over MPI_COMM_WORLD. Otherwise, it  is  collective  over  the
       union of all processes that have been and continue to be connected.

NOTES

       All  processes must call this routine before exiting. All processes will still exist but may not make any
       further MPI calls. MPI_Finalize guarantees that all local actions required by communications the user has
       completed  will, in fact, occur before it returns. However, MPI_Finalize guarantees nothing about pending
       communications that have not been completed;  completion  is  ensured  only  by  MPI_Wait,  MPI_Test,  or
       MPI_Request_free combined with some other verification of completion.

       For  example,  a  successful  return from a blocking communication operation or from MPI_Wait or MPI_Test
       means that the communication is completed by the user  and  the  buffer  can  be  reused,  but  does  not
       guarantee  that  the  local  process  has  no  more  work  to  do.  Similarly,  a  successful return from
       MPI_Request_free with a request handle generated by an  MPI_Isend  nullifies  the  handle  but  does  not
       guarantee  that  the  operation has completed. The MPI_Isend is complete only when a matching receive has
       completed.

       If you would like  to  cause  actions  to  happen  when  a  process  finishes,  attach  an  attribute  to
       MPI_COMM_SELF  with  a  callback  function.  Then, when MPI_Finalize is called, it will first execute the
       equivalent of an MPI_Comm_free on MPI_COMM_SELF. This will cause  the  delete  callback  function  to  be
       executed  on all keys associated with MPI_COMM_SELF in an arbitrary order. If no key has been attached to
       MPI_COMM_SELF, then no callback is invoked. This freeing of MPI_COMM_SELF happens before any other  parts
       of  MPI  are affected. Calling MPI_Finalized will thus return “false” in any of these callback functions.
       Once you have done this with MPI_COMM_SELF, the results of MPI_Finalize are not specified.

ERRORS

       Almost all MPI routines return an error value; C routines as  the  return  result  of  the  function  and
       Fortran routines in the last argument.

       Before  the  error  value  is  returned,  the current MPI error handler associated with the communication
       object (e.g., communicator, window, file) is called.  If no communication object is associated  with  the
       MPI  call,  then  the call is considered attached to MPI_COMM_SELF and will call the associated MPI error
       handler.  When  MPI_COMM_SELF  is  not  initialized   (i.e.,   before   MPI_Init/MPI_Init_thread,   after
       MPI_Finalize,  or  when using the Sessions Model exclusively) the error raises the initial error handler.
       The initial error handler can be changed by calling MPI_Comm_set_errhandler on MPI_COMM_SELF  when  using
       the  World  model,  or the mpi_initial_errhandler CLI argument to mpiexec or info key to MPI_Comm_spawn/‐
       MPI_Comm_spawn_multiple.  If no other appropriate error handler has been set, then the  MPI_ERRORS_RETURN
       error  handler  is  called for MPI I/O functions and the MPI_ERRORS_ABORT error handler is called for all
       other MPI functions.

       Open MPI includes three predefined error handlers that can be used:

       • MPI_ERRORS_ARE_FATAL Causes the program to abort all connected MPI processes.

       • MPI_ERRORS_ABORT An error handler that can be invoked on a communicator, window, file, or session. When
         called  on  a  communicator,  it  acts  as if MPI_Abort was called on that communicator. If called on a
         window or file, acts as if MPI_Abort was called on a communicator containing the group of processes  in
         the corresponding window or file. If called on a session, aborts only the local process.

       • MPI_ERRORS_RETURN Returns an error code to the application.

       MPI applications can also implement their own error handlers by calling:

       • MPI_Comm_create_errhandler then MPI_Comm_set_errhandler

       • MPI_File_create_errhandler then MPI_File_set_errhandler

       • MPI_Session_create_errhandler then MPI_Session_set_errhandler or at MPI_Session_init

       • MPI_Win_create_errhandler then MPI_Win_set_errhandler

       Note that MPI does not guarantee that an MPI program can continue past an error.

       See the MPI man page for a full list of MPI error codes.

       See the Error Handling section of the MPI-3.1 standard for more information.

       SEE ALSO:
          MPI_Init

COPYRIGHT

       2003-2025, The Open MPI Community

                                                  Feb 17, 2025                                   MPI_FINALIZE(3)