src/smpi/mpi/smpi_group.cpp

   1 /* Copyright (c) 2010-2023. 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 smpi_MPI_GROUP_EMPTY;
  12
  13 namespace simgrid::smpi {
  14
  15 Group::Group(const Group* origin)
  16 {
  17   if (origin != MPI_GROUP_NULL && origin != MPI_GROUP_EMPTY) {
  18     rank_to_pid_map_ = origin->rank_to_pid_map_;
  19     pid_to_rank_map_ = origin->pid_to_rank_map_;
  20   }
  21 }
  22
  23 void Group::set_mapping(aid_t pid, int rank)
  24 {
  25   if (0 <= rank && rank < size()) {
  26     if (static_cast<size_t>(pid) >= pid_to_rank_map_.size())
  27       pid_to_rank_map_.resize(pid + 1, MPI_UNDEFINED);
  28     rank_to_pid_map_[rank] = pid;
  29     pid_to_rank_map_[pid]  = rank;
  30   }
  31 }
  32
  33 int Group::rank(aid_t pid) const
  34 {
  35   int res = static_cast<size_t>(pid) < pid_to_rank_map_.size() ? pid_to_rank_map_[pid] : MPI_UNDEFINED;
  36   if (res == MPI_UNDEFINED) {
  37     // I'm not in the communicator ... but maybe my parent is?
  38     if (auto parent = s4u::Actor::by_pid(pid)) {
  39       aid_t ppid = parent->get_ppid();
  40       res        = static_cast<size_t>(ppid) < pid_to_rank_map_.size() ? pid_to_rank_map_[ppid] : MPI_UNDEFINED;
  41     }
  42   }
  43   return res;
  44 }
  45
  46 aid_t Group::actor(int rank) const
  47 {
  48   return (0 <= rank && rank < size()) ? rank_to_pid_map_[rank] : -1;
  49 }
  50
  51 void Group::ref()
  52 {
  53   refcount_++;
  54 }
  55
  56 void Group::unref(Group* group)
  57 {
  58   group->refcount_--;
  59   if (group->refcount_ <= 0) {
  60     if (simgrid::smpi::F2C::lookup() != nullptr)
  61       F2C::free_f(group->f2c_id());
  62     delete group;
  63   }
  64 }
  65
  66 int Group::compare(const Group* group2) const
  67 {
  68   int result;
  69
  70   result = MPI_IDENT;
  71   if (size() != group2->size()) {
  72     result = MPI_UNEQUAL;
  73   } else {
  74     for (int i = 0; i < size(); i++) {
  75       int rank = group2->rank(actor(i));
  76       if (rank == MPI_UNDEFINED) {
  77         result = MPI_UNEQUAL;
  78         break;
  79       }
  80       if (rank != i) {
  81         result = MPI_SIMILAR;
  82       }
  83     }
  84   }
  85   return result;
  86 }
  87
  88 int Group::incl(int n, const int* ranks, MPI_Group* newgroup) const
  89 {
  90   if (n == 0) {
  91     *newgroup = MPI_GROUP_EMPTY;
  92     return MPI_SUCCESS;
  93   }
  94
  95   *newgroup = new Group(n);
  96   for (int i = 0; i < n; i++) {
  97     aid_t actor = this->actor(ranks[i]);
  98     (*newgroup)->set_mapping(actor, i);
  99   }
 100   (*newgroup)->add_f();
 101   return MPI_SUCCESS;
 102 }
 103
 104 int Group::incl(const std::vector<int>& ranks, MPI_Group* newgroup) const
 105 {
 106   return incl(static_cast<int>(ranks.size()), ranks.data(), newgroup);
 107 }
 108
 109 int Group::excl(const std::vector<bool>& excl_map, MPI_Group* newgroup) const
 110 {
 111   xbt_assert(static_cast<int>(excl_map.size()) == size());
 112   std::vector<int> ranks;
 113   for (int i = 0; i < static_cast<int>(excl_map.size()); i++)
 114     if (not excl_map[i])
 115       ranks.push_back(i);
 116   return incl(static_cast<int>(ranks.size()), ranks.data(), newgroup);
 117 }
 118
 119 int Group::group_union(const Group* group2, MPI_Group* newgroup) const
 120 {
 121   std::vector<int> ranks2;
 122   for (int i = 0; i < group2->size(); i++) {
 123     aid_t actor = group2->actor(i);
 124     if (rank(actor) == MPI_UNDEFINED)
 125       ranks2.push_back(i);
 126   }
 127
 128   int newsize = size() + static_cast<int>(ranks2.size());
 129   if (newsize == 0) {
 130     *newgroup = MPI_GROUP_EMPTY;
 131     return MPI_SUCCESS;
 132   }
 133
 134   *newgroup = new Group(newsize);
 135   int i;
 136   for (i = 0; i < size(); i++) {
 137     aid_t actor1 = actor(i);
 138     (*newgroup)->set_mapping(actor1, i);
 139   }
 140   for (int j : ranks2) {
 141     aid_t actor2 = group2->actor(j);
 142     (*newgroup)->set_mapping(actor2, i);
 143     i++;
 144   }
 145   (*newgroup)->add_f();
 146   return MPI_SUCCESS;
 147 }
 148
 149 int Group::intersection(const Group* group2, MPI_Group* newgroup) const
 150 {
 151   std::vector<int> ranks2;
 152   for (int i = 0; i < group2->size(); i++) {
 153     aid_t actor = group2->actor(i);
 154     if (rank(actor) != MPI_UNDEFINED)
 155       ranks2.push_back(i);
 156   }
 157   return group2->incl(ranks2, newgroup);
 158 }
 159
 160 int Group::difference(const Group* group2, MPI_Group* newgroup) const
 161 {
 162   std::vector<int> ranks;
 163   for (int i = 0; i < size(); i++) {
 164     aid_t actor = this->actor(i);
 165     if (group2->rank(actor) == MPI_UNDEFINED)
 166       ranks.push_back(i);
 167   }
 168   return this->incl(ranks, newgroup);
 169 }
 170
 171 int Group::excl(int n, const int* ranks, MPI_Group* newgroup) const
 172 {
 173   std::vector<bool> to_excl(size(), false);
 174   for (int i = 0; i < n; i++)
 175     to_excl[ranks[i]] = true;
 176   return this->excl(to_excl, newgroup);
 177 }
 178
 179 static bool is_rank_in_range(int rank, int first, int last)
 180 {
 181   return (first <= rank && rank <= last) || (first >= rank && rank >= last);
 182 }
 183
 184 int Group::range_incl(int n, const int ranges[][3], MPI_Group* newgroup) const
 185 {
 186   std::vector<int> ranks;
 187   for (int i = 0; i < n; i++) {
 188     for (int j = ranges[i][0]; j >= 0 && j < size() && is_rank_in_range(j, ranges[i][0], ranges[i][1]);
 189          j += ranges[i][2])
 190       ranks.push_back(j);
 191   }
 192   return this->incl(ranks, newgroup);
 193 }
 194
 195 int Group::range_excl(int n, const int ranges[][3], MPI_Group* newgroup) const
 196 {
 197   std::vector<bool> to_excl(size(), false);
 198   for (int i = 0; i < n; i++) {
 199     for (int j = ranges[i][0]; j >= 0 && j < size() && is_rank_in_range(j, ranges[i][0], ranges[i][1]);
 200          j += ranges[i][2])
 201       to_excl[j] = true;
 202   }
 203   return this->excl(to_excl, newgroup);
 204 }
 205
 206 MPI_Group Group::f2c(int id) {
 207   if(id == -2) {
 208     return MPI_GROUP_EMPTY;
 209   } else if (F2C::lookup() != nullptr && id >= 0) {
 210     return static_cast<MPI_Group>(F2C::lookup()->at(id));
 211   } else {
 212     return MPI_GROUP_NULL;
 213   }
 214 }
 215
 216 } // namespace simgrid::smpi