static void backend_fatal(char *type, struct ompi_communicator_t *comm, char *name, int *error_code, va_list arglist) { /* We only want aggregation while the rte is initialized */ if (ompi_rte_initialized) { backend_fatal_aggregate(type, comm, name, error_code, arglist); } else { backend_fatal_no_aggregate(type, comm, name, error_code, arglist); } /* In most instances the communicator will be valid. If not, we are either early in * the initialization or we are dealing with a window. Thus, it is good enough to abort * on MPI_COMM_SELF, the error will propagate. */ if (comm == NULL) { comm = &ompi_mpi_comm_self.comm; } if (NULL != error_code) { ompi_mpi_abort(comm, *error_code); } else { ompi_mpi_abort(comm, 1); } }
static void backend_fatal(char *type, struct ompi_communicator_t *comm, char *name, int *error_code, va_list arglist) { /* Do we want help message aggregation? Usually yes, but it uses malloc(), which may cause further errors if we're exiting due to a memory problem. So we also have the option to *not* aggregate (which doesn't use malloc during its call stack, meaning that there is a better chance that the error message will actually get printed). Note that we can only do aggregation after MPI_INIT and before MPI_FINALIZE. */ if (orte_help_want_aggregate && ompi_mpi_initialized && !ompi_mpi_finalized) { backend_fatal_aggregate(type, comm, name, error_code, arglist); } else { backend_fatal_no_aggregate(type, comm, name, error_code, arglist); } /* Should we do something more intelligent than just using COMM_SELF? */ if (comm == NULL) { comm = &ompi_mpi_comm_self.comm; } if (NULL != error_code) { ompi_mpi_abort(comm, *error_code, false); } else { ompi_mpi_abort(comm, 1, false); } }