void test_groups_noncollective() {
int *pid_lists[MAX_GROUPS];
int pids[MAXPROC];
int i, nprocs, world_me;
ARMCI_Group group;
int *my_pid_list=NULL, my_grp_size=0;
int ngrps;
MP_BARRIER();
MP_PROCS(&nprocs);
MP_MYID(&world_me);
random_permute(pids, nproc);
ngrps = nprocs/GROUP_SIZE;
for(i=0; i<nprocs/GROUP_SIZE; i++) {
pid_lists[i] = pids + (i*GROUP_SIZE);
}
for(i=0; i<nprocs; i++) {
if(pids[i] == world_me) {
int grp_id = ARMCI_MIN(i/GROUP_SIZE, ngrps-1);
my_pid_list = pid_lists[grp_id];
if(grp_id == ngrps-1)
my_grp_size = GROUP_SIZE + (nprocs%GROUP_SIZE);
else
my_grp_size = GROUP_SIZE;
}
}
qsort(my_pid_list, my_grp_size, sizeof(int), int_compare);
MP_BARRIER();
/*now create all these disjoint groups and test them in parallel*/
ARMCI_Group_create(my_grp_size, my_pid_list, &group);
test_one_group(&group, my_pid_list);
ARMCI_Group_free(&group);
ARMCI_AllFence();
MP_BARRIER();
if(world_me==0){printf("O.K.\n"); fflush(stdout);}
}
/** Destroy a group of ARMCI mutexes. Collective.
*
* @param[in] hdl Handle to the group that should be destroyed.
* @return Zero on success, non-zero otherwise.
*/
int ARMCIX_Destroy_mutexes_hdl(armcix_mutex_hdl_t hdl) {
int i;
for (i = 0; i < hdl->max_count; i++) {
MPI_Win_free(&hdl->windows[i]);
}
if (hdl->bases != NULL) {
for (i = 0; i < hdl->my_count; i++)
MPI_Free_mem(hdl->bases[i]);
free(hdl->bases);
}
ARMCI_Group_free(&hdl->grp);
free(hdl->windows);
free(hdl);
return 0;
}
int main(int argc, char **argv) {
int me, nproc;
int i, *procs;
ARMCI_Group g_world, g_odd, g_even;
MPI_Init(&argc, &argv);
ARMCI_Init();
MPI_Comm_rank(MPI_COMM_WORLD, &me);
MPI_Comm_size(MPI_COMM_WORLD, &nproc);
procs = malloc(sizeof(int) * ( nproc/2 + (nproc % 2 ? 1 : 0 )));
if (me == 0) printf("ARMCI Group test starting on %d procs\n", nproc);
ARMCI_Group_get_world(&g_world);
if (me == 0) printf(" + Creating odd group\n");
for (i = 1; i < nproc; i += 2) {
procs[i/2] = i;
}
ARMCI_Group_create_child(i/2, procs, &g_odd, &g_world);
if (me == 0) printf(" + Creating even group\n");
for (i = 0; i < nproc; i += 2) {
procs[i/2] = i;
}
ARMCI_Group_create_child(i/2, procs, &g_even, &g_world);
/***********************************************************************/
{
int grp_me, grp_nproc;
double t_abs_to_grp, t_grp_to_abs;
const int iter = 1000000;
if (me == 0) {
ARMCI_Group_rank(&g_even, &grp_me);
ARMCI_Group_size(&g_even, &grp_nproc);
t_abs_to_grp = MPI_Wtime();
for (i = 0; i < iter; i++)
ARMCII_Translate_absolute_to_group(&g_even, (grp_me+1) % grp_nproc);
t_abs_to_grp = MPI_Wtime() - t_abs_to_grp;
t_grp_to_abs = MPI_Wtime();
for (i = 0; i < iter; i++)
ARMCI_Absolute_id(&g_even, (grp_me+1) % grp_nproc);
t_grp_to_abs = MPI_Wtime() - t_grp_to_abs;
printf("t_abs_to_grp = %f us, t_grp_to_abs = %f us\n", t_abs_to_grp/iter * 1.0e6, t_grp_to_abs/iter * 1.0e6);
}
ARMCI_Barrier();
}
/***********************************************************************/
if (me == 0) printf(" + Freeing groups\n");
if (me % 2 > 0)
ARMCI_Group_free(&g_odd);
else
ARMCI_Group_free(&g_even);
free(procs);
ARMCI_Finalize();
MPI_Finalize();
return 0;
}
void armci_group_finalize() {
#ifdef ARMCI_GROUP
ARMCI_Group_free((ARMCI_Group *)&ARMCI_World_Proc_Group);
#endif
}
