root/ompi/group/group_plist.c

DEFINITIONS

1. ompi_group_dense_overlap
2. ompi_group_dense_lookup_raw
3. ompi_group_get_proc_ptr_raw
4. ompi_group_calc_plist
5. ompi_group_incl_plist
6. ompi_group_union
7. ompi_group_difference

   1 /* -*- Mode: C; c-basic-offset:4 ; indent-tabs-mode:nil -*- */
   2 /*
   3  * Copyright (c) 2004-2005 The Trustees of Indiana University and Indiana
   4  *                         University Research and Technology
   5  *                         Corporation.  All rights reserved.
   6  * Copyright (c) 2004-2005 The University of Tennessee and The University
   7  *                         of Tennessee Research Foundation.  All rights
   8  *                         reserved.
   9  * Copyright (c) 2004-2005 High Performance Computing Center Stuttgart,
  10  *                         University of Stuttgart.  All rights reserved.
  11  * Copyright (c) 2004-2005 The Regents of the University of California.
  12  *                         All rights reserved.
  13  * Copyright (c) 2006-2007 University of Houston. All rights reserved.
  14  * Copyright (c) 2007      Cisco Systems, Inc. All rights reserved.
  15  * Copyright (c) 2013-2015 Los Alamos National Security, LLC.  All rights
  16  *                         reserved.
  17  * Copyright (c) 2016      Research Organization for Information Science
  18  *                         and Technology (RIST). All rights reserved.
  19  * Copyright (c) 2017      Intel, Inc. All rights reserved.
  20  * $COPYRIGHT$
  21  *
  22  * Additional copyrights may follow
  23  *
  24  * $HEADER$
  25  */
  26 
  27 #include "ompi_config.h"
  28 #include "opal/class/opal_bitmap.h"
  29 #include "ompi/group/group.h"
  30 #include "ompi/constants.h"
  31 #include "ompi/proc/proc.h"
  32 #include "mpi.h"
  33 
  34 #include <math.h>
  35 
  36 static int ompi_group_dense_overlap (ompi_group_t *group1, ompi_group_t *group2, opal_bitmap_t *bitmap)
  37 {
  38     ompi_proc_t *proc1_pointer, *proc2_pointer;
  39     int rc, overlap_count;
  40 
  41     overlap_count = 0;
  42 
  43     for (int proc1 = 0 ; proc1 < group1->grp_proc_count ; ++proc1) {
  44         proc1_pointer = ompi_group_get_proc_ptr_raw (group1, proc1);
  45 
  46         /* check to see if this proc is in group2 */
  47         for (int proc2 = 0 ; proc2 < group2->grp_proc_count ; ++proc2) {
  48             proc2_pointer = ompi_group_get_proc_ptr_raw (group2, proc2);
  49             if( proc1_pointer == proc2_pointer ) {
  50                 rc = opal_bitmap_set_bit (bitmap, proc2);
  51                 if (OPAL_SUCCESS != rc) {
  52                     return rc;
  53                 }
  54                 ++overlap_count;
  55 
  56                 break;
  57             }
  58         }  /* end proc1 loop */
  59     }  /* end proc loop */
  60 
  61     return overlap_count;
  62 }
  63 
  64 static struct ompi_proc_t *ompi_group_dense_lookup_raw (ompi_group_t *group, const int peer_id)
  65 {
  66     if (OPAL_UNLIKELY(ompi_proc_is_sentinel (group->grp_proc_pointers[peer_id]))) {
  67         ompi_proc_t *proc =
  68             (ompi_proc_t *) ompi_proc_lookup (ompi_proc_sentinel_to_name ((uintptr_t) group->grp_proc_pointers[peer_id]));
  69         if (NULL != proc) {
  70             /* replace sentinel value with an actual ompi_proc_t */
  71             group->grp_proc_pointers[peer_id] = proc;
  72             /* retain the proc */
  73             OBJ_RETAIN(group->grp_proc_pointers[peer_id]);
  74         }
  75     }
  76 
  77     return group->grp_proc_pointers[peer_id];
  78 }
  79 
  80 ompi_proc_t *ompi_group_get_proc_ptr_raw (ompi_group_t *group, int rank)
  81 {
  82 #if OMPI_GROUP_SPARSE
  83     do {
  84         if (OMPI_GROUP_IS_DENSE(group)) {
  85             return ompi_group_dense_lookup_raw (group, rank);
  86         }
  87         int ranks1 = rank;
  88         ompi_group_translate_ranks (group, 1, &ranks1, group->grp_parent_group_ptr, &rank);
  89         group = group->grp_parent_group_ptr;
  90     } while (1);
  91 #else
  92     return ompi_group_dense_lookup_raw (group, rank);
  93 #endif
  94 }
  95 
  96 int ompi_group_calc_plist ( int n , const int *ranks ) {
  97     return sizeof(char *) * n ;
  98 }
  99 
 100 int ompi_group_incl_plist(ompi_group_t* group, int n, const int *ranks,
 101                           ompi_group_t **new_group)
 102 {
 103     /* local variables */
 104     int my_group_rank;
 105     ompi_group_t *group_pointer, *new_group_pointer;
 106 
 107     group_pointer = (ompi_group_t *)group;
 108 
 109     if ( 0 == n ) {
 110         *new_group = MPI_GROUP_EMPTY;
 111         OBJ_RETAIN(MPI_GROUP_EMPTY);
 112         return OMPI_SUCCESS;
 113     }
 114 
 115     /* get new group struct */
 116     new_group_pointer=ompi_group_allocate(n);
 117     if( NULL == new_group_pointer ) {
 118         return MPI_ERR_GROUP;
 119     }
 120 
 121     /* put group elements in the list */
 122     for (int proc = 0; proc < n; proc++) {
 123         new_group_pointer->grp_proc_pointers[proc] =
 124             ompi_group_get_proc_ptr_raw (group_pointer, ranks[proc]);
 125     }                           /* end proc loop */
 126 
 127     /* increment proc reference counters */
 128     ompi_group_increment_proc_count(new_group_pointer);
 129 
 130     /* find my rank */
 131     my_group_rank=group_pointer->grp_my_rank;
 132     if (MPI_UNDEFINED != my_group_rank) {
 133         ompi_set_group_rank(new_group_pointer, ompi_proc_local_proc);
 134     } else {
 135         new_group_pointer->grp_my_rank = MPI_UNDEFINED;
 136     }
 137 
 138     *new_group = (MPI_Group)new_group_pointer;
 139 
 140     return OMPI_SUCCESS;
 141 }
 142 
 143 /*
 144  * Group Union has to use the dense format since we don't support
 145  * two parent groups in the group structure and maintain functions
 146  */
 147 int ompi_group_union (ompi_group_t* group1, ompi_group_t* group2,
 148                       ompi_group_t **new_group)
 149 {
 150     /* local variables */
 151     int new_group_size, cnt, rc, overlap_count;
 152     ompi_group_t *new_group_pointer;
 153     ompi_proc_t *proc2_pointer;
 154     opal_bitmap_t bitmap;
 155 
 156     /*
 157      * form union
 158      */
 159 
 160     /* get new group size */
 161     OBJ_CONSTRUCT(&bitmap, opal_bitmap_t);
 162     rc = opal_bitmap_init (&bitmap, 32);
 163     if (OPAL_SUCCESS != rc) {
 164         return rc;
 165     }
 166 
 167     /* check group2 elements to see if they need to be included in the list */
 168     overlap_count = ompi_group_dense_overlap (group1, group2, &bitmap);
 169     if (0 > overlap_count) {
 170         OBJ_DESTRUCT(&bitmap);
 171         return overlap_count;
 172     }
 173 
 174     new_group_size = group1->grp_proc_count + group2->grp_proc_count - overlap_count;
 175     if ( 0 == new_group_size ) {
 176         *new_group = MPI_GROUP_EMPTY;
 177         OBJ_RETAIN(MPI_GROUP_EMPTY);
 178         OBJ_DESTRUCT(&bitmap);
 179         return MPI_SUCCESS;
 180     }
 181 
 182     /* get new group struct */
 183     new_group_pointer = ompi_group_allocate(new_group_size);
 184     if (NULL == new_group_pointer) {
 185         OBJ_DESTRUCT(&bitmap);
 186         return MPI_ERR_GROUP;
 187     }
 188 
 189     /* fill in the new group list */
 190 
 191     /* put group1 elements in the list */
 192     for (int proc1 = 0; proc1 < group1->grp_proc_count; ++proc1) {
 193         new_group_pointer->grp_proc_pointers[proc1] =
 194             ompi_group_get_proc_ptr_raw (group1, proc1);
 195     }
 196     cnt = group1->grp_proc_count;
 197 
 198     /* check group2 elements to see if they need to be included in the list */
 199     for (int proc2 = 0; proc2 < group2->grp_proc_count; ++proc2) {
 200         if (opal_bitmap_is_set_bit (&bitmap, proc2)) {
 201             continue;
 202         }
 203 
 204         proc2_pointer = ompi_group_get_proc_ptr_raw (group2, proc2);
 205         new_group_pointer->grp_proc_pointers[cnt++] = proc2_pointer;
 206     }                           /* end proc loop */
 207 
 208     OBJ_DESTRUCT(&bitmap);
 209 
 210     /* increment proc reference counters */
 211     ompi_group_increment_proc_count(new_group_pointer);
 212 
 213     /* find my rank */
 214     if (MPI_UNDEFINED != group1->grp_my_rank || MPI_UNDEFINED != group2->grp_my_rank) {
 215         ompi_set_group_rank(new_group_pointer, ompi_proc_local_proc);
 216     } else {
 217         new_group_pointer->grp_my_rank = MPI_UNDEFINED;
 218     }
 219 
 220     *new_group = (MPI_Group) new_group_pointer;
 221 
 222     return OMPI_SUCCESS;
 223 }
 224 
 225 /*
 226  * Group Difference has to use the dense format since we don't support
 227  * two parent groups in the group structure and maintain functions
 228  */
 229 int ompi_group_difference(ompi_group_t* group1, ompi_group_t* group2,
 230                           ompi_group_t **new_group) {
 231 
 232     /* local varibles */
 233     int new_group_size, overlap_count, rc;
 234     ompi_group_t *new_group_pointer;
 235     ompi_proc_t *proc1_pointer;
 236     opal_bitmap_t bitmap;
 237 
 238     /*
 239      * form union
 240      */
 241 
 242     /* get new group size */
 243     OBJ_CONSTRUCT(&bitmap, opal_bitmap_t);
 244     rc = opal_bitmap_init (&bitmap, 32);
 245     if (OPAL_SUCCESS != rc) {
 246         return rc;
 247     }
 248 
 249     /* check group2 elements to see if they need to be included in the list */
 250     overlap_count = ompi_group_dense_overlap (group2, group1, &bitmap);
 251     if (0 > overlap_count) {
 252         OBJ_DESTRUCT(&bitmap);
 253         return overlap_count;
 254     }
 255 
 256     new_group_size = group1->grp_proc_count - overlap_count;
 257     if ( 0 == new_group_size ) {
 258         *new_group = MPI_GROUP_EMPTY;
 259         OBJ_RETAIN(MPI_GROUP_EMPTY);
 260         OBJ_DESTRUCT(&bitmap);
 261         return MPI_SUCCESS;
 262     }
 263 
 264     /* allocate a new ompi_group_t structure */
 265     new_group_pointer = ompi_group_allocate(new_group_size);
 266     if( NULL == new_group_pointer ) {
 267         OBJ_DESTRUCT(&bitmap);
 268         return MPI_ERR_GROUP;
 269     }
 270 
 271     /* fill in group list */
 272     /* loop over group1 members */
 273     for (int proc1 = 0, cnt = 0 ; proc1 < group1->grp_proc_count ; ++proc1) {
 274         if (opal_bitmap_is_set_bit (&bitmap, proc1)) {
 275             continue;
 276         }
 277 
 278         proc1_pointer = ompi_group_get_proc_ptr_raw (group1, proc1);
 279         new_group_pointer->grp_proc_pointers[cnt++] = proc1_pointer;
 280     }  /* end proc loop */
 281 
 282     OBJ_DESTRUCT(&bitmap);
 283 
 284     /* increment proc reference counters */
 285     ompi_group_increment_proc_count(new_group_pointer);
 286 
 287     /* find my rank */
 288     if (MPI_UNDEFINED == group1->grp_my_rank || MPI_UNDEFINED != group2->grp_my_rank) {
 289         new_group_pointer->grp_my_rank = MPI_UNDEFINED;
 290     } else {
 291         ompi_set_group_rank(new_group_pointer, ompi_proc_local_proc);
 292     }
 293 
 294     *new_group = (MPI_Group)new_group_pointer;
 295 
 296     return OMPI_SUCCESS;
 297 }