src/smpi/mpi/smpi_group.cpp

   1 /* Copyright (c) 2010-2017. The SimGrid Team. All rights reserved.          */
   2
   3 /* This program is free software; you can redistribute it and/or modify it
   4  * under the terms of the license (GNU LGPL) which comes with this package. */
   5
   6 #include "smpi_comm.hpp"
   7 #include "smpi_group.hpp"
   8
   9 XBT_LOG_NEW_DEFAULT_SUBCATEGORY(smpi_group, smpi, "Logging specific to SMPI (group)");
  10
  11 simgrid::smpi::Group mpi_MPI_GROUP_EMPTY;
  12 MPI_Group MPI_GROUP_EMPTY=&mpi_MPI_GROUP_EMPTY;
  13
  14 namespace simgrid{
  15 namespace smpi{
  16
  17 Group::Group()
  18 {
  19   size_              = 0;       /* size */
  20   rank_to_index_map_ = nullptr; /* rank_to_index_map_ */
  21   refcount_          = 1;       /* refcount_: start > 0 so that this group never gets freed */
  22 }
  23
  24 Group::Group(int n) : size_(n)
  25 {
  26   rank_to_index_map_ = new int[size_];
  27   refcount_ = 1;
  28   for (int i              = 0; i < size_; i++)
  29     rank_to_index_map_[i] = MPI_UNDEFINED;
  30 }
  31
  32 Group::Group(MPI_Group origin)
  33 {
  34   if (origin != MPI_GROUP_NULL && origin != MPI_GROUP_EMPTY) {
  35     size_              = origin->size();
  36     rank_to_index_map_ = new int[size_];
  37     refcount_          = 1;
  38     for (int i = 0; i < size_; i++) {
  39       rank_to_index_map_[i] = origin->rank_to_index_map_[i];
  40     }
  41
  42     for (auto const& elm : origin->index_to_rank_map_) {
  43       index_to_rank_map_.insert({elm.first, elm.second});
  44     }
  45   }
  46 }
  47
  48 Group::~Group()
  49 {
  50   delete[] rank_to_index_map_;
  51 }
  52
  53 void Group::set_mapping(int index, int rank)
  54 {
  55   if (rank < size_) {
  56     rank_to_index_map_[rank] = index;
  57     if (index != MPI_UNDEFINED)
  58       index_to_rank_map_.insert({index, rank});
  59   }
  60 }
  61
  62 int Group::index(int rank)
  63 {
  64   int index = MPI_UNDEFINED;
  65
  66   if (0 <= rank && rank < size_) {
  67     index = rank_to_index_map_[rank];
  68   }
  69   return index;
  70 }
  71
  72 int Group::rank(int index)
  73 {
  74   if (this == MPI_GROUP_EMPTY)
  75     return MPI_UNDEFINED;
  76   auto rank = index_to_rank_map_.find(index);
  77   return rank == index_to_rank_map_.end() ? MPI_UNDEFINED : rank->second;
  78 }
  79
  80 void Group::ref()
  81 {
  82   refcount_++;
  83 }
  84
  85 void Group::unref(Group* group)
  86 {
  87   group->refcount_--;
  88   if (group->refcount_ <= 0) {
  89     delete group;
  90   }
  91 }
  92
  93 int Group::size()
  94 {
  95   return size_;
  96 }
  97
  98 int Group::compare(MPI_Group group2)
  99 {
 100   int result;
 101
 102   result = MPI_IDENT;
 103   if (size_ != group2->size()) {
 104     result = MPI_UNEQUAL;
 105   } else {
 106     int sz = group2->size();
 107     for (int i = 0; i < sz; i++) {
 108       int index = this->index(i);
 109       int rank = group2->rank(index);
 110       if (rank == MPI_UNDEFINED) {
 111         result = MPI_UNEQUAL;
 112         break;
 113       }
 114       if (rank != i) {
 115         result = MPI_SIMILAR;
 116       }
 117     }
 118   }
 119   return result;
 120 }
 121
 122 int Group::incl(int n, int* ranks, MPI_Group* newgroup)
 123 {
 124   int i=0;
 125   int index=0;
 126   if (n == 0) {
 127     *newgroup = MPI_GROUP_EMPTY;
 128   } else if (n == size_) {
 129     *newgroup = this;
 130     if(this!= MPI_COMM_WORLD->group()
 131               && this != MPI_COMM_SELF->group()
 132               && this != MPI_GROUP_EMPTY)
 133     this->ref();
 134   } else {
 135     *newgroup = new Group(n);
 136     for (i = 0; i < n; i++) {
 137       index = this->index(ranks[i]);
 138       (*newgroup)->set_mapping(index, i);
 139     }
 140   }
 141   return MPI_SUCCESS;
 142 }
 143
 144 int Group::group_union(MPI_Group group2, MPI_Group* newgroup)
 145 {
 146   int size1 = size_;
 147   int size2 = group2->size();
 148   for (int i = 0; i < size2; i++) {
 149     int proc2 = group2->index(i);
 150     int proc1 = this->rank(proc2);
 151     if (proc1 == MPI_UNDEFINED) {
 152       size1++;
 153     }
 154   }
 155   if (size1 == 0) {
 156     *newgroup = MPI_GROUP_EMPTY;
 157   } else {
 158     *newgroup = new  Group(size1);
 159     size2 = this->size();
 160     for (int i = 0; i < size2; i++) {
 161       int proc1 = this->index(i);
 162       (*newgroup)->set_mapping(proc1, i);
 163     }
 164     for (int i = size2; i < size1; i++) {
 165       int proc2 = group2->index(i - size2);
 166       (*newgroup)->set_mapping(proc2, i);
 167     }
 168   }
 169   return MPI_SUCCESS;
 170 }
 171
 172 int Group::intersection(MPI_Group group2, MPI_Group* newgroup)
 173 {
 174   int size2 = group2->size();
 175   for (int i = 0; i < size2; i++) {
 176     int proc2 = group2->index(i);
 177     int proc1 = this->rank(proc2);
 178     if (proc1 == MPI_UNDEFINED) {
 179       size2--;
 180     }
 181   }
 182   if (size2 == 0) {
 183     *newgroup = MPI_GROUP_EMPTY;
 184   } else {
 185     *newgroup = new  Group(size2);
 186     int j=0;
 187     for (int i = 0; i < group2->size(); i++) {
 188       int proc2 = group2->index(i);
 189       int proc1 = this->rank(proc2);
 190       if (proc1 != MPI_UNDEFINED) {
 191         (*newgroup)->set_mapping(proc2, j);
 192         j++;
 193       }
 194     }
 195   }
 196   return MPI_SUCCESS;
 197 }
 198
 199 int Group::difference(MPI_Group group2, MPI_Group* newgroup)
 200 {
 201   int newsize = size_;
 202   int size2 = size_;
 203   for (int i = 0; i < size2; i++) {
 204     int proc1 = this->index(i);
 205     int proc2 = group2->rank(proc1);
 206     if (proc2 != MPI_UNDEFINED) {
 207       newsize--;
 208     }
 209   }
 210   if (newsize == 0) {
 211     *newgroup = MPI_GROUP_EMPTY;
 212   } else {
 213     *newgroup = new  Group(newsize);
 214     for (int i = 0; i < size2; i++) {
 215       int proc1 = this->index(i);
 216       int proc2 = group2->rank(proc1);
 217       if (proc2 == MPI_UNDEFINED) {
 218         (*newgroup)->set_mapping(proc1, i);
 219       }
 220     }
 221   }
 222   return MPI_SUCCESS;
 223 }
 224
 225 int Group::excl(int n, int *ranks, MPI_Group * newgroup){
 226   int oldsize = size_;
 227   int newsize = oldsize - n;
 228   *newgroup = new  Group(newsize);
 229   int* to_exclude=xbt_new0(int, size_);
 230   for (int i     = 0; i < oldsize; i++)
 231     to_exclude[i]=0;
 232   for (int i            = 0; i < n; i++)
 233     to_exclude[ranks[i]]=1;
 234   int j = 0;
 235   for (int i = 0; i < oldsize; i++) {
 236     if(to_exclude[i]==0){
 237       int index = this->index(i);
 238       (*newgroup)->set_mapping(index, j);
 239       j++;
 240     }
 241   }
 242   xbt_free(to_exclude);
 243   return MPI_SUCCESS;
 244
 245 }
 246
 247 int Group::range_incl(int n, int ranges[][3], MPI_Group * newgroup){
 248   int newsize = 0;
 249   for (int i = 0; i < n; i++) {
 250     for (int rank = ranges[i][0];                    /* First */
 251          rank >= 0 && rank < size_; /* Last */
 252          ) {
 253       newsize++;
 254       if(rank == ranges[i][1]){/*already last ?*/
 255         break;
 256       }
 257       rank += ranges[i][2]; /* Stride */
 258       if (ranges[i][0] < ranges[i][1]) {
 259         if (rank > ranges[i][1])
 260           break;
 261       } else {
 262         if (rank < ranges[i][1])
 263           break;
 264       }
 265     }
 266   }
 267   *newgroup = new  Group(newsize);
 268   int j     = 0;
 269   for (int i = 0; i < n; i++) {
 270     for (int rank = ranges[i][0];                    /* First */
 271          rank >= 0 && rank < size_; /* Last */
 272          ) {
 273       int index = this->index(rank);
 274       (*newgroup)->set_mapping(index, j);
 275       j++;
 276       if(rank == ranges[i][1]){/*already last ?*/
 277         break;
 278       }
 279       rank += ranges[i][2]; /* Stride */
 280       if (ranges[i][0] < ranges[i][1]) {
 281         if (rank > ranges[i][1])
 282           break;
 283       } else {
 284         if (rank < ranges[i][1])
 285           break;
 286       }
 287     }
 288   }
 289   return MPI_SUCCESS;
 290 }
 291
 292 int Group::range_excl(int n, int ranges[][3], MPI_Group * newgroup){
 293   int newsize = size_;
 294   for (int i = 0; i < n; i++) {
 295     for (int rank = ranges[i][0];                    /* First */
 296          rank >= 0 && rank < size_; /* Last */
 297          ) {
 298       newsize--;
 299       if(rank == ranges[i][1]){/*already last ?*/
 300         break;
 301       }
 302       rank += ranges[i][2]; /* Stride */
 303       if (ranges[i][0] < ranges[i][1]) {
 304         if (rank > ranges[i][1])
 305           break;
 306       } else {
 307         if (rank < ranges[i][1])
 308           break;
 309       }
 310     }
 311   }
 312   if (newsize == 0) {
 313     *newgroup = MPI_GROUP_EMPTY;
 314   } else {
 315     *newgroup = new  Group(newsize);
 316     int newrank = 0;
 317     int oldrank = 0;
 318     while (newrank < newsize) {
 319       int add = 1;
 320       for (int i = 0; i < n; i++) {
 321         for (int rank = ranges[i][0]; rank >= 0 && rank < size_;) {
 322           if(rank==oldrank){
 323             add = 0;
 324             break;
 325           }
 326           if(rank == ranges[i][1]){/*already last ?*/
 327             break;
 328           }
 329           rank += ranges[i][2]; /* Stride */
 330           if (ranges[i][0]<ranges[i][1]){
 331             if (rank > ranges[i][1])
 332               break;
 333           }else{
 334             if (rank < ranges[i][1])
 335               break;
 336           }
 337         }
 338       }
 339       if(add==1){
 340         int index = this->index(oldrank);
 341         (*newgroup)->set_mapping(index, newrank);
 342         newrank++;
 343       }
 344       oldrank++;
 345     }
 346   }
 347   return MPI_SUCCESS;
 348 }
 349
 350 MPI_Group Group::f2c(int id) {
 351   if(id == -2) {
 352     return MPI_GROUP_EMPTY;
 353   } else if(F2C::f2c_lookup() != nullptr && id >= 0) {
 354     char key[KEY_SIZE];
 355     return static_cast<MPI_Group>(F2C::f2c_lookup()->at(get_key(key, id)));
 356   } else {
 357     return static_cast<MPI_Group>(MPI_GROUP_NULL);
 358   }
 359 }
 360
 361 }
 362 }