int MPIR_Barrier_intra_smp(MPIR_Comm * comm_ptr, MPIR_Errflag_t * errflag)
{
int mpi_errno = MPI_SUCCESS;
int mpi_errno_ret = MPI_SUCCESS;
MPIR_Assert(MPIR_CVAR_ENABLE_SMP_COLLECTIVES && MPIR_CVAR_ENABLE_SMP_BARRIER &&
MPIR_Comm_is_node_aware(comm_ptr));
/* do the intranode barrier on all nodes */
if (comm_ptr->node_comm != NULL) {
mpi_errno = MPIR_Barrier(comm_ptr->node_comm, errflag);
if (mpi_errno) {
/* for communication errors, just record the error but continue */
*errflag =
MPIX_ERR_PROC_FAILED ==
MPIR_ERR_GET_CLASS(mpi_errno) ? MPIR_ERR_PROC_FAILED : MPIR_ERR_OTHER;
MPIR_ERR_SET(mpi_errno, *errflag, "**fail");
MPIR_ERR_ADD(mpi_errno_ret, mpi_errno);
}
}
/* do the barrier across roots of all nodes */
if (comm_ptr->node_roots_comm != NULL) {
mpi_errno = MPIR_Barrier(comm_ptr->node_roots_comm, errflag);
if (mpi_errno) {
/* for communication errors, just record the error but continue */
*errflag =
MPIX_ERR_PROC_FAILED ==
MPIR_ERR_GET_CLASS(mpi_errno) ? MPIR_ERR_PROC_FAILED : MPIR_ERR_OTHER;
MPIR_ERR_SET(mpi_errno, *errflag, "**fail");
MPIR_ERR_ADD(mpi_errno_ret, mpi_errno);
}
}
/* release the local processes on each node with a 1-byte
* broadcast (0-byte broadcast just returns without doing
* anything) */
if (comm_ptr->node_comm != NULL) {
int i = 0;
mpi_errno = MPIR_Bcast(&i, 1, MPI_BYTE, 0, comm_ptr->node_comm, errflag);
if (mpi_errno) {
/* for communication errors, just record the error but continue */
*errflag =
MPIX_ERR_PROC_FAILED ==
MPIR_ERR_GET_CLASS(mpi_errno) ? MPIR_ERR_PROC_FAILED : MPIR_ERR_OTHER;
MPIR_ERR_SET(mpi_errno, *errflag, "**fail");
MPIR_ERR_ADD(mpi_errno_ret, mpi_errno);
}
}
if (mpi_errno_ret)
mpi_errno = mpi_errno_ret;
else if (*errflag != MPIR_ERR_NONE)
MPIR_ERR_SET(mpi_errno, *errflag, "**coll_fail");
return mpi_errno;
}
int MPIDO_Ibarrier(MPID_Comm *comm_ptr, MPID_Request **request)
{
TRACE_ERR("Entering MPIDO_Ibarrier\n");
/*
* There is actually no current pami optimization for this
* so just kick it back to MPICH if mpir_nbc is set, otherwise
* call the blocking MPIR_Barrier().
*/
if (MPIDI_Process.mpir_nbc != 0)
return 0;
/*
* MPIR_* nbc implementation is not enabled. Fake a non-blocking
* MPIR_Ibarrier() with a blocking MPIR_Barrier().
*/
if(unlikely(MPIDI_Process.verbose >= MPIDI_VERBOSE_DETAILS_ALL && comm_ptr->rank == 0))
fprintf(stderr,"Using MPICH barrier\n");
TRACE_ERR("Using MPICH Barrier\n");
int mpierrno = 0;
int rc = MPIR_Barrier(comm_ptr, &mpierrno);
MPID_Request * mpid_request = MPID_Request_create_inline();
mpid_request->kind = MPID_COLL_REQUEST;
*request = mpid_request;
MPIDI_Request_complete_norelease_inline(mpid_request);
return rc;
}
/* not declared static because it is called in ch3_comm_connect/accept */
static
int MPID_PSP_Barrier(MPIR_Comm *comm_ptr, MPIR_Errflag_t *errflag)
{
if (comm_ptr->group) {
pscom_barrier(comm_ptr->group);
return MPI_SUCCESS;
} else {
/* Fallback to MPIch default Barrier */
return MPIR_Barrier(comm_ptr, errflag);
}
}
int MPIR_Barrier_impl(MPID_Comm *comm_ptr, MPIR_Errflag_t *errflag)
{
int mpi_errno = MPI_SUCCESS;
if (comm_ptr->coll_fns != NULL && comm_ptr->coll_fns->Barrier != NULL)
{
/* --BEGIN USEREXTENSION-- */
mpi_errno = comm_ptr->coll_fns->Barrier(comm_ptr, errflag);
if (mpi_errno) MPIR_ERR_POP(mpi_errno);
/* --END USEREXTENSION-- */
}
else
{
mpi_errno = MPIR_Barrier(comm_ptr, errflag);
if (mpi_errno) MPIR_ERR_POP(mpi_errno);
}
fn_exit:
if (*errflag != MPIR_ERR_NONE)
MPIR_ERR_SET(mpi_errno, *errflag, "**coll_fail");
return mpi_errno;
fn_fail:
goto fn_exit;
}
int MPIDO_Barrier(MPID_Comm *comm_ptr, int *mpierrno)
{
TRACE_ERR("Entering MPIDO_Barrier\n");
volatile unsigned active=1;
MPIDI_Post_coll_t barrier_post;
pami_xfer_t barrier;
pami_algorithm_t my_barrier;
pami_metadata_t *my_barrier_md;
int queryreq = 0;
if(comm_ptr->mpid.user_selected_type[PAMI_XFER_BARRIER] == MPID_COLL_USE_MPICH)
{
if(unlikely(MPIDI_Process.verbose >= MPIDI_VERBOSE_DETAILS_ALL && comm_ptr->rank == 0))
fprintf(stderr,"Using MPICH barrier\n");
TRACE_ERR("Using MPICH Barrier\n");
return MPIR_Barrier(comm_ptr, mpierrno);
}
barrier.cb_done = cb_barrier;
barrier.cookie = (void *)&active;
if(comm_ptr->mpid.user_selected_type[PAMI_XFER_BARRIER] == MPID_COLL_OPTIMIZED)
{
TRACE_ERR("Optimized barrier (%s) was pre-selected\n", comm_ptr->mpid.opt_protocol_md[PAMI_XFER_BARRIER][0].name);
my_barrier = comm_ptr->mpid.opt_protocol[PAMI_XFER_BARRIER][0];
my_barrier_md = &comm_ptr->mpid.opt_protocol_md[PAMI_XFER_BARRIER][0];
queryreq = comm_ptr->mpid.must_query[PAMI_XFER_BARRIER][0];
}
else
{
TRACE_ERR("Barrier (%s) was specified by user\n", comm_ptr->mpid.user_metadata[PAMI_XFER_BARRIER].name);
my_barrier = comm_ptr->mpid.user_selected[PAMI_XFER_BARRIER];
my_barrier_md = &comm_ptr->mpid.user_metadata[PAMI_XFER_BARRIER];
queryreq = comm_ptr->mpid.user_selected_type[PAMI_XFER_BARRIER];
}
barrier.algorithm = my_barrier;
/* There is no support for query-required barrier protocols here */
MPID_assert_always(queryreq != MPID_COLL_ALWAYS_QUERY);
MPID_assert_always(queryreq != MPID_COLL_CHECK_FN_REQUIRED);
/* TODO Name needs fixed somehow */
MPIDI_Update_last_algorithm(comm_ptr, my_barrier_md->name);
if(unlikely(MPIDI_Process.verbose >= MPIDI_VERBOSE_DETAILS_ALL && comm_ptr->rank == 0))
{
unsigned long long int threadID;
MPIU_Thread_id_t tid;
MPIU_Thread_self(&tid);
threadID = (unsigned long long int)tid;
fprintf(stderr,"<%llx> Using protocol %s for barrier on %u\n",
threadID,
my_barrier_md->name,
/* comm_ptr->rank,comm_ptr->local_size,comm_ptr->remote_size,*/
(unsigned) comm_ptr->context_id);
}
TRACE_ERR("%s barrier\n", MPIDI_Process.context_post.active>0?"posting":"invoking");
MPIDI_Context_post(MPIDI_Context[0], &barrier_post.state,
MPIDI_Pami_post_wrapper, (void *)&barrier);
TRACE_ERR("barrier %s rc: %d\n", MPIDI_Process.context_post.active>0?"posted":"invoked", rc);
TRACE_ERR("advance spinning\n");
MPID_PROGRESS_WAIT_WHILE(active);
TRACE_ERR("exiting mpido_barrier\n");
return 0;
}
