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