Logo AND Algorithmique Numérique Distribuée

Public GIT Repository
[TRACING] Rename TIT action reduceScatter -> reducescatter
[simgrid.git] / src / smpi / bindings / smpi_pmpi_group.cpp
1 /* Copyright (c) 2007-2018. 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 "private.hpp"
7 #include "smpi_coll.hpp"
8 #include "smpi_comm.hpp"
9 #include "smpi_datatype_derived.hpp"
10 #include "smpi_op.hpp"
11 #include "smpi_process.hpp"
12
13 XBT_LOG_EXTERNAL_DEFAULT_CATEGORY(smpi_pmpi);
14
15
16 /* PMPI User level calls */
17
18 int PMPI_Group_free(MPI_Group * group)
19 {
20   if (group == nullptr) {
21     return MPI_ERR_ARG;
22   } else {
23     if(*group != MPI_COMM_WORLD->group() && *group != MPI_GROUP_EMPTY)
24       simgrid::smpi::Group::unref(*group);
25     *group = MPI_GROUP_NULL;
26     return MPI_SUCCESS;
27   }
28 }
29
30 int PMPI_Group_size(MPI_Group group, int *size)
31 {
32   if (group == MPI_GROUP_NULL) {
33     return MPI_ERR_GROUP;
34   } else if (size == nullptr) {
35     return MPI_ERR_ARG;
36   } else {
37     *size = group->size();
38     return MPI_SUCCESS;
39   }
40 }
41
42 int PMPI_Group_rank(MPI_Group group, int *rank)
43 {
44   if (group == MPI_GROUP_NULL) {
45     return MPI_ERR_GROUP;
46   } else if (rank == nullptr) {
47     return MPI_ERR_ARG;
48   } else {
49     *rank = group->rank(simgrid::s4u::this_actor::get_pid());
50     return MPI_SUCCESS;
51   }
52 }
53
54 int PMPI_Group_translate_ranks(MPI_Group group1, int n, int *ranks1, MPI_Group group2, int *ranks2)
55 {
56   if (group1 == MPI_GROUP_NULL || group2 == MPI_GROUP_NULL) {
57     return MPI_ERR_GROUP;
58   } else {
59     for (int i = 0; i < n; i++) {
60       if(ranks1[i]==MPI_PROC_NULL){
61         ranks2[i]=MPI_PROC_NULL;
62       }else{
63         simgrid::s4u::ActorPtr actor = group1->actor(ranks1[i]);
64         ranks2[i] = group2->rank(actor);
65       }
66     }
67     return MPI_SUCCESS;
68   }
69 }
70
71 int PMPI_Group_compare(MPI_Group group1, MPI_Group group2, int *result)
72 {
73   if (group1 == MPI_GROUP_NULL || group2 == MPI_GROUP_NULL) {
74     return MPI_ERR_GROUP;
75   } else if (result == nullptr) {
76     return MPI_ERR_ARG;
77   } else {
78     *result = group1->compare(group2);
79     return MPI_SUCCESS;
80   }
81 }
82
83 int PMPI_Group_union(MPI_Group group1, MPI_Group group2, MPI_Group * newgroup)
84 {
85
86   if (group1 == MPI_GROUP_NULL || group2 == MPI_GROUP_NULL) {
87     return MPI_ERR_GROUP;
88   } else if (newgroup == nullptr) {
89     return MPI_ERR_ARG;
90   } else {
91     return group1->group_union(group2, newgroup);
92   }
93 }
94
95 int PMPI_Group_intersection(MPI_Group group1, MPI_Group group2, MPI_Group * newgroup)
96 {
97
98   if (group1 == MPI_GROUP_NULL || group2 == MPI_GROUP_NULL) {
99     return MPI_ERR_GROUP;
100   } else if (newgroup == nullptr) {
101     return MPI_ERR_ARG;
102   } else {
103     return group1->intersection(group2,newgroup);
104   }
105 }
106
107 int PMPI_Group_difference(MPI_Group group1, MPI_Group group2, MPI_Group * newgroup)
108 {
109   if (group1 == MPI_GROUP_NULL || group2 == MPI_GROUP_NULL) {
110     return MPI_ERR_GROUP;
111   } else if (newgroup == nullptr) {
112     return MPI_ERR_ARG;
113   } else {
114     return group1->difference(group2,newgroup);
115   }
116 }
117
118 int PMPI_Group_incl(MPI_Group group, int n, int *ranks, MPI_Group * newgroup)
119 {
120   if (group == MPI_GROUP_NULL) {
121     return MPI_ERR_GROUP;
122   } else if (newgroup == nullptr) {
123     return MPI_ERR_ARG;
124   } else {
125     return group->incl(n, ranks, newgroup);
126   }
127 }
128
129 int PMPI_Group_excl(MPI_Group group, int n, int *ranks, MPI_Group * newgroup)
130 {
131   if (group == MPI_GROUP_NULL) {
132     return MPI_ERR_GROUP;
133   } else if (newgroup == nullptr) {
134     return MPI_ERR_ARG;
135   } else {
136     if (n == 0) {
137       *newgroup = group;
138       if (group != MPI_COMM_WORLD->group() && group != MPI_COMM_SELF->group() && group != MPI_GROUP_EMPTY)
139         group->ref();
140       return MPI_SUCCESS;
141     } else if (n == group->size()) {
142       *newgroup = MPI_GROUP_EMPTY;
143       return MPI_SUCCESS;
144     } else {
145       return group->excl(n,ranks,newgroup);
146     }
147   }
148 }
149
150 int PMPI_Group_range_incl(MPI_Group group, int n, int ranges[][3], MPI_Group * newgroup)
151 {
152   if (group == MPI_GROUP_NULL) {
153     return MPI_ERR_GROUP;
154   } else if (newgroup == nullptr) {
155     return MPI_ERR_ARG;
156   } else {
157     if (n == 0) {
158       *newgroup = MPI_GROUP_EMPTY;
159       return MPI_SUCCESS;
160     } else {
161       return group->range_incl(n,ranges,newgroup);
162     }
163   }
164 }
165
166 int PMPI_Group_range_excl(MPI_Group group, int n, int ranges[][3], MPI_Group * newgroup)
167 {
168   if (group == MPI_GROUP_NULL) {
169     return MPI_ERR_GROUP;
170   } else if (newgroup == nullptr) {
171     return MPI_ERR_ARG;
172   } else {
173     if (n == 0) {
174       *newgroup = group;
175       if (group != MPI_COMM_WORLD->group() && group != MPI_COMM_SELF->group() &&
176           group != MPI_GROUP_EMPTY)
177         group->ref();
178       return MPI_SUCCESS;
179     } else {
180       return group->range_excl(n,ranges,newgroup);
181     }
182   }
183 }
184
185 MPI_Group PMPI_Group_f2c(MPI_Fint group){
186   return simgrid::smpi::Group::f2c(group);
187 }
188
189 MPI_Fint PMPI_Group_c2f(MPI_Group group){
190   return group->c2f();
191 }