void MPIR_Group_setup_lpid_pairs( MPID_Group *group_ptr1,
MPID_Group *group_ptr2 )
{
/* If the lpid list hasn't been created, do it now */
if (group_ptr1->idx_of_first_lpid < 0) {
MPIR_Group_setup_lpid_list( group_ptr1 );
}
if (group_ptr2->idx_of_first_lpid < 0) {
MPIR_Group_setup_lpid_list( group_ptr2 );
}
}
int MPIR_Group_compare_impl(MPID_Group *group_ptr1, MPID_Group *group_ptr2, int *result)
{
int mpi_errno = MPI_SUCCESS;
int g1_idx, g2_idx, size, i;
/* See if their sizes are equal */
if (group_ptr1->size != group_ptr2->size) {
*result = MPI_UNEQUAL;
goto fn_exit;
}
/* Run through the lrank to lpid lists of each group in lpid order
to see if the same processes are involved */
g1_idx = group_ptr1->idx_of_first_lpid;
g2_idx = group_ptr2->idx_of_first_lpid;
/* If the lpid list hasn't been created, do it now */
if (g1_idx < 0) {
MPIR_Group_setup_lpid_list( group_ptr1 );
g1_idx = group_ptr1->idx_of_first_lpid;
}
if (g2_idx < 0) {
MPIR_Group_setup_lpid_list( group_ptr2 );
g2_idx = group_ptr2->idx_of_first_lpid;
}
while (g1_idx >= 0 && g2_idx >= 0) {
if (group_ptr1->lrank_to_lpid[g1_idx].lpid !=
group_ptr2->lrank_to_lpid[g2_idx].lpid) {
*result = MPI_UNEQUAL;
goto fn_exit;
}
g1_idx = group_ptr1->lrank_to_lpid[g1_idx].next_lpid;
g2_idx = group_ptr2->lrank_to_lpid[g2_idx].next_lpid;
}
/* See if the processes are in the same order by rank */
size = group_ptr1->size;
for (i=0; i<size; i++) {
if (group_ptr1->lrank_to_lpid[i].lpid !=
group_ptr2->lrank_to_lpid[i].lpid) {
*result = MPI_SIMILAR;
goto fn_exit;
}
}
/* If we reach here, the groups are identical */
*result = MPI_IDENT;
fn_exit:
return mpi_errno;
fn_fail:
goto fn_exit;
}
void MPITEST_Group_print( MPI_Group g )
{
MPID_Group *g_ptr;
int g_idx, size, i;
MPID_Group_get_ptr( g, g_ptr );
g_idx = g_ptr->idx_of_first_lpid;
if (g_idx < 0) {
MPIR_Group_setup_lpid_list( g_ptr );
g_idx = g_ptr->idx_of_first_lpid;
}
/* Loop through these, printing the lpids by rank and in order */
size = g_ptr->size;
fprintf( stdout, "Lpids in rank order\n" );
for (i=0; i<size; i++) {
fprintf( stdout, "Rank %d has lpid %d\n",
i, g_ptr->lrank_to_lpid[i].lpid );
}
fprintf( stdout, "Ranks in lpid order\n" );
while (g_idx >= 0) {
fprintf( stdout, "Rank %d has lpid %d\n", g_idx,
g_ptr->lrank_to_lpid[g_idx].lpid );
g_idx = g_ptr->lrank_to_lpid[g_idx].next_lpid;
}
}
int MPIR_Comm_create_calculate_mapping(MPID_Group *group_ptr,
MPID_Comm *comm_ptr,
int **mapping_out,
MPID_Comm **mapping_comm)
{
int mpi_errno = MPI_SUCCESS;
int subsetOfWorld = 0;
int i, j;
int n;
int *mapping=0;
MPIU_CHKPMEM_DECL(1);
MPID_MPI_STATE_DECL(MPID_STATE_MPIR_COMM_CREATE_CALCULATE_MAPPING);
MPID_MPI_FUNC_ENTER(MPID_STATE_MPIR_COMM_CREATE_CALCULATE_MAPPING);
*mapping_out = NULL;
*mapping_comm = comm_ptr;
n = group_ptr->size;
MPIU_CHKPMEM_MALLOC(mapping,int*,n*sizeof(int),mpi_errno,"mapping");
/* Make sure that the processes for this group are contained within
the input communicator. Also identify the mapping from the ranks of
the old communicator to the new communicator.
We do this by matching the lpids of the members of the group
with the lpids of the members of the input communicator.
It is an error if the group contains a reference to an lpid that
does not exist in the communicator.
An important special case is groups (and communicators) that
are subsets of MPI_COMM_WORLD. In this case, the lpids are
exactly the same as the ranks in comm world.
*/
/* we examine the group's lpids in both the intracomm and non-comm_world cases */
MPIR_Group_setup_lpid_list( group_ptr );
/* Optimize for groups contained within MPI_COMM_WORLD. */
if (comm_ptr->comm_kind == MPID_INTRACOMM) {
int wsize;
subsetOfWorld = 1;
wsize = MPIR_Process.comm_world->local_size;
for (i=0; i<n; i++) {
int g_lpid = group_ptr->lrank_to_lpid[i].lpid;
/* This mapping is relative to comm world */
MPL_DBG_MSG_FMT(MPIR_DBG_COMM,VERBOSE,
(MPL_DBG_FDEST,
"comm-create - mapping into world[%d] = %d",
i, g_lpid ));
if (g_lpid < wsize) {
mapping[i] = g_lpid;
}
else {
subsetOfWorld = 0;
break;
}
}
}
MPL_DBG_MSG_D(MPIR_DBG_COMM,VERBOSE, "subsetOfWorld=%d", subsetOfWorld );
if (subsetOfWorld) {
# ifdef HAVE_ERROR_CHECKING
{
MPID_BEGIN_ERROR_CHECKS;
{
mpi_errno = MPIR_Group_check_subset( group_ptr, comm_ptr );
if (mpi_errno) MPIR_ERR_POP(mpi_errno);
}
MPID_END_ERROR_CHECKS;
}
# endif
/* Override the comm to be used with the mapping array. */
*mapping_comm = MPIR_Process.comm_world;
}
else {
for (i=0; i<n; i++) {
/* mapping[i] is the rank in the communicator of the process
that is the ith element of the group */
/* FIXME : BUBBLE SORT */
mapping[i] = -1;
for (j=0; j<comm_ptr->local_size; j++) {
int comm_lpid;
MPID_Comm_get_lpid( comm_ptr, j, &comm_lpid, FALSE );
if (comm_lpid == group_ptr->lrank_to_lpid[i].lpid) {
mapping[i] = j;
break;
}
}
MPIR_ERR_CHKANDJUMP1(mapping[i] == -1,mpi_errno,MPI_ERR_GROUP,
"**groupnotincomm", "**groupnotincomm %d", i );
}
}
MPIU_Assert(mapping != NULL);
*mapping_out = mapping;
MPL_VG_CHECK_MEM_IS_DEFINED(*mapping_out, n * sizeof(**mapping_out));
MPIU_CHKPMEM_COMMIT();
fn_exit:
MPID_MPI_FUNC_EXIT(MPID_STATE_MPIR_COMM_CREATE_CALCULATE_MAPPING);
return mpi_errno;
fn_fail:
MPIU_CHKPMEM_REAP();
goto fn_exit;
}
PMPI_LOCAL int MPIR_Comm_create_calculate_mapping(MPID_Group *group_ptr,
MPID_Comm *comm_ptr,
MPID_VCR **mapping_vcr_out,
int **mapping_out)
{
int mpi_errno = MPI_SUCCESS;
int subsetOfWorld = 0;
int i, j;
int n;
int *mapping=0;
int vcr_size;
MPID_VCR *vcr;
MPIU_CHKPMEM_DECL(1);
MPID_MPI_STATE_DECL(MPID_STATE_MPIR_COMM_CREATE_CALCULATE_MAPPING);
MPID_MPI_FUNC_ENTER(MPID_STATE_MPIR_COMM_CREATE_CALCULATE_MAPPING);
*mapping_out = NULL;
*mapping_vcr_out = NULL;
/* N.B. For intracomms only the comm_ptr->vcr is valid and populated,
* however local_size and remote_size are always set to the same value for
* intracomms. For intercomms both are valid and populated, with the
* local_vcr holding VCs corresponding to the local_group, local_comm, and
* local_size.
*
* For this mapping calculation we always want the logically local vcr,
* regardless of whether it is stored in the "plain" vcr or local_vcr. */
if (comm_ptr->comm_kind == MPID_INTERCOMM) {
vcr = comm_ptr->local_vcr;
vcr_size = comm_ptr->local_size;
}
else {
vcr = comm_ptr->vcr;
vcr_size = comm_ptr->remote_size;
}
n = group_ptr->size;
MPIU_CHKPMEM_MALLOC(mapping,int*,n*sizeof(int),mpi_errno,"mapping");
/* Make sure that the processes for this group are contained within
the input communicator. Also identify the mapping from the ranks of
the old communicator to the new communicator.
We do this by matching the lpids of the members of the group
with the lpids of the members of the input communicator.
It is an error if the group contains a reference to an lpid that
does not exist in the communicator.
An important special case is groups (and communicators) that
are subsets of MPI_COMM_WORLD. In this case, the lpids are
exactly the same as the ranks in comm world.
*/
/* we examine the group's lpids in both the intracomm and non-comm_world cases */
MPIR_Group_setup_lpid_list( group_ptr );
/* Optimize for groups contained within MPI_COMM_WORLD. */
if (comm_ptr->comm_kind == MPID_INTRACOMM) {
int wsize;
subsetOfWorld = 1;
wsize = MPIR_Process.comm_world->local_size;
for (i=0; i<n; i++) {
int g_lpid = group_ptr->lrank_to_lpid[i].lpid;
/* This mapping is relative to comm world */
MPIU_DBG_MSG_FMT(COMM,VERBOSE,
(MPIU_DBG_FDEST,
"comm-create - mapping into world[%d] = %d\n",
i, g_lpid ));
if (g_lpid < wsize) {
mapping[i] = g_lpid;
}
else {
subsetOfWorld = 0;
break;
}
}
}
MPIU_DBG_MSG_D(COMM,VERBOSE, "subsetOfWorld=%d", subsetOfWorld );
if (subsetOfWorld) {
# ifdef HAVE_ERROR_CHECKING
{
MPID_BEGIN_ERROR_CHECKS;
{
int idx;
mpi_errno = MPIR_GroupCheckVCRSubset( group_ptr, vcr_size, vcr, &idx );
if (mpi_errno) MPIU_ERR_POP(mpi_errno);
}
MPID_END_ERROR_CHECKS;
}
# endif
/* Override the vcr to be used with the mapping array. */
vcr = MPIR_Process.comm_world->vcr;
vcr_size = MPIR_Process.comm_world->local_size;
}
else {
for (i=0; i<n; i++) {
/* mapping[i] is the rank in the communicator of the process
that is the ith element of the group */
/* FIXME : BUBBLE SORT */
mapping[i] = -1;
for (j=0; j<vcr_size; j++) {
int comm_lpid;
MPID_VCR_Get_lpid( vcr[j], &comm_lpid );
if (comm_lpid == group_ptr->lrank_to_lpid[i].lpid) {
mapping[i] = j;
break;
}
}
MPIU_ERR_CHKANDJUMP1(mapping[i] == -1,mpi_errno,MPI_ERR_GROUP,
"**groupnotincomm", "**groupnotincomm %d", i );
}
}
MPIU_Assert(vcr != NULL);
MPIU_Assert(mapping != NULL);
*mapping_vcr_out = vcr;
*mapping_out = mapping;
MPL_VG_CHECK_MEM_IS_DEFINED(*mapping_vcr_out, vcr_size * sizeof(**mapping_vcr_out));
MPL_VG_CHECK_MEM_IS_DEFINED(*mapping_out, n * sizeof(**mapping_out));
MPIU_CHKPMEM_COMMIT();
fn_exit:
MPID_MPI_FUNC_EXIT(MPID_STATE_MPIR_COMM_CREATE_CALCULATE_MAPPING);
return mpi_errno;
fn_fail:
MPIU_CHKPMEM_REAP();
goto fn_exit;
}
int MPIR_Group_translate_ranks_impl(MPID_Group *gp1, int n, const int ranks1[],
MPID_Group *gp2, int ranks2[])
{
int mpi_errno = MPI_SUCCESS;
int i, g2_idx, l1_pid, l2_pid;
MPIU_DBG_MSG_S(OTHER,VERBOSE,"gp2->is_local_dense_monotonic=%s", (gp2->is_local_dense_monotonic ? "TRUE" : "FALSE"));
/* Initialize the output ranks */
for (i=0; i<n; i++)
ranks2[i] = MPI_UNDEFINED;
if (gp2->size > 0 && gp2->is_local_dense_monotonic) {
/* g2 probably == group_of(MPI_COMM_WORLD); use fast, constant-time lookup */
int lpid_offset = gp2->lrank_to_lpid[0].lpid;
MPIU_Assert(lpid_offset >= 0);
for (i = 0; i < n; ++i) {
int g1_lpid;
if (ranks1[i] == MPI_PROC_NULL) {
ranks2[i] = MPI_PROC_NULL;
continue;
}
/* "adjusted" lpid from g1 */
g1_lpid = gp1->lrank_to_lpid[ranks1[i]].lpid - lpid_offset;
if ((g1_lpid >= 0) && (g1_lpid < gp2->size)) {
ranks2[i] = g1_lpid;
}
/* else leave UNDEFINED */
}
}
else {
/* general, slow path; lookup time is dependent on the user-provided rank values! */
g2_idx = gp2->idx_of_first_lpid;
if (g2_idx < 0) {
MPIR_Group_setup_lpid_list( gp2 );
g2_idx = gp2->idx_of_first_lpid;
}
if (g2_idx >= 0) {
/* g2_idx can be < 0 if the g2 group is empty */
l2_pid = gp2->lrank_to_lpid[g2_idx].lpid;
for (i=0; i<n; i++) {
if (ranks1[i] == MPI_PROC_NULL) {
ranks2[i] = MPI_PROC_NULL;
continue;
}
l1_pid = gp1->lrank_to_lpid[ranks1[i]].lpid;
/* Search for this l1_pid in group2. Use the following
optimization: start from the last position in the lpid list
if possible. A more sophisticated version could use a
tree based or even hashed search to speed the translation. */
if (l1_pid < l2_pid || g2_idx < 0) {
/* Start over from the beginning */
g2_idx = gp2->idx_of_first_lpid;
l2_pid = gp2->lrank_to_lpid[g2_idx].lpid;
}
while (g2_idx >= 0 && l1_pid > l2_pid) {
g2_idx = gp2->lrank_to_lpid[g2_idx].next_lpid;
if (g2_idx >= 0)
l2_pid = gp2->lrank_to_lpid[g2_idx].lpid;
else
l2_pid = -1;
}
if (l1_pid == l2_pid)
ranks2[i] = gp2->lrank_to_lpid[g2_idx].lrank;
}
}
}
fn_exit:
return mpi_errno;
fn_fail:
goto fn_exit;
}
