/*@
MPI_Finalize - Terminates MPI execution environment
Notes:
All processes must call this routine before exiting. The number of
processes running `after` this routine is called is undefined;
it is best not to perform much more than a 'return rc' after calling
'MPI_Finalize'.
Thread and Signal Safety:
The MPI standard requires that 'MPI_Finalize' be called `only` by the same
thread that initialized MPI with either 'MPI_Init' or 'MPI_Init_thread'.
.N Fortran
.N Errors
.N MPI_SUCCESS
@*/
int MPI_Finalize( void )
{
static const char FCNAME[] = "MPI_Finalize";
int mpi_errno = MPI_SUCCESS;
#if defined(HAVE_USLEEP) && defined(USE_COVERAGE)
int rank=0;
#endif
MPID_MPI_FINALIZE_STATE_DECL(MPID_STATE_MPI_FINALIZE);
MPIR_ERRTEST_INITIALIZED_ORDIE();
/* Note: Only one thread may ever call MPI_Finalize (MPI_Finalize may
be called at most once in any program) */
MPIU_THREAD_CS_ENTER(ALLFUNC,);
MPID_MPI_FINALIZE_FUNC_ENTER(MPID_STATE_MPI_FINALIZE);
/* ... body of routine ... */
/* If the user requested for asynchronous progress, we need to
* shutdown the progress thread */
if (MPIR_async_thread_initialized) {
mpi_errno = MPIR_Finalize_async_thread();
if (mpi_errno) goto fn_fail;
}
#if defined(HAVE_USLEEP) && defined(USE_COVERAGE)
/* We need to get the rank before freeing MPI_COMM_WORLD */
rank = MPIR_Process.comm_world->rank;
#endif
/* Remove the attributes, executing the attribute delete routine.
Do this only if the attribute functions are defined. */
/* The standard (MPI-2, section 4.8) says that the attributes on
MPI_COMM_SELF are deleted before almost anything else happens */
/* Note that the attributes need to be removed from the communicators
so that they aren't freed twice. (The communicators are released
in MPID_Finalize) */
if (MPIR_Process.attr_free && MPIR_Process.comm_self->attributes) {
mpi_errno = MPIR_Process.attr_free( MPI_COMM_SELF,
&MPIR_Process.comm_self->attributes);
MPIR_Process.comm_self->attributes = 0;
}
if (MPIR_Process.attr_free && MPIR_Process.comm_world->attributes) {
mpi_errno = MPIR_Process.attr_free( MPI_COMM_WORLD,
&MPIR_Process.comm_world->attributes);
MPIR_Process.comm_world->attributes = 0;
}
/*
* Now that we're finalizing, we need to take control of the error handlers
* At this point, we will release any user-defined error handlers on
* comm self and comm world
*/
/* no MPI_OBJ CS needed here */
if (MPIR_Process.comm_world->errhandler &&
! (HANDLE_GET_KIND(MPIR_Process.comm_world->errhandler->handle) ==
HANDLE_KIND_BUILTIN) ) {
int in_use;
MPIR_Errhandler_release_ref( MPIR_Process.comm_world->errhandler,
&in_use);
if (!in_use) {
MPIU_Handle_obj_free( &MPID_Errhandler_mem,
MPIR_Process.comm_world->errhandler );
MPIR_Process.comm_world->errhandler = NULL;
}
}
if (MPIR_Process.comm_self->errhandler &&
! (HANDLE_GET_KIND(MPIR_Process.comm_self->errhandler->handle) ==
HANDLE_KIND_BUILTIN) ) {
int in_use;
MPIR_Errhandler_release_ref( MPIR_Process.comm_self->errhandler,
&in_use);
if (!in_use) {
MPIU_Handle_obj_free( &MPID_Errhandler_mem,
MPIR_Process.comm_self->errhandler );
MPIR_Process.comm_self->errhandler = NULL;
}
}
/* FIXME: Why is this not one of the finalize callbacks?. Do we need
pre and post MPID_Finalize callbacks? */
MPIU_Timer_finalize();
/* Call the high-priority callbacks */
MPIR_Call_finalize_callbacks( MPIR_FINALIZE_CALLBACK_PRIO+1,
MPIR_FINALIZE_CALLBACK_MAX_PRIO );
/* Signal the debugger that we are about to exit. */
/* FIXME: Should this also be a finalize callback? */
#ifdef HAVE_DEBUGGER_SUPPORT
MPIR_DebuggerSetAborting( (char *)0 );
#endif
mpi_errno = MPID_Finalize();
if (mpi_errno) {
MPIU_ERR_POP(mpi_errno);
}
/* Call the low-priority (post Finalize) callbacks */
MPIR_Call_finalize_callbacks( 0, MPIR_FINALIZE_CALLBACK_PRIO-1 );
/* At this point, if there has been a failure, exit before
completing the finalize */
if (mpi_errno != MPI_SUCCESS) goto fn_fail;
/* FIXME: Many of these debugging items could/should be callbacks,
added to the finalize callback list */
/* FIXME: the memory tracing code block should be a finalize callback */
/* If memory debugging is enabled, check the memory here, after all
finalize callbacks */
MPIU_THREAD_CS_EXIT(ALLFUNC,);
MPIR_Process.initialized = MPICH_POST_FINALIZED;
MPIU_THREAD_CS_FINALIZE;
/* We place the memory tracing at the very end because any of the other
steps may have allocated memory that they still need to release*/
#ifdef USE_MEMORY_TRACING
/* FIXME: We'd like to arrange for the mem dump output to
go to separate files or to be sorted by rank (note that
the rank is at the head of the line) */
{
if (MPIR_PARAM_MEMDUMP) {
/* The second argument is the min id to print; memory allocated
after MPI_Init is given an id of one. This allows us to
ignore, if desired, memory leaks in the MPID_Init call */
MPIU_trdump( (void *)0, -1 );
}
}
#endif
#if defined(HAVE_USLEEP) && defined(USE_COVERAGE)
/* If performing coverage analysis, make each process sleep for
rank * 100 ms, to give time for the coverage tool to write out
any files. It would be better if the coverage tool and runtime
was more careful about file updates, though the lack of OS support
for atomic file updates makes this harder. */
/*
On some systems, a 0.1 second delay appears to be too short for
the file system. This code allows the use of the environment
variable MPICH_FINALDELAY, which is the delay in milliseconds.
It must be an integer value.
*/
{
int microseconds = 100000;
char *delayStr = getenv( "MPICH_FINALDELAY" );
if (delayStr) {
/* Because this is a maintainer item, we won't check for
errors in the delayStr */
microseconds = 1000 * atoi( delayStr );
}
usleep( rank * microseconds );
}
#endif
/* ... end of body of routine ... */
fn_exit:
MPID_MPI_FINALIZE_FUNC_EXIT(MPID_STATE_MPI_FINALIZE);
return mpi_errno;
fn_fail:
/* --BEGIN ERROR HANDLING-- */
# ifdef HAVE_ERROR_CHECKING
{
mpi_errno = MPIR_Err_create_code(mpi_errno, MPIR_ERR_RECOVERABLE,
FCNAME, __LINE__, MPI_ERR_OTHER, "**mpi_finalize", 0);
}
# endif
mpi_errno = MPIR_Err_return_comm( 0, FCNAME, mpi_errno );
if (MPIR_Process.initialized < MPICH_POST_FINALIZED) {
MPIU_THREAD_CS_EXIT(ALLFUNC,);
}
/*@
MPI_File_set_errhandler - Set the error handler for an MPI file
Input Parameters:
+ file - MPI file (handle)
- errhandler - new error handler for file (handle)
.N ThreadSafeNoUpdate
.N Fortran
.N Errors
.N MPI_SUCCESS
@*/
int MPI_File_set_errhandler(MPI_File file, MPI_Errhandler errhandler)
{
#ifdef HAVE_ERROR_CHECKING
static const char FCNAME[] = "MPI_File_set_errhandler";
#endif
int mpi_errno = MPI_SUCCESS;
#ifdef MPI_MODE_RDONLY
int in_use;
MPIR_Errhandler *errhan_ptr = NULL, *old_errhandler_ptr;
MPI_Errhandler old_errhandler;
#endif
MPIR_FUNC_TERSE_STATE_DECL(MPID_STATE_MPI_FILE_SET_ERRHANDLER);
MPIR_ERRTEST_INITIALIZED_ORDIE();
MPIR_FUNC_TERSE_ENTER(MPID_STATE_MPI_FILE_SET_ERRHANDLER);
#ifdef MPI_MODE_RDONLY
/* Validate parameters, especially handles needing to be converted */
# ifdef HAVE_ERROR_CHECKING
{
MPID_BEGIN_ERROR_CHECKS;
{
/* FIXME: check for a valid file handle (fh) before converting to
a pointer */
MPIR_ERRTEST_ERRHANDLER(errhandler, mpi_errno);
}
MPID_END_ERROR_CHECKS;
}
# endif /* HAVE_ERROR_CHECKING */
MPIR_Errhandler_get_ptr( errhandler, errhan_ptr );
/* Validate parameters and objects (post conversion) */
# ifdef HAVE_ERROR_CHECKING
{
MPID_BEGIN_ERROR_CHECKS;
{
if (HANDLE_GET_KIND(errhandler) != HANDLE_KIND_BUILTIN) {
MPIR_Errhandler_valid_ptr( errhan_ptr,mpi_errno );
/* Also check for a valid errhandler kind */
if (!mpi_errno) {
if (errhan_ptr->kind != MPIR_FILE) {
mpi_errno = MPIR_Err_create_code(
MPI_SUCCESS, MPIR_ERR_RECOVERABLE, FCNAME, __LINE__, MPI_ERR_ARG, "**errhandnotfile", NULL );
}
}
}
if (mpi_errno) goto fn_fail;
}
MPID_END_ERROR_CHECKS;
}
# endif /* HAVE_ERROR_CHECKING */
/* ... body of routine ... */
MPIR_ROMIO_Get_file_errhand( file, &old_errhandler );
if (!old_errhandler) {
/* MPI_File objects default to the errhandler set on MPI_FILE_NULL
* at file open time, or MPI_ERRORS_RETURN if no errhandler is set
* on MPI_FILE_NULL. (MPI-2.2, sec 13.7) */
MPIR_Errhandler_get_ptr( MPI_ERRORS_RETURN, old_errhandler_ptr );
}
else {
MPIR_Errhandler_get_ptr( old_errhandler, old_errhandler_ptr );
}
if (old_errhandler_ptr) {
MPIR_Errhandler_release_ref(old_errhandler_ptr,&in_use);
if (!in_use) {
MPIR_Errhandler_free( old_errhandler_ptr );
}
}
MPIR_Errhandler_add_ref(errhan_ptr);
MPIR_ROMIO_Set_file_errhand( file, errhandler );
#else
/* Dummy in case ROMIO is not defined */
mpi_errno = MPI_ERR_INTERN;
#ifdef HAVE_ERROR_CHECKING
if (0) goto fn_fail; /* quiet compiler warning about unused label */
#endif
#endif
/* ... end of body of routine ... */
#ifdef HAVE_ERROR_CHECKING
fn_exit:
#endif
MPIR_FUNC_TERSE_EXIT(MPID_STATE_MPI_FILE_SET_ERRHANDLER);
return mpi_errno;
/* --BEGIN ERROR HANDLING-- */
# ifdef HAVE_ERROR_CHECKING
fn_fail:
{
mpi_errno = MPIR_Err_create_code(
mpi_errno, MPIR_ERR_RECOVERABLE, FCNAME, __LINE__, MPI_ERR_OTHER,
"**mpi_file_set_errhandler",
"**mpi_file_set_errhandler %F %E", file, errhandler);
}
/* FIXME: Is this obsolete now? */
#ifdef MPI_MODE_RDONLY
mpi_errno = MPIO_Err_return_file( file, mpi_errno );
#endif
goto fn_exit;
# endif
/* --END ERROR HANDLING-- */
}
/*@
MPI_Win_free - Free an MPI RMA window
Input Parameters:
. win - window object (handle)
Notes:
If successfully freed, 'win' is set to 'MPI_WIN_NULL'.
.N ThreadSafe
.N Fortran
.N Errors
.N MPI_SUCCESS
.N MPI_ERR_WIN
.N MPI_ERR_OTHER
@*/
int MPI_Win_free(MPI_Win *win)
{
static const char FCNAME[] = "MPI_Win_free";
int mpi_errno = MPI_SUCCESS;
MPID_Win *win_ptr = NULL;
MPID_MPI_STATE_DECL(MPID_STATE_MPI_WIN_FREE);
MPIR_ERRTEST_INITIALIZED_ORDIE();
MPID_THREAD_CS_ENTER(GLOBAL, MPIR_THREAD_GLOBAL_ALLFUNC_MUTEX);
MPID_MPI_RMA_FUNC_ENTER(MPID_STATE_MPI_WIN_FREE);
/* Validate parameters, especially handles needing to be converted */
# ifdef HAVE_ERROR_CHECKING
{
MPID_BEGIN_ERROR_CHECKS;
{
MPIR_ERRTEST_WIN(*win, mpi_errno);
}
MPID_END_ERROR_CHECKS;
}
# endif
/* Convert MPI object handles to object pointers */
MPID_Win_get_ptr( *win, win_ptr );
/* Validate parameters and objects (post conversion) */
# ifdef HAVE_ERROR_CHECKING
{
MPID_BEGIN_ERROR_CHECKS;
{
/* Validate win_ptr */
MPID_Win_valid_ptr( win_ptr, mpi_errno );
if (mpi_errno) goto fn_fail;
/* TODO: Check for unterminated passive target epoch */
/* TODO: check for unterminated active mode epoch */
if (mpi_errno) goto fn_fail;
}
MPID_END_ERROR_CHECKS;
}
# endif /* HAVE_ERROR_CHECKING */
/* ... body of routine ... */
if (MPIR_Process.attr_free && win_ptr->attributes)
{
mpi_errno = MPIR_Process.attr_free( win_ptr->handle,
&win_ptr->attributes );
}
/*
* If the user attribute free function returns an error,
* then do not free the window
*/
if (mpi_errno != MPI_SUCCESS) goto fn_fail;
/* We need to release the error handler */
if (win_ptr->errhandler &&
! (HANDLE_GET_KIND(win_ptr->errhandler->handle) ==
HANDLE_KIND_BUILTIN) ) {
int in_use;
MPIR_Errhandler_release_ref( win_ptr->errhandler,&in_use);
if (!in_use) {
MPIU_Handle_obj_free( &MPID_Errhandler_mem, win_ptr->errhandler );
}
}
mpi_errno = MPID_Win_free(&win_ptr);
if (mpi_errno) goto fn_fail;
*win = MPI_WIN_NULL;
/* ... end of body of routine ... */
fn_exit:
MPID_MPI_RMA_FUNC_EXIT(MPID_STATE_MPI_WIN_FREE);
MPID_THREAD_CS_EXIT(GLOBAL, MPIR_THREAD_GLOBAL_ALLFUNC_MUTEX);
return mpi_errno;
fn_fail:
/* --BEGIN ERROR HANDLING-- */
# ifdef HAVE_ERROR_CHECKING
{
mpi_errno = MPIR_Err_create_code(
mpi_errno, MPIR_ERR_RECOVERABLE, FCNAME, __LINE__, MPI_ERR_OTHER, "**mpi_win_free", "**mpi_win_free %p", win);
}
# endif
mpi_errno = MPIR_Err_return_win( win_ptr, FCNAME, mpi_errno );
goto fn_exit;
/* --END ERROR HANDLING-- */
}
int MPIR_Comm_delete_internal(MPID_Comm * comm_ptr)
{
int in_use;
int mpi_errno = MPI_SUCCESS;
MPID_MPI_STATE_DECL(MPID_STATE_COMM_DELETE_INTERNAL);
MPID_MPI_FUNC_ENTER(MPID_STATE_COMM_DELETE_INTERNAL);
MPIU_Assert(MPIU_Object_get_ref(comm_ptr) == 0); /* sanity check */
/* Remove the attributes, executing the attribute delete routine.
* Do this only if the attribute functions are defined.
* This must be done first, because if freeing the attributes
* returns an error, the communicator is not freed */
if (MPIR_Process.attr_free && comm_ptr->attributes) {
/* Temporarily add a reference to this communicator because
* the attr_free code requires a valid communicator */
MPIU_Object_add_ref(comm_ptr);
mpi_errno = MPIR_Process.attr_free(comm_ptr->handle, &comm_ptr->attributes);
/* Release the temporary reference added before the call to
* attr_free */
MPIU_Object_release_ref(comm_ptr, &in_use);
}
/* If the attribute delete functions return failure, the
* communicator must not be freed. That is the reason for the
* test on mpi_errno here. */
if (mpi_errno == MPI_SUCCESS) {
/* If this communicator is our parent, and we're disconnecting
* from the parent, mark that fact */
if (MPIR_Process.comm_parent == comm_ptr)
MPIR_Process.comm_parent = NULL;
/* Notify the device that the communicator is about to be
* destroyed */
mpi_errno = MPID_Dev_comm_destroy_hook(comm_ptr);
if (mpi_errno)
MPIR_ERR_POP(mpi_errno);
/* Free info hints */
if (comm_ptr->info != NULL) {
MPIU_Info_free(comm_ptr->info);
}
/* release our reference to the collops structure, comes after the
* destroy_hook to allow the device to manage these vtables in a custom
* fashion */
if (comm_ptr->coll_fns && --comm_ptr->coll_fns->ref_count == 0) {
MPIU_Free(comm_ptr->coll_fns);
comm_ptr->coll_fns = NULL;
}
if (comm_ptr->comm_kind == MPID_INTERCOMM && comm_ptr->local_comm)
MPIR_Comm_release(comm_ptr->local_comm);
/* Free the local and remote groups, if they exist */
if (comm_ptr->local_group)
MPIR_Group_release(comm_ptr->local_group);
if (comm_ptr->remote_group)
MPIR_Group_release(comm_ptr->remote_group);
/* free the intra/inter-node communicators, if they exist */
if (comm_ptr->node_comm)
MPIR_Comm_release(comm_ptr->node_comm);
if (comm_ptr->node_roots_comm)
MPIR_Comm_release(comm_ptr->node_roots_comm);
if (comm_ptr->intranode_table != NULL)
MPIU_Free(comm_ptr->intranode_table);
if (comm_ptr->internode_table != NULL)
MPIU_Free(comm_ptr->internode_table);
/* Free the context value. This should come after freeing the
* intra/inter-node communicators since those free calls won't
* release this context ID and releasing this before then could lead
* to races once we make threading finer grained. */
/* This must be the recvcontext_id (i.e. not the (send)context_id)
* because in the case of intercommunicators the send context ID is
* allocated out of the remote group's bit vector, not ours. */
MPIR_Free_contextid(comm_ptr->recvcontext_id);
/* We need to release the error handler */
if (comm_ptr->errhandler &&
!(HANDLE_GET_KIND(comm_ptr->errhandler->handle) == HANDLE_KIND_BUILTIN)) {
int errhInuse;
MPIR_Errhandler_release_ref(comm_ptr->errhandler, &errhInuse);
if (!errhInuse) {
MPIU_Handle_obj_free(&MPID_Errhandler_mem, comm_ptr->errhandler);
}
}
/* Remove from the list of active communicators if
* we are supporting message-queue debugging. We make this
* conditional on having debugger support since the
* operation is not constant-time */
MPIR_COMML_FORGET(comm_ptr);
/* Check for predefined communicators - these should not
* be freed */
if (!(HANDLE_GET_KIND(comm_ptr->handle) == HANDLE_KIND_BUILTIN))
MPIU_Handle_obj_free(&MPID_Comm_mem, comm_ptr);
}
else {
/* If the user attribute free function returns an error,
* then do not free the communicator */
MPIR_Comm_add_ref(comm_ptr);
}
fn_exit:
MPID_MPI_FUNC_EXIT(MPID_STATE_COMM_DELETE_INTERNAL);
return mpi_errno;
fn_fail:
goto fn_exit;
}
/*@
MPI_Win_set_errhandler - Set window error handler
Input Parameters:
+ win - window (handle)
- errhandler - new error handler for window (handle)
.N ThreadSafeNoUpdate
.N Fortran
.N Errors
.N MPI_SUCCESS
.N MPI_ERR_WIN
@*/
int MPI_Win_set_errhandler(MPI_Win win, MPI_Errhandler errhandler)
{
#ifdef HAVE_ERROR_CHECKING
static const char FCNAME[] = "MPI_Win_set_errhandler";
#endif
int mpi_errno = MPI_SUCCESS;
MPID_Win *win_ptr = NULL;
int in_use;
MPID_Errhandler *errhan_ptr = NULL;
MPID_MPI_STATE_DECL(MPID_STATE_MPI_WIN_SET_ERRHANDLER);
MPIR_ERRTEST_INITIALIZED_ORDIE();
MPID_MPI_FUNC_ENTER(MPID_STATE_MPI_WIN_SET_ERRHANDLER);
/* Validate parameters, especially handles needing to be converted */
# ifdef HAVE_ERROR_CHECKING
{
MPID_BEGIN_ERROR_CHECKS;
{
MPIR_ERRTEST_WIN(win, mpi_errno);
MPIR_ERRTEST_ERRHANDLER(errhandler, mpi_errno);
}
MPID_END_ERROR_CHECKS;
}
# endif
/* Convert MPI object handles to object pointers */
MPID_Win_get_ptr( win, win_ptr );
MPID_Errhandler_get_ptr( errhandler, errhan_ptr );
/* Validate parameters and objects (post conversion) */
# ifdef HAVE_ERROR_CHECKING
{
MPID_BEGIN_ERROR_CHECKS;
{
/* Validate win_ptr */
MPID_Win_valid_ptr( win_ptr, mpi_errno );
/* If win_ptr is not value, it will be reset to null */
if (HANDLE_GET_KIND(errhandler) != HANDLE_KIND_BUILTIN) {
MPID_Errhandler_valid_ptr( errhan_ptr,mpi_errno );
/* Also check for a valid errhandler kind */
if (!mpi_errno) {
if (errhan_ptr->kind != MPID_WIN) {
mpi_errno = MPIR_Err_create_code(
MPI_SUCCESS, MPIR_ERR_RECOVERABLE, FCNAME,
__LINE__, MPI_ERR_ARG, "**errhandnotwin", NULL );
}
}
}
if (mpi_errno) goto fn_fail;
}
MPID_END_ERROR_CHECKS;
}
# endif /* HAVE_ERROR_CHECKING */
/* ... body of routine ... */
MPID_THREAD_CS_ENTER(POBJ, MPIR_THREAD_POBJ_WIN_MUTEX(win_ptr));
if (win_ptr->errhandler != NULL) {
MPIR_Errhandler_release_ref(win_ptr->errhandler,&in_use);
if (!in_use) {
MPID_Errhandler_free( win_ptr->errhandler );
}
}
MPIR_Errhandler_add_ref(errhan_ptr);
win_ptr->errhandler = errhan_ptr;
MPID_THREAD_CS_EXIT(POBJ, MPIR_THREAD_POBJ_WIN_MUTEX(win_ptr));
/* ... end of body of routine ... */
#ifdef HAVE_ERROR_CHECKING
fn_exit:
#endif
MPID_MPI_FUNC_EXIT(MPID_STATE_MPI_WIN_SET_ERRHANDLER);
return mpi_errno;
/* --BEGIN ERROR HANDLING-- */
# ifdef HAVE_ERROR_CHECKING
fn_fail:
{
mpi_errno = MPIR_Err_create_code(
mpi_errno, MPIR_ERR_RECOVERABLE, FCNAME, __LINE__, MPI_ERR_OTHER,
"**mpi_win_set_errhandler",
"**mpi_win_set_errhandler %W %E", win, errhandler);
}
mpi_errno = MPIR_Err_return_win(win_ptr, FCNAME, mpi_errno);
goto fn_exit;
# endif
/* --END ERROR HANDLING-- */
}
