src/smpi/mpi/smpi_group.cpp

   1 /* Copyright (c) 2010-2019. 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 "simgrid/s4u/Actor.hpp"
   7 #include "smpi_group.hpp"
   8 #include "smpi_comm.hpp"
   9 #include <string>
  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(Group* origin)
  18 {
  19   if (origin != MPI_GROUP_NULL && origin != MPI_GROUP_EMPTY) {
  20     size_              = origin->size();
  21     // FIXME: cheinrich: There is no such thing as an index any more; the two maps should be removed
  22     index_to_rank_map_ = origin->index_to_rank_map_;
  23     rank_to_actor_map_ = origin->rank_to_actor_map_;
  24     actor_to_rank_map_ = origin->actor_to_rank_map_;
  25   }
  26 }
  27
  28 void Group::set_mapping(s4u::Actor* actor, int rank)
  29 {
  30   if (0 <= rank && rank < size_) {
  31     int index                = actor->get_pid();
  32     if (index != MPI_UNDEFINED) {
  33       if ((unsigned)index >= index_to_rank_map_.size())
  34         index_to_rank_map_.resize(index + 1, MPI_UNDEFINED);
  35       index_to_rank_map_[index] = rank;
  36     }
  37
  38     rank_to_actor_map_[rank] = actor;
  39     actor_to_rank_map_.insert({actor, rank});
  40   }
  41 }
  42
  43 int Group::rank(int index)
  44 {
  45   int rank;
  46   if (0 <= index && (unsigned)index < index_to_rank_map_.size())
  47     rank = index_to_rank_map_[index];
  48   else
  49     rank = MPI_UNDEFINED;
  50
  51   return rank;
  52 }
  53
  54 s4u::Actor* Group::actor(int rank)
  55 {
  56   if (0 <= rank && rank < size_)
  57     return rank_to_actor_map_[rank];
  58   else
  59     return nullptr;
  60 }
  61
  62 int Group::rank(s4u::Actor* actor)
  63 {
  64   auto iterator = actor_to_rank_map_.find(actor);
  65   return (iterator == actor_to_rank_map_.end()) ? MPI_UNDEFINED : (*iterator).second;
  66 }
  67
  68 void Group::ref()
  69 {
  70   refcount_++;
  71 }
  72
  73 void Group::unref(Group* group)
  74 {
  75   group->refcount_--;
  76   if (group->refcount_ <= 0) {
  77     delete group;
  78   }
  79 }
  80
  81 int Group::compare(MPI_Group group2)
  82 {
  83   int result;
  84
  85   result = MPI_IDENT;
  86   if (size_ != group2->size()) {
  87     result = MPI_UNEQUAL;
  88   } else {
  89     for (int i = 0; i < size_; i++) {
  90       s4u::Actor* actor = this->actor(i);
  91       int rank = group2->rank(actor);
  92       if (rank == MPI_UNDEFINED) {
  93         result = MPI_UNEQUAL;
  94         break;
  95       }
  96       if (rank != i) {
  97         result = MPI_SIMILAR;
  98       }
  99     }
 100   }
 101   return result;
 102 }
 103
 104 int Group::incl(int n, const int* ranks, MPI_Group* newgroup)
 105 {
 106   if (n == 0) {
 107     *newgroup = MPI_GROUP_EMPTY;
 108   } else if (n == size_) {
 109     *newgroup = this;
 110     if (this != MPI_COMM_WORLD->group() && this != MPI_COMM_SELF->group() && this != MPI_GROUP_EMPTY)
 111       this->ref();
 112   } else {
 113     *newgroup = new Group(n);
 114     for (int i = 0; i < n; i++) {
 115       s4u::Actor* actor = this->actor(ranks[i]); // ranks[] was passed as a param!
 116       (*newgroup)->set_mapping(actor, i);
 117     }
 118   }
 119   return MPI_SUCCESS;
 120 }
 121
 122 int Group::group_union(MPI_Group group2, MPI_Group* newgroup)
 123 {
 124   int size1 = size_;
 125   int size2 = group2->size();
 126   for (int i = 0; i < size2; i++) {
 127     s4u::Actor* actor = group2->actor(i);
 128     int proc1 = this->rank(actor);
 129     if (proc1 == MPI_UNDEFINED) {
 130       size1++;
 131     }
 132   }
 133   if (size1 == 0) {
 134     *newgroup = MPI_GROUP_EMPTY;
 135   } else {
 136     *newgroup = new  Group(size1);
 137     size2 = this->size();
 138     for (int i = 0; i < size2; i++) {
 139       s4u::Actor* actor1 = this->actor(i);
 140       (*newgroup)->set_mapping(actor1, i);
 141     }
 142     for (int i = size2; i < size1; i++) {
 143       s4u::Actor* actor = group2->actor(i - size2);
 144       (*newgroup)->set_mapping(actor, i);
 145     }
 146   }
 147   return MPI_SUCCESS;
 148 }
 149
 150 int Group::intersection(MPI_Group group2, MPI_Group* newgroup)
 151 {
 152   int size2 = group2->size();
 153   for (int i = 0; i < size2; i++) {
 154     s4u::Actor* actor = group2->actor(i);
 155     int proc1 = this->rank(actor);
 156     if (proc1 == MPI_UNDEFINED) {
 157       size2--;
 158     }
 159   }
 160   if (size2 == 0) {
 161     *newgroup = MPI_GROUP_EMPTY;
 162   } else {
 163     *newgroup = new  Group(size2);
 164     int j=0;
 165     for (int i = 0; i < group2->size(); i++) {
 166       s4u::Actor* actor = group2->actor(i);
 167       int proc1 = this->rank(actor);
 168       if (proc1 != MPI_UNDEFINED) {
 169         (*newgroup)->set_mapping(actor, j);
 170         j++;
 171       }
 172     }
 173   }
 174   return MPI_SUCCESS;
 175 }
 176
 177 int Group::difference(MPI_Group group2, MPI_Group* newgroup)
 178 {
 179   int newsize = size_;
 180   int size2 = size_;
 181   for (int i = 0; i < size2; i++) {
 182     s4u::Actor* actor = this->actor(i);
 183     int proc2 = group2->rank(actor);
 184     if (proc2 != MPI_UNDEFINED) {
 185       newsize--;
 186     }
 187   }
 188   if (newsize == 0) {
 189     *newgroup = MPI_GROUP_EMPTY;
 190   } else {
 191     *newgroup = new  Group(newsize);
 192     for (int i = 0; i < size2; i++) {
 193       s4u::Actor* actor = this->actor(i);
 194       int proc2 = group2->rank(actor);
 195       if (proc2 == MPI_UNDEFINED) {
 196         (*newgroup)->set_mapping(actor, i);
 197       }
 198     }
 199   }
 200   return MPI_SUCCESS;
 201 }
 202
 203 int Group::excl(int n, const int *ranks, MPI_Group * newgroup){
 204   int oldsize = size_;
 205   int newsize = oldsize - n;
 206   *newgroup = new  Group(newsize);
 207   int* to_exclude = new int[size_];
 208   for (int i     = 0; i < oldsize; i++)
 209     to_exclude[i]=0;
 210   for (int i            = 0; i < n; i++)
 211     to_exclude[ranks[i]]=1;
 212   int j = 0;
 213   for (int i = 0; i < oldsize; i++) {
 214     if(to_exclude[i]==0){
 215       s4u::Actor* actor = this->actor(i);
 216       (*newgroup)->set_mapping(actor, j);
 217       j++;
 218     }
 219   }
 220   delete[] to_exclude;
 221   return MPI_SUCCESS;
 222
 223 }
 224
 225 static bool is_rank_in_range(int rank, int first, int last)
 226 {
 227   if (first < last)
 228     return rank <= last;
 229   else
 230     return rank >= last;
 231 }
 232
 233 int Group::range_incl(int n, int ranges[][3], MPI_Group * newgroup){
 234   int newsize = 0;
 235   for (int i = 0; i < n; i++) {
 236     for (int rank = ranges[i][0];                    /* First */
 237          rank >= 0 && rank < size_; /* Last */
 238          ) {
 239       newsize++;
 240       if(rank == ranges[i][1]){/*already last ?*/
 241         break;
 242       }
 243       rank += ranges[i][2]; /* Stride */
 244       if (not is_rank_in_range(rank, ranges[i][0], ranges[i][1]))
 245         break;
 246     }
 247   }
 248   *newgroup = new  Group(newsize);
 249   int j     = 0;
 250   for (int i = 0; i < n; i++) {
 251     for (int rank = ranges[i][0];                    /* First */
 252          rank >= 0 && rank < size_; /* Last */
 253          ) {
 254       s4u::Actor* actor = this->actor(rank);
 255       (*newgroup)->set_mapping(actor, j);
 256       j++;
 257       if(rank == ranges[i][1]){/*already last ?*/
 258         break;
 259       }
 260       rank += ranges[i][2]; /* Stride */
 261       if (not is_rank_in_range(rank, ranges[i][0], ranges[i][1]))
 262         break;
 263     }
 264   }
 265   return MPI_SUCCESS;
 266 }
 267
 268 int Group::range_excl(int n, int ranges[][3], MPI_Group * newgroup){
 269   int newsize = size_;
 270   for (int i = 0; i < n; i++) {
 271     for (int rank = ranges[i][0];                    /* First */
 272          rank >= 0 && rank < size_; /* Last */
 273          ) {
 274       newsize--;
 275       if(rank == ranges[i][1]){/*already last ?*/
 276         break;
 277       }
 278       rank += ranges[i][2]; /* Stride */
 279       if (not is_rank_in_range(rank, ranges[i][0], ranges[i][1]))
 280         break;
 281     }
 282   }
 283   if (newsize == 0) {
 284     *newgroup = MPI_GROUP_EMPTY;
 285   } else {
 286     *newgroup = new  Group(newsize);
 287     int newrank = 0;
 288     int oldrank = 0;
 289     while (newrank < newsize) {
 290       int add = 1;
 291       for (int i = 0; i < n; i++) {
 292         for (int rank = ranges[i][0]; rank >= 0 && rank < size_;) {
 293           if(rank==oldrank){
 294             add = 0;
 295             break;
 296           }
 297           if(rank == ranges[i][1]){/*already last ?*/
 298             break;
 299           }
 300           rank += ranges[i][2]; /* Stride */
 301           if (not is_rank_in_range(rank, ranges[i][0], ranges[i][1]))
 302             break;
 303         }
 304       }
 305       if(add==1){
 306         s4u::Actor* actor = this->actor(oldrank);
 307         (*newgroup)->set_mapping(actor, newrank);
 308         newrank++;
 309       }
 310       oldrank++;
 311     }
 312   }
 313   return MPI_SUCCESS;
 314 }
 315
 316 MPI_Group Group::f2c(int id) {
 317   if(id == -2) {
 318     return MPI_GROUP_EMPTY;
 319   } else if(F2C::f2c_lookup() != nullptr && id >= 0) {
 320     char key[KEY_SIZE];
 321     return static_cast<MPI_Group>(F2C::f2c_lookup()->at(get_key(key, id)));
 322   } else {
 323     return static_cast<MPI_Group>(MPI_GROUP_NULL);
 324   }
 325 }
 326
 327 }
 328 }