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