Logo AND Algorithmique Numérique Distribuée

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