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; }