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_group.hpp"
   7 #include "smpi_comm.hpp"
   8 #include <string>
   9 #include <xbt/log.h>
  10
  11 XBT_LOG_NEW_DEFAULT_SUBCATEGORY(smpi_group, smpi, "Logging specific to SMPI (group)");
  12
  13 simgrid::smpi::Group mpi_MPI_GROUP_EMPTY;
  14 MPI_Group MPI_GROUP_EMPTY=&mpi_MPI_GROUP_EMPTY;
  15
  16 namespace simgrid{
  17 namespace smpi{
  18
  19 Group::Group()
  20 {
  21   size_              = 0;       /* size */
  22   rank_to_index_map_ = nullptr; /* rank_to_index_map_ */
  23   refcount_          = 1;       /* refcount_: start > 0 so that this group never gets freed */
  24 }
  25
  26 Group::Group(int n) : size_(n)
  27 {
  28   rank_to_index_map_ = new int[size_];
  29   refcount_ = 1;
  30   for (int i              = 0; i < size_; i++)
  31     rank_to_index_map_[i] = MPI_UNDEFINED;
  32 }
  33
  34 Group::Group(MPI_Group origin)
  35 {
  36   if (origin != MPI_GROUP_NULL && origin != MPI_GROUP_EMPTY) {
  37     size_              = origin->size();
  38     rank_to_index_map_ = new int[size_];
  39     refcount_          = 1;
  40     for (int i = 0; i < size_; i++) {
  41       rank_to_index_map_[i] = origin->rank_to_index_map_[i];
  42     }
  43
  44     for (auto const& elm : origin->index_to_rank_map_) {
  45       index_to_rank_map_.insert({elm.first, elm.second});
  46     }
  47   }
  48 }
  49
  50 Group::~Group()
  51 {
  52   delete[] rank_to_index_map_;
  53 }
  54
  55 void Group::set_mapping(int index, int rank)
  56 {
  57   if (rank < size_) {
  58     rank_to_index_map_[rank] = index;
  59     if (index != MPI_UNDEFINED)
  60       index_to_rank_map_.insert({index, rank});
  61   }
  62 }
  63
  64 int Group::index(int rank)
  65 {
  66   int index = MPI_UNDEFINED;
  67
  68   if (0 <= rank && rank < size_) {
  69     index = rank_to_index_map_[rank];
  70   }
  71   return index;
  72 }
  73
  74 int Group::rank(int index)
  75 {
  76   if (this == MPI_GROUP_EMPTY)
  77     return MPI_UNDEFINED;
  78   auto rank = index_to_rank_map_.find(index);
  79   return rank == index_to_rank_map_.end() ? MPI_UNDEFINED : rank->second;
  80 }
  81
  82 void Group::ref()
  83 {
  84   refcount_++;
  85 }
  86
  87 void Group::unref(Group* group)
  88 {
  89   group->refcount_--;
  90   if (group->refcount_ <= 0) {
  91     delete group;
  92   }
  93 }
  94
  95 int Group::size()
  96 {
  97   return size_;
  98 }
  99
 100 int Group::compare(MPI_Group group2)
 101 {
 102   int result;
 103
 104   result = MPI_IDENT;
 105   if (size_ != group2->size()) {
 106     result = MPI_UNEQUAL;
 107   } else {
 108     int sz = group2->size();
 109     for (int i = 0; i < sz; i++) {
 110       int index = this->index(i);
 111       int rank = group2->rank(index);
 112       if (rank == MPI_UNDEFINED) {
 113         result = MPI_UNEQUAL;
 114         break;
 115       }
 116       if (rank != i) {
 117         result = MPI_SIMILAR;
 118       }
 119     }
 120   }
 121   return result;
 122 }
 123
 124 int Group::incl(int n, int* ranks, MPI_Group* newgroup)
 125 {
 126   int i=0;
 127   int index=0;
 128   if (n == 0) {
 129     *newgroup = MPI_GROUP_EMPTY;
 130   } else if (n == size_) {
 131     *newgroup = this;
 132     if (this != MPI_COMM_WORLD->group() && this != MPI_COMM_SELF->group() && 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 = new 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   delete[] 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 }