Logo AND Algorithmique Numérique Distribuée

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