/*@
MPI_Group_compare - Compares two groups
Input Parameters:
+ group1 - group1 (handle)
- group2 - group2 (handle)
Output Parameters:
. result - integer which is 'MPI_IDENT' if the order and members of
the two groups are the same, 'MPI_SIMILAR' if only the members are the same,
and 'MPI_UNEQUAL' otherwise
.N ThreadSafe
.N Fortran
.N Errors
.N MPI_SUCCESS
.N MPI_ERR_GROUP
.N MPI_ERR_ARG
@*/
int MPI_Group_compare(MPI_Group group1, MPI_Group group2, int *result)
{
int mpi_errno = MPI_SUCCESS;
MPID_Group *group_ptr1 = NULL;
MPID_Group *group_ptr2 = NULL;
MPID_MPI_STATE_DECL(MPID_STATE_MPI_GROUP_COMPARE);
MPIR_ERRTEST_INITIALIZED_ORDIE();
/* The routines that setup the group data structures must be executed
within a mutex. As most of the group routines are not performance
critical, we simple run these routines within the SINGLE_CS */
MPIU_THREAD_CS_ENTER(ALLFUNC,);
MPID_MPI_FUNC_ENTER(MPID_STATE_MPI_GROUP_COMPARE);
/* Validate parameters, especially handles needing to be converted */
# ifdef HAVE_ERROR_CHECKING
{
MPID_BEGIN_ERROR_CHECKS;
{
MPIR_ERRTEST_ARGNULL( result, "result", mpi_errno );
MPIR_ERRTEST_GROUP(group1, mpi_errno);
MPIR_ERRTEST_GROUP(group2, mpi_errno);
}
MPID_END_ERROR_CHECKS;
}
# endif
/* Convert MPI object handles to object pointers */
MPID_Group_get_ptr( group1, group_ptr1 );
MPID_Group_get_ptr( group2, group_ptr2 );
/* Validate parameters and objects (post conversion) */
# ifdef HAVE_ERROR_CHECKING
{
MPID_BEGIN_ERROR_CHECKS;
{
/* Validate group_ptr */
MPID_Group_valid_ptr( group_ptr1, mpi_errno );
MPID_Group_valid_ptr( group_ptr2, mpi_errno );
/* If group_ptr is not valid, it will be reset to null */
if (mpi_errno) goto fn_fail;
}
MPID_END_ERROR_CHECKS;
}
# endif /* HAVE_ERROR_CHECKING */
/* ... body of routine ... */
mpi_errno = MPIR_Group_compare_impl(group_ptr1, group_ptr2, result);
if (mpi_errno) MPIU_ERR_POP(mpi_errno);
/* ... end of body of routine ... */
fn_exit:
MPID_MPI_FUNC_EXIT(MPID_STATE_MPI_GROUP_COMPARE);
MPIU_THREAD_CS_EXIT(ALLFUNC,);
return mpi_errno;
/* --BEGIN ERROR HANDLING-- */
fn_fail:
{
mpi_errno = MPIR_Err_create_code(
mpi_errno, MPIR_ERR_RECOVERABLE, FCNAME, __LINE__, MPI_ERR_OTHER,
"**mpi_group_compare",
"**mpi_group_compare %G %G %p", group1, group2, result);
}
mpi_errno = MPIR_Err_return_comm( NULL, FCNAME, mpi_errno );
goto fn_exit;
/* --END ERROR HANDLING-- */
}
/*@
MPI_Group_range_incl - Creates a new group from ranges of ranks in an
existing group
Input Parameters:
+ group - group (handle)
. n - number of triplets in array 'ranges' (integer)
- ranges - a one-dimensional array of integer triplets, of the
form (first rank, last rank, stride) indicating ranks in
'group' or processes to be included in 'newgroup'.
Output Parameters:
. newgroup - new group derived from above, in the
order defined by 'ranges' (handle)
.N ThreadSafe
.N Fortran
.N Errors
.N MPI_SUCCESS
.N MPI_ERR_GROUP
.N MPI_ERR_EXHAUSTED
.N MPI_ERR_ARG
.N MPI_ERR_RANK
.seealso: MPI_Group_free
@*/
int MPI_Group_range_incl(MPI_Group group, int n, int ranges[][3],
MPI_Group *newgroup)
{
int mpi_errno = MPI_SUCCESS;
MPID_Group *group_ptr = NULL, *new_group_ptr;
MPID_MPI_STATE_DECL(MPID_STATE_MPI_GROUP_RANGE_INCL);
MPIR_ERRTEST_INITIALIZED_ORDIE();
MPID_THREAD_CS_ENTER(GLOBAL, MPIR_THREAD_GLOBAL_ALLFUNC_MUTEX);
MPID_MPI_FUNC_ENTER(MPID_STATE_MPI_GROUP_RANGE_INCL);
/* Validate parameters, especially handles needing to be converted */
# ifdef HAVE_ERROR_CHECKING
{
MPID_BEGIN_ERROR_CHECKS;
{
MPIR_ERRTEST_GROUP(group, mpi_errno);
}
MPID_END_ERROR_CHECKS;
}
# endif
/* Convert MPI object handles to object pointers */
MPID_Group_get_ptr( group, group_ptr );
/* Validate parameters and objects (post conversion) */
# ifdef HAVE_ERROR_CHECKING
{
MPID_BEGIN_ERROR_CHECKS;
{
/* Validate group_ptr */
MPID_Group_valid_ptr( group_ptr, mpi_errno );
/* If group_ptr is not value, it will be reset to null */
if (group_ptr) {
mpi_errno = MPIR_Group_check_valid_ranges( group_ptr,
ranges, n );
}
if (mpi_errno) goto fn_fail;
}
MPID_END_ERROR_CHECKS;
}
# endif /* HAVE_ERROR_CHECKING */
/* ... body of routine ... */
mpi_errno = MPIR_Group_range_incl_impl(group_ptr, n, ranges, &new_group_ptr);
if (mpi_errno) goto fn_fail;
MPIR_OBJ_PUBLISH_HANDLE(*newgroup, new_group_ptr->handle);
/* ... end of body of routine ... */
fn_exit:
MPID_MPI_FUNC_EXIT(MPID_STATE_MPI_GROUP_RANGE_INCL);
MPID_THREAD_CS_EXIT(GLOBAL, MPIR_THREAD_GLOBAL_ALLFUNC_MUTEX);
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_group_range_incl",
"**mpi_group_range_incl %G %d %p %p", group, n, ranges, newgroup);
}
# endif
mpi_errno = MPIR_Err_return_comm( NULL, FCNAME, mpi_errno );
goto fn_exit;
/* --END ERROR HANDLING-- */
}
/*@
MPI_Group_free - Frees a group
Input Parameters:
. group - group to free (handle)
Notes:
On output, group is set to 'MPI_GROUP_NULL'.
.N ThreadSafe
.N Fortran
.N Errors
.N MPI_SUCCESS
.N MPI_ERR_ARG
.N MPI_ERR_PERM_GROUP
@*/
int MPI_Group_free(MPI_Group *group)
{
int mpi_errno = MPI_SUCCESS;
MPID_Group *group_ptr = NULL;
MPID_MPI_STATE_DECL(MPID_STATE_MPI_GROUP_FREE);
MPIR_ERRTEST_INITIALIZED_ORDIE();
MPID_THREAD_CS_ENTER(GLOBAL, MPIR_THREAD_GLOBAL_ALLFUNC_MUTEX);
MPID_MPI_FUNC_ENTER(MPID_STATE_MPI_GROUP_FREE);
/* Validate parameters, especially handles needing to be converted */
# ifdef HAVE_ERROR_CHECKING
{
MPID_BEGIN_ERROR_CHECKS;
{
MPIR_ERRTEST_GROUP(*group, mpi_errno);
}
MPID_END_ERROR_CHECKS;
}
# endif
/* Convert MPI object handles to object pointers */
MPID_Group_get_ptr( *group, group_ptr );
/* Validate parameters and objects (post conversion) */
# ifdef HAVE_ERROR_CHECKING
{
MPID_BEGIN_ERROR_CHECKS;
{
/* Validate group_ptr */
MPID_Group_valid_ptr( group_ptr, mpi_errno );
/* If group_ptr is not valid, it will be reset to null */
/* Cannot free the predefined groups, but allow GROUP_EMPTY
because otherwise many tests fail */
if ((HANDLE_GET_KIND(*group) == HANDLE_KIND_BUILTIN) &&
*group != MPI_GROUP_EMPTY) {
mpi_errno = MPIR_Err_create_code( MPI_SUCCESS,
MPIR_ERR_RECOVERABLE, FCNAME, __LINE__, MPI_ERR_GROUP,
"**groupperm", 0);
}
if (mpi_errno) goto fn_fail;
}
MPID_END_ERROR_CHECKS;
}
# endif /* HAVE_ERROR_CHECKING */
/* ... body of routine ... */
mpi_errno = MPIR_Group_free_impl(group_ptr);
*group = MPI_GROUP_NULL;
if (mpi_errno != MPI_SUCCESS) goto fn_fail;
/* ... end of body of routine ... */
fn_exit:
MPID_MPI_FUNC_EXIT(MPID_STATE_MPI_GROUP_FREE);
MPID_THREAD_CS_EXIT(GLOBAL, MPIR_THREAD_GLOBAL_ALLFUNC_MUTEX);
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_group_free", "**mpi_group_free %p", group);
}
# endif
mpi_errno = MPIR_Err_return_comm( NULL, FCNAME, mpi_errno );
goto fn_exit;
/* --END ERROR HANDLING-- */
}
/*@
MPI_Win_post - Start an RMA exposure epoch
Input Parameters:
+ group - group of origin processes (handle)
. assert - Used to optimize this call; zero may be used as a default.
See notes. (integer)
- win - window object (handle)
Notes:
The 'assert' argument is used to indicate special conditions for the
fence that an implementation may use to optimize the 'MPI_Win_post'
operation. The value zero is always correct. Other assertion values
may be or''ed together. Assertions that are valid for 'MPI_Win_post' are\:
+ MPI_MODE_NOCHECK - the matching calls to 'MPI_WIN_START' have not yet
occurred on any origin processes when the call to 'MPI_WIN_POST' is made.
The nocheck option can be specified by a post call if and only if it is
specified by each matching start call.
. MPI_MODE_NOSTORE - the local window was not updated by local stores (or
local get or receive calls) since last synchronization. This may avoid
the need for cache synchronization at the post call.
- MPI_MODE_NOPUT - the local window will not be updated by put or accumulate
calls after the post call, until the ensuing (wait) synchronization. This
may avoid the need for cache synchronization at the wait call.
.N Fortran
.N Errors
.N MPI_SUCCESS
@*/
int MPI_Win_post(MPI_Group group, int assert, MPI_Win win)
{
static const char FCNAME[] = "MPI_Win_post";
int mpi_errno = MPI_SUCCESS;
MPID_Win *win_ptr = NULL;
MPID_Group *group_ptr=NULL;
MPID_MPI_STATE_DECL(MPID_STATE_MPI_WIN_POST);
MPIR_ERRTEST_INITIALIZED_ORDIE();
MPIU_THREAD_CS_ENTER(ALLFUNC,);
MPID_MPI_RMA_FUNC_ENTER(MPID_STATE_MPI_WIN_POST);
/* Validate parameters, especially handles needing to be converted */
# ifdef HAVE_ERROR_CHECKING
{
MPID_BEGIN_ERROR_CHECKS;
{
MPIR_ERRTEST_WIN(win, mpi_errno);
MPIR_ERRTEST_GROUP(group, mpi_errno);
}
MPID_END_ERROR_CHECKS;
}
# endif
/* Convert MPI object handles to object pointers */
MPID_Win_get_ptr( win, win_ptr );
MPID_Group_get_ptr(group, group_ptr);
/* Validate parameters and objects (post conversion) */
# ifdef HAVE_ERROR_CHECKING
{
MPID_BEGIN_ERROR_CHECKS;
{
/* Validate win_ptr */
MPID_Win_valid_ptr( win_ptr, mpi_errno );
MPID_Group_valid_ptr(group_ptr, mpi_errno);
/* TODO: Validate assert argument */
/* TODO: Validate that window is not in passive mode */
if (mpi_errno) goto fn_fail;
}
MPID_END_ERROR_CHECKS;
}
# endif /* HAVE_ERROR_CHECKING */
/* ... body of routine ... */
mpi_errno = MPIU_RMA_CALL(win_ptr,Win_post(group_ptr, assert, win_ptr));
if (mpi_errno != MPI_SUCCESS) goto fn_fail;
/* ... end of body of routine ... */
fn_exit:
MPID_MPI_RMA_FUNC_EXIT(MPID_STATE_MPI_WIN_POST);
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_win_post",
"**mpi_win_post %G %A %W", group, assert, win);
}
# endif
mpi_errno = MPIR_Err_return_win( win_ptr, FCNAME, mpi_errno );
goto fn_exit;
/* --END ERROR HANDLING-- */
}
/*@
MPI_Group_excl - Produces a group by reordering an existing group and taking
only unlisted members
Input Parameters:
+ group - group (handle)
. n - number of elements in array 'ranks' (integer)
- ranks - array of integer ranks in 'group' not to appear in 'newgroup'
Output Parameter:
. newgroup - new group derived from above, preserving the order defined by
'group' (handle)
Note:
The MPI standard requires that each of the ranks to excluded must be
a valid rank in the group and all elements must be distinct or the
function is erroneous.
.N ThreadSafe
.N Fortran
.N Errors
.N MPI_SUCCESS
.N MPI_ERR_GROUP
.N MPI_ERR_EXHAUSTED
.N MPI_ERR_ARG
.N MPI_ERR_RANK
.seealso: MPI_Group_free
@*/
int MPI_Group_excl(MPI_Group group, int n, int *ranks, MPI_Group *newgroup)
{
static const char FCNAME[] = "MPI_Group_excl";
int mpi_errno = MPI_SUCCESS;
MPID_Group *group_ptr = NULL, *new_group_ptr;
int size, i, newi;
MPID_MPI_STATE_DECL(MPID_STATE_MPI_GROUP_EXCL);
MPIR_ERRTEST_INITIALIZED_ORDIE();
MPIU_THREAD_CS_ENTER(ALLFUNC,);
MPID_MPI_FUNC_ENTER(MPID_STATE_MPI_GROUP_EXCL);
/* Validate parameters, especially handles needing to be converted */
# ifdef HAVE_ERROR_CHECKING
{
MPID_BEGIN_ERROR_CHECKS;
{
MPIR_ERRTEST_GROUP(group, mpi_errno);
MPIR_ERRTEST_ARGNEG(n,"n",mpi_errno);
if (mpi_errno != MPI_SUCCESS) goto fn_fail;
}
MPID_END_ERROR_CHECKS;
}
# endif
/* Convert MPI object handles to object pointers */
MPID_Group_get_ptr( group, group_ptr );
# ifdef HAVE_ERROR_CHECKING
{
MPID_BEGIN_ERROR_CHECKS;
{
/* Validate group_ptr */
MPID_Group_valid_ptr( group_ptr, mpi_errno );
/* If group_ptr is not valid, it will be reset to null */
if (group_ptr) {
mpi_errno = MPIR_Group_check_valid_ranks( group_ptr,
ranks, n );
}
if (mpi_errno) goto fn_fail;
}
MPID_END_ERROR_CHECKS;
}
# endif /* HAVE_ERROR_CHECKING */
/* ... body of routine ... */
/* Allocate a new group and lrank_to_lpid array */
size = group_ptr->size;
if (size == n) {
*newgroup = MPI_GROUP_EMPTY;
goto fn_exit;
}
mpi_errno = MPIR_Group_create( size - n, &new_group_ptr );
/* --BEGIN ERROR HANDLING-- */
if (mpi_errno)
{
goto fn_fail;
}
/* --END ERROR HANDLING-- */
new_group_ptr->rank = MPI_UNDEFINED;
/* Use flag fields to mark the members to *exclude* . */
for (i=0; i<size; i++) {
group_ptr->lrank_to_lpid[i].flag = 0;
}
for (i=0; i<n; i++) {
group_ptr->lrank_to_lpid[ranks[i]].flag = 1;
}
newi = 0;
for (i=0; i<size; i++) {
if (group_ptr->lrank_to_lpid[i].flag == 0) {
new_group_ptr->lrank_to_lpid[newi].lrank = newi;
new_group_ptr->lrank_to_lpid[newi].lpid =
group_ptr->lrank_to_lpid[i].lpid;
if (group_ptr->rank == i) new_group_ptr->rank = newi;
newi++;
}
}
new_group_ptr->size = size - n;
new_group_ptr->idx_of_first_lpid = -1;
/* TODO calculate is_local_dense_monotonic */
MPIU_OBJ_PUBLISH_HANDLE(*newgroup, new_group_ptr->handle);
/* ... end of body of routine ... */
fn_exit:
MPID_MPI_FUNC_EXIT(MPID_STATE_MPI_GROUP_EXCL);
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_group_excl",
"**mpi_group_excl %G %d %p %p", group, n, ranks, newgroup);
}
# endif
mpi_errno = MPIR_Err_return_comm( NULL, FCNAME, mpi_errno );
goto fn_exit;
/* --END ERROR HANDLING-- */
}
/*@
MPI_Group_intersection - Produces a group as the intersection of two existing
groups
Input Parameters:
+ group1 - first group (handle)
- group2 - second group (handle)
Output Parameters:
. newgroup - intersection group (handle)
Notes:
The output group contains those processes that are in both 'group1' and
'group2'.
.N ThreadSafe
.N Fortran
.N Errors
.N MPI_SUCCESS
.N MPI_ERR_GROUP
.N MPI_ERR_EXHAUSTED
.seealso: MPI_Group_free
@*/
int MPI_Group_intersection(MPI_Group group1, MPI_Group group2, MPI_Group *newgroup)
{
int mpi_errno = MPI_SUCCESS;
MPID_Group *group_ptr1 = NULL;
MPID_Group *group_ptr2 = NULL;
MPID_Group *new_group_ptr;
MPID_MPI_STATE_DECL(MPID_STATE_MPI_GROUP_INTERSECTION);
MPIR_ERRTEST_INITIALIZED_ORDIE();
MPIU_THREAD_CS_ENTER(ALLFUNC,);
MPID_MPI_FUNC_ENTER(MPID_STATE_MPI_GROUP_INTERSECTION);
/* Validate parameters, especially handles needing to be converted */
# ifdef HAVE_ERROR_CHECKING
{
MPID_BEGIN_ERROR_CHECKS;
{
MPIR_ERRTEST_GROUP(group1, mpi_errno);
MPIR_ERRTEST_GROUP(group2, mpi_errno);
}
MPID_END_ERROR_CHECKS;
}
# endif
/* Convert MPI object handles to object pointers */
MPID_Group_get_ptr( group1, group_ptr1 );
MPID_Group_get_ptr( group2, group_ptr2 );
/* Validate parameters and objects (post conversion) */
# ifdef HAVE_ERROR_CHECKING
{
MPID_BEGIN_ERROR_CHECKS;
{
/* Validate group_ptr */
MPID_Group_valid_ptr( group_ptr1, mpi_errno );
MPID_Group_valid_ptr( group_ptr2, mpi_errno );
/* If either group_ptr is not valid, it will be reset to null */
if (mpi_errno) goto fn_fail;
}
MPID_END_ERROR_CHECKS;
}
# endif /* HAVE_ERROR_CHECKING */
/* ... body of routine ... */
mpi_errno = MPIR_Group_intersection_impl(group_ptr1, group_ptr2, &new_group_ptr);
if (mpi_errno) goto fn_fail;
MPIU_OBJ_PUBLISH_HANDLE(*newgroup, new_group_ptr->handle);
/* ... end of body of routine ... */
fn_exit:
MPID_MPI_FUNC_EXIT(MPID_STATE_MPI_GROUP_INTERSECTION);
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_group_intersection",
"**mpi_group_intersection %G %G %p", group1, group2, newgroup);
}
# endif
mpi_errno = MPIR_Err_return_comm( NULL, FCNAME, mpi_errno );
goto fn_exit;
/* --END ERROR HANDLING-- */
}
/*@
MPI_Group_difference - Makes a group from the difference of two groups
Input Parameters:
+ group1 - first group (handle)
- group2 - second group (handle)
Output Parameter:
. newgroup - difference group (handle)
Notes:
The generated group containc the members of 'group1' that are not in 'group2'.
.N ThreadSafe
.N Fortran
.N Errors
.N MPI_SUCCESS
.N MPI_ERR_GROUP
.N MPI_ERR_EXHAUSTED
.seealso: MPI_Group_free
@*/
int MPI_Group_difference(MPI_Group group1, MPI_Group group2, MPI_Group *newgroup)
{
static const char FCNAME[] = "MPI_Group_difference";
int mpi_errno = MPI_SUCCESS;
MPID_Group *group_ptr1 = NULL;
MPID_Group *group_ptr2 = NULL;
MPID_Group *new_group_ptr;
int size1, i, k, g1_idx, g2_idx, l1_pid, l2_pid, nnew;
MPID_MPI_STATE_DECL(MPID_STATE_MPI_GROUP_DIFFERENCE);
MPIR_ERRTEST_INITIALIZED_ORDIE();
MPIU_THREAD_CS_ENTER(ALLFUNC,);
MPID_MPI_FUNC_ENTER(MPID_STATE_MPI_GROUP_DIFFERENCE);
/* Validate parameters, especially handles needing to be converted */
# ifdef HAVE_ERROR_CHECKING
{
MPID_BEGIN_ERROR_CHECKS;
{
MPIR_ERRTEST_GROUP(group1, mpi_errno);
MPIR_ERRTEST_GROUP(group2, mpi_errno);
if (mpi_errno != MPI_SUCCESS) goto fn_fail;
}
MPID_END_ERROR_CHECKS;
}
# endif
/* Convert MPI object handles to object pointers */
MPID_Group_get_ptr( group1, group_ptr1 );
MPID_Group_get_ptr( group2, group_ptr2 );
/* Validate parameters and objects (post conversion) */
# ifdef HAVE_ERROR_CHECKING
{
MPID_BEGIN_ERROR_CHECKS;
{
/* Validate group_ptr */
MPID_Group_valid_ptr( group_ptr1, mpi_errno );
MPID_Group_valid_ptr( group_ptr2, mpi_errno );
/* If either group_ptr is not valid, it will be reset to null */
if (mpi_errno) goto fn_fail;
}
MPID_END_ERROR_CHECKS;
}
# endif /* HAVE_ERROR_CHECKING */
/* ... body of routine ... */
/* Return a group consisting of the members of group1 that are *not*
in group2 */
size1 = group_ptr1->size;
/* Insure that the lpid lists are setup */
MPIR_Group_setup_lpid_pairs( group_ptr1, group_ptr2 );
for (i=0; i<size1; i++) {
group_ptr1->lrank_to_lpid[i].flag = 0;
}
g1_idx = group_ptr1->idx_of_first_lpid;
g2_idx = group_ptr2->idx_of_first_lpid;
nnew = size1;
while (g1_idx >= 0 && g2_idx >= 0) {
l1_pid = group_ptr1->lrank_to_lpid[g1_idx].lpid;
l2_pid = group_ptr2->lrank_to_lpid[g2_idx].lpid;
if (l1_pid < l2_pid) {
g1_idx = group_ptr1->lrank_to_lpid[g1_idx].next_lpid;
}
else if (l1_pid > l2_pid) {
g2_idx = group_ptr2->lrank_to_lpid[g2_idx].next_lpid;
}
else {
/* Equal */
group_ptr1->lrank_to_lpid[g1_idx].flag = 1;
g1_idx = group_ptr1->lrank_to_lpid[g1_idx].next_lpid;
g2_idx = group_ptr2->lrank_to_lpid[g2_idx].next_lpid;
nnew --;
}
}
/* Create the group */
if (nnew == 0) {
/* See 5.3.2, Group Constructors. For many group routines,
the standard explicitly says to return MPI_GROUP_EMPTY;
for others it is implied */
*newgroup = MPI_GROUP_EMPTY;
goto fn_exit;
}
else {
mpi_errno = MPIR_Group_create( nnew, &new_group_ptr );
/* --BEGIN ERROR HANDLING-- */
if (mpi_errno) {
goto fn_fail;
}
/* --END ERROR HANDLING-- */
new_group_ptr->rank = MPI_UNDEFINED;
k = 0;
for (i=0; i<size1; i++) {
if (!group_ptr1->lrank_to_lpid[i].flag) {
new_group_ptr->lrank_to_lpid[k].lrank = k;
new_group_ptr->lrank_to_lpid[k].lpid =
group_ptr1->lrank_to_lpid[i].lpid;
if (i == group_ptr1->rank)
new_group_ptr->rank = k;
k++;
}
}
/* TODO calculate is_local_dense_monotonic */
}
MPIU_OBJ_PUBLISH_HANDLE(*newgroup, new_group_ptr->handle);
/* ... end of body of routine ... */
fn_exit:
MPID_MPI_FUNC_EXIT(MPID_STATE_MPI_GROUP_DIFFERENCE);
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_group_difference",
"**mpi_group_difference %G %G %p", group1, group2, newgroup);
}
# endif
mpi_errno = MPIR_Err_return_comm( NULL, FCNAME, mpi_errno );
goto fn_exit;
/* --END ERROR HANDLING-- */
}
/*@
MPI_Group_translate_ranks - Translates the ranks of processes in one group to
those in another group
Input Parameters:
+ group1 - group1 (handle)
. n - number of ranks in 'ranks1' and 'ranks2' arrays (integer)
. ranks1 - array of zero or more valid ranks in 'group1'
- group2 - group2 (handle)
Output Parameters:
. ranks2 - array of corresponding ranks in group2, 'MPI_UNDEFINED' when no
correspondence exists.
As a special case (see the MPI-2 errata), if the input rank is
'MPI_PROC_NULL', 'MPI_PROC_NULL' is given as the output rank.
.N ThreadSafe
.N Fortran
.N Errors
.N MPI_SUCCESS
@*/
int MPI_Group_translate_ranks(MPI_Group group1, int n, const int ranks1[],
MPI_Group group2, int ranks2[])
{
int mpi_errno = MPI_SUCCESS;
MPID_Group *group_ptr1 = NULL;
MPID_Group *group_ptr2 = NULL;
MPID_MPI_STATE_DECL(MPID_STATE_MPI_GROUP_TRANSLATE_RANKS);
MPIR_ERRTEST_INITIALIZED_ORDIE();
/* The routines that setup the group data structures must be executed
within a mutex. As most of the group routines are not performance
critical, we simple run these routines within the SINGLE_CS */
MPIU_THREAD_CS_ENTER(ALLFUNC,);
MPID_MPI_FUNC_ENTER(MPID_STATE_MPI_GROUP_TRANSLATE_RANKS);
/* Validate parameters, especially handles needing to be converted */
# ifdef HAVE_ERROR_CHECKING
{
MPID_BEGIN_ERROR_CHECKS;
{
MPIR_ERRTEST_GROUP(group1, mpi_errno);
MPIR_ERRTEST_GROUP(group2, mpi_errno);
}
MPID_END_ERROR_CHECKS;
}
# endif
/* Convert MPI object handles to object pointers */
MPID_Group_get_ptr( group1, group_ptr1 );
MPID_Group_get_ptr( group2, group_ptr2 );
/* Validate parameters and objects (post conversion) */
# ifdef HAVE_ERROR_CHECKING
{
MPID_BEGIN_ERROR_CHECKS;
{
/* Validate group_ptr */
MPID_Group_valid_ptr( group_ptr1, mpi_errno );
MPID_Group_valid_ptr( group_ptr2, mpi_errno );
/* If either group_ptr is not valid, it will be reset to null */
MPIR_ERRTEST_ARGNEG(n,"n",mpi_errno);
if (group_ptr1) {
/* Check that the rank entries are valid */
int size1 = group_ptr1->size;
int i;
for (i=0; i<n; i++) {
if ( (ranks1[i] < 0 && ranks1[i] != MPI_PROC_NULL) ||
ranks1[i] >= size1) {
mpi_errno = MPIR_Err_create_code( MPI_SUCCESS,
MPIR_ERR_RECOVERABLE, FCNAME, __LINE__,
MPI_ERR_RANK,
"**rank", "**rank %d %d",
ranks1[i], size1 );
goto fn_fail;
}
}
}
}
MPID_END_ERROR_CHECKS;
}
# endif /* HAVE_ERROR_CHECKING */
/* ... body of routine ... */
mpi_errno = MPIR_Group_translate_ranks_impl(group_ptr1, n, ranks1, group_ptr2, ranks2);
if (mpi_errno) MPIU_ERR_POP(mpi_errno);
/* ... end of body of routine ... */
fn_exit:
MPID_MPI_FUNC_EXIT(MPID_STATE_MPI_GROUP_TRANSLATE_RANKS);
MPIU_THREAD_CS_EXIT(ALLFUNC,);
return mpi_errno;
/* --BEGIN ERROR HANDLING-- */
fn_fail:
{
mpi_errno = MPIR_Err_create_code(
mpi_errno, MPIR_ERR_RECOVERABLE, FCNAME, __LINE__, MPI_ERR_OTHER,
"**mpi_group_translate_ranks",
"**mpi_group_translate_ranks %G %d %p %G %p",
group1, n, ranks1, group2, ranks2);
}
mpi_errno = MPIR_Err_return_comm( NULL, FCNAME, mpi_errno );
goto fn_exit;
/* --END ERROR HANDLING-- */
}
