uint32_t vt_rank_to_pe(VT_MPI_INT rank, MPI_Comm comm)
{
MPI_Group group;
VT_MPI_INT global_rank;
VT_MPI_INT inter;
#if defined(HAVE_DECL_MPI_ROOT) && HAVE_DECL_MPI_ROOT
if ( rank == MPI_ROOT )
{
global_rank = (VT_MPI_INT)vt_my_trace;
}
else
#endif /* HAVE_DECL_MPI_ROOT */
{
PMPI_Comm_test_inter(comm, &inter);
if ( inter )
PMPI_Comm_remote_group(comm, &group);
else
PMPI_Comm_group(comm, &group);
PMPI_Group_translate_ranks(group, 1, &rank, world.group, &global_rank);
PMPI_Group_free(&group);
}
return (uint32_t)global_rank;
}
/**
* Measurement wrapper for MPI_Comm_test_inter
* @note Auto-generated by wrapgen from template: std.w
* @note C interface
* @note Introduced with MPI 1.0
* @ingroup cg
*/
int MPI_Comm_test_inter(MPI_Comm comm,
int* flag)
{
int return_val;
if (IS_EVENT_GEN_ON_FOR(CG))
{
EVENT_GEN_OFF();
esd_enter(epk_mpi_regid[EPK__MPI_COMM_TEST_INTER]);
return_val = PMPI_Comm_test_inter(comm, flag);
esd_exit(epk_mpi_regid[EPK__MPI_COMM_TEST_INTER]);
EVENT_GEN_ON();
}
else
{
return_val = PMPI_Comm_test_inter(comm, flag);
}
return return_val;
}
void vt_comm_create(MPI_Comm comm)
{
MPI_Group group, lgroup, rgroup;
VT_MPI_INT inter;
VT_MPI_INT size_grpv = 0;
uint32_t cid;
/* raise maximum number of communicators, if necessary */
if (last_comm == max_comms)
RAISE_MAX(comms, max_comms, struct VTComm);
/* ask for group of comm */
PMPI_Comm_test_inter(comm, &inter);
if (inter)
{
PMPI_Comm_remote_group(comm, &rgroup);
PMPI_Comm_group(comm, &lgroup);
PMPI_Group_union(lgroup, rgroup, &group);
PMPI_Group_free(&lgroup);
PMPI_Group_free(&rgroup);
}
else
{
PMPI_Comm_group(comm, &group);
}
/* create group entry in grpv except for
MPI_COMM_SELF and
MPI_COMM_WORLD (if the current rank isn't the first available one) */
if ((comm != MPI_COMM_SELF && comm != MPI_COMM_WORLD) ||
(comm == MPI_COMM_WORLD && vt_my_trace_is_first_avail))
{
group_to_bitvector( group );
size_grpv = world.size_grpv;
}
/* register mpi communicator definition */
#if (defined(VT_MT) || defined(VT_HYB))
VTTHRD_LOCK_IDS();
#endif /* VT_MT || VT_HYB */
cid = vt_def_mpi_comm(VT_CURRENT_THREAD,
comm == MPI_COMM_WORLD ? VT_MPI_COMM_WORLD :
comm == MPI_COMM_SELF ? VT_MPI_COMM_SELF : VT_MPI_COMM_OTHER,
size_grpv, grpv);
#if (defined(VT_MT) || defined(VT_HYB))
VTTHRD_UNLOCK_IDS();
#endif /* VT_MT || VT_HYB */
/* save communicator id for fast access in VT_COMM_ID */
if (comm == MPI_COMM_WORLD) vt_mpi_comm_world_cid = cid;
else if (comm == MPI_COMM_SELF) vt_mpi_comm_self_cid = cid;
/* enter comm in comms[] array */
comms[last_comm].comm = comm;
comms[last_comm].cid = cid;
last_comm++;
/* clean up */
PMPI_Group_free(&group);
}
/*@
MPI_Comm_dup - Duplicates an existing communicator with all its cached
information
Input Parameter:
. comm - Communicator to be duplicated (handle)
Output Parameter:
. newcomm - A new communicator over the same group as 'comm' but with a new
context. See notes. (handle)
Notes:
This routine is used to create a new communicator that has a new
communication context but contains the same group of processes as
the input communicator. Since all MPI communication is performed
within a communicator (specifies as the group of processes `plus`
the context), this routine provides an effective way to create a
private communicator for use by a software module or library. In
particular, no library routine should use 'MPI_COMM_WORLD' as the
communicator; instead, a duplicate of a user-specified communicator
should always be used. For more information, see Using MPI, 2nd
edition.
Because this routine essentially produces a copy of a communicator,
it also copies any attributes that have been defined on the input
communicator, using the attribute copy function specified by the
'copy_function' argument to 'MPI_Keyval_create'. This is
particularly useful for (a) attributes that describe some property
of the group associated with the communicator, such as its
interconnection topology and (b) communicators that are given back
to the user; the attibutes in this case can track subsequent
'MPI_Comm_dup' operations on this communicator.
.N ThreadSafe
.N Fortran
.N Errors
.N MPI_SUCCESS
.N MPI_ERR_COMM
.seealso: MPI_Comm_free, MPI_Keyval_create, MPI_Attr_put, MPI_Attr_delete,
MPI_Comm_create_keyval, MPI_Comm_set_attr, MPI_Comm_delete_attr
@*/
int MPI_Comm_dup(MPI_Comm comm, MPI_Comm *newcomm)
{
int mpi_errno = MPI_SUCCESS;
MPID_Comm *comm_ptr = NULL, *newcomm_ptr;
MPID_MPI_STATE_DECL(MPID_STATE_MPI_COMM_DUP);
MPIR_ERRTEST_INITIALIZED_ORDIE();
MPIU_THREAD_CS_ENTER(ALLFUNC,);
MPID_MPI_FUNC_ENTER(MPID_STATE_MPI_COMM_DUP);
/* Validate parameters, especially handles needing to be converted */
# ifdef HAVE_ERROR_CHECKING
{
MPID_BEGIN_ERROR_CHECKS;
{
MPIR_ERRTEST_COMM(comm, mpi_errno);
if (mpi_errno != MPI_SUCCESS) goto fn_fail;
}
MPID_END_ERROR_CHECKS;
}
# endif /* HAVE_ERROR_CHECKING */
/* Convert MPI object handles to object pointers */
MPID_Comm_get_ptr( comm, comm_ptr );
/* Validate parameters and objects (post conversion) */
# ifdef HAVE_ERROR_CHECKING
{
MPID_BEGIN_ERROR_CHECKS;
{
/* Validate comm_ptr */
MPID_Comm_valid_ptr( comm_ptr, mpi_errno );
/* If comm_ptr is not valid, it will be reset to null */
MPIR_ERRTEST_ARGNULL(newcomm, "newcomm", mpi_errno);
if (mpi_errno) goto fn_fail;
}
MPID_END_ERROR_CHECKS;
}
# endif /* HAVE_ERROR_CHECKING */
/* ... body of routine ... */
mpi_errno = MPIR_Comm_dup_impl(comm_ptr, &newcomm_ptr);
if (mpi_errno) MPIU_ERR_POP(mpi_errno);
MPIU_OBJ_PUBLISH_HANDLE(*newcomm, newcomm_ptr->handle);
#if defined(_OSU_MVAPICH_) || defined(_OSU_PSM_)
if (enable_shmem_collectives){
if (check_split_comm(pthread_self())){
if (*newcomm != MPI_COMM_NULL){
int flag;
PMPI_Comm_test_inter(*newcomm, &flag);
if (flag == 0){
int my_id, size;
mpi_errno = PMPI_Comm_rank(*newcomm, &my_id);
if(mpi_errno) {
MPIU_ERR_POP(mpi_errno);
}
mpi_errno = PMPI_Comm_size(*newcomm, &size);
if(mpi_errno) {
MPIU_ERR_POP(mpi_errno);
}
disable_split_comm(pthread_self());
mpi_errno = create_2level_comm(*newcomm, size, my_id);
if(mpi_errno) {
MPIU_ERR_POP(mpi_errno);
}
enable_split_comm(pthread_self());
}
}
}
}
#endif /* defined(_OSU_MVAPICH_) || defined(_OSU_PSM_) */
/* ... end of body of routine ... */
fn_exit:
MPID_MPI_FUNC_EXIT(MPID_STATE_MPI_COMM_DUP);
MPIU_THREAD_CS_EXIT(ALLFUNC,);
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_comm_dup",
"**mpi_comm_dup %C %p", comm, newcomm);
}
# endif
*newcomm = MPI_COMM_NULL;
mpi_errno = MPIR_Err_return_comm( comm_ptr, FCNAME, mpi_errno );
goto fn_exit;
/* --END ERROR HANDLING-- */
}
int MPI_Comm_test_inter(MPI_Comm comm, int* flag) {
return PMPI_Comm_test_inter(comm, flag);
}
