Line data Source code
1 : /* +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
2 : Copyright (c) 2012-2023 The plumed team
3 : (see the PEOPLE file at the root of the distribution for a list of names)
4 :
5 : See http://www.plumed.org for more information.
6 :
7 : This file is part of plumed, version 2.
8 :
9 : plumed is free software: you can redistribute it and/or modify
10 : it under the terms of the GNU Lesser General Public License as published by
11 : the Free Software Foundation, either version 3 of the License, or
12 : (at your option) any later version.
13 :
14 : plumed is distributed in the hope that it will be useful,
15 : but WITHOUT ANY WARRANTY; without even the implied warranty of
16 : MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
17 : GNU Lesser General Public License for more details.
18 :
19 : You should have received a copy of the GNU Lesser General Public License
20 : along with plumed. If not, see <http://www.gnu.org/licenses/>.
21 : +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ */
22 : #include "Communicator.h"
23 : #include "Exception.h"
24 : #include "AtomNumber.h"
25 : #include <cstdlib>
26 : #include <cstring>
27 : #include <cstdio>
28 :
29 : namespace PLMD {
30 :
31 54 : bool Communicator::plumedHasMPI() {
32 : #ifdef __PLUMED_HAS_MPI
33 54 : return true;
34 : #else
35 : return false;
36 : #endif
37 : }
38 :
39 1622824 : Communicator::Communicator()
40 : #ifdef __PLUMED_HAS_MPI
41 1622824 : : communicator(MPI_COMM_SELF)
42 : #endif
43 : {
44 1622824 : }
45 :
46 0 : Communicator::Communicator(const Communicator&pc) {
47 0 : Set_comm(pc.communicator);
48 0 : }
49 :
50 : Communicator::Status Communicator::StatusIgnore;
51 :
52 0 : Communicator& Communicator::operator=(const Communicator&pc) {
53 0 : if (this != &pc) {
54 0 : Set_comm(pc.communicator);
55 : }
56 0 : return *this;
57 : }
58 :
59 7786665 : int Communicator::Get_rank()const {
60 7786665 : int r=0;
61 : #ifdef __PLUMED_HAS_MPI
62 7786665 : if(initialized()) {
63 2784828 : MPI_Comm_rank(communicator,&r);
64 : }
65 : #endif
66 7786665 : return r;
67 : }
68 :
69 2984087 : int Communicator::Get_size()const {
70 2984087 : int s=1;
71 : #ifdef __PLUMED_HAS_MPI
72 2984087 : if(initialized()) {
73 1130465 : MPI_Comm_size(communicator,&s);
74 : }
75 : #endif
76 2984087 : return s;
77 : }
78 :
79 2448 : void Communicator::Set_comm(MPI_Comm c) {
80 : #ifdef __PLUMED_HAS_MPI
81 2448 : if(initialized()) {
82 1813 : if(communicator!=MPI_COMM_SELF && communicator!=MPI_COMM_WORLD) {
83 0 : MPI_Comm_free(&communicator);
84 : }
85 1813 : if(c!=MPI_COMM_SELF) {
86 1770 : MPI_Comm_dup(c,&communicator);
87 : }
88 : }
89 : #else
90 : (void) c;
91 : #endif
92 2448 : }
93 :
94 3242344 : Communicator::~Communicator() {
95 : #ifdef __PLUMED_HAS_MPI
96 1622824 : if(initialized() && communicator!=MPI_COMM_SELF && communicator!=MPI_COMM_WORLD) {
97 2184 : MPI_Comm_free(&communicator);
98 : }
99 : #endif
100 3242344 : }
101 :
102 1257 : void Communicator::Set_comm(const TypesafePtr & val) {
103 : #ifdef __PLUMED_HAS_MPI
104 1257 : plumed_massert(initialized(),"you are trying to use an MPI function, but MPI is not initialized");
105 1257 : if(val) {
106 1257 : Set_comm(*(const MPI_Comm*)val.get<const void*>());
107 : }
108 : #else
109 : (void) val;
110 : plumed_merror("you are trying to use an MPI function, but PLUMED has been compiled without MPI support");
111 : #endif
112 1257 : }
113 :
114 0 : void Communicator::Set_fcomm(const TypesafePtr & val) {
115 : #ifdef __PLUMED_HAS_MPI
116 0 : plumed_massert(initialized(),"you are trying to use an MPI function, but MPI is not initialized");
117 0 : if(val) {
118 0 : MPI_Comm comm=MPI_Comm_f2c(*(const MPI_Fint*)val.get<const void*>());
119 0 : Set_comm(comm);
120 : }
121 : #else
122 : (void) val;
123 : plumed_merror("you are trying to use an MPI function, but PLUMED has been compiled without MPI support");
124 : #endif
125 0 : }
126 :
127 0 : void Communicator::Abort(int errorcode) {
128 : #ifdef __PLUMED_HAS_MPI
129 0 : if(initialized()) {
130 0 : MPI_Abort(communicator,errorcode);
131 : }
132 : #endif
133 0 : std::fprintf(stderr,"aborting with error code %d\n",errorcode);
134 0 : std::abort();
135 : }
136 :
137 5554050 : void Communicator::Bcast(Data data,int root) {
138 : #if defined(__PLUMED_HAS_MPI)
139 5554050 : if(initialized()) {
140 1851298 : MPI_Bcast(data.pointer,data.size,data.type,root,communicator);
141 : }
142 : #else
143 : (void) data;
144 : (void) root;
145 : #endif
146 5554050 : }
147 :
148 4558840 : void Communicator::Sum(Data data) {
149 : #if defined(__PLUMED_HAS_MPI)
150 4558840 : if(initialized()) {
151 1982890 : MPI_Allreduce(MPI_IN_PLACE,data.pointer,data.size,data.type,MPI_SUM,communicator);
152 : }
153 : #else
154 : (void) data;
155 : #endif
156 4558840 : }
157 :
158 3 : void Communicator::Prod(Data data) {
159 : #if defined(__PLUMED_HAS_MPI)
160 3 : if(initialized()) {
161 3 : MPI_Allreduce(MPI_IN_PLACE,data.pointer,data.size,data.type,MPI_PROD,communicator);
162 : }
163 : #else
164 : (void) data;
165 : #endif
166 3 : }
167 :
168 155 : void Communicator::Max(Data data) {
169 : #if defined(__PLUMED_HAS_MPI)
170 155 : if(initialized()) {
171 155 : MPI_Allreduce(MPI_IN_PLACE,data.pointer,data.size,data.type,MPI_MAX,communicator);
172 : }
173 : #else
174 : (void) data;
175 : #endif
176 155 : }
177 :
178 3 : void Communicator::Min(Data data) {
179 : #if defined(__PLUMED_HAS_MPI)
180 3 : if(initialized()) {
181 3 : MPI_Allreduce(MPI_IN_PLACE,data.pointer,data.size,data.type,MPI_MIN,communicator);
182 : }
183 : #else
184 : (void) data;
185 : #endif
186 3 : }
187 :
188 15394 : Communicator::Request Communicator::Isend(ConstData data,int source,int tag) {
189 : Request req;
190 : #ifdef __PLUMED_HAS_MPI
191 15394 : plumed_massert(initialized(),"you are trying to use an MPI function, but MPI is not initialized");
192 15394 : void*s=const_cast<void*>((const void*)data.pointer);
193 15394 : MPI_Isend(s,data.size,data.type,source,tag,communicator,&req.r);
194 : #else
195 : (void) data;
196 : (void) source;
197 : (void) tag;
198 : plumed_merror("you are trying to use an MPI function, but PLUMED has been compiled without MPI support");
199 : #endif
200 15394 : return req;
201 : }
202 :
203 20888 : void Communicator::Allgatherv(ConstData in,Data out,const int*recvcounts,const int*displs) {
204 20888 : void*s=const_cast<void*>((const void*)in.pointer);
205 20888 : void*r=const_cast<void*>((const void*)out.pointer);
206 : int*rc=const_cast<int*>(recvcounts);
207 : int*di=const_cast<int*>(displs);
208 : #if defined(__PLUMED_HAS_MPI)
209 20888 : if(initialized()) {
210 20887 : if(s==NULL) {
211 : s=MPI_IN_PLACE;
212 : }
213 20887 : MPI_Allgatherv(s,in.size,in.type,r,rc,di,out.type,communicator);
214 : } else {
215 1 : plumed_assert(in.nbytes==out.nbytes);
216 1 : plumed_assert(in.size==out.size);
217 1 : plumed_assert(rc);
218 1 : plumed_assert(rc[0]==in.size);
219 1 : plumed_assert(di);
220 1 : if(s) {
221 1 : std::memcpy(static_cast<char*>(r)+displs[0]*in.nbytes,s,size_t(in.size)*in.nbytes);
222 : }
223 : }
224 : #else
225 : plumed_assert(in.nbytes==out.nbytes);
226 : plumed_assert(in.size==out.size);
227 : plumed_assert(rc);
228 : plumed_assert(rc[0]==in.size);
229 : plumed_assert(di);
230 : if(s) {
231 : std::memcpy(static_cast<char*>(r)+displs[0]*in.nbytes,s,size_t(in.size)*in.nbytes);
232 : }
233 : #endif
234 20888 : }
235 :
236 5850 : void Communicator::Allgather(ConstData in,Data out) {
237 5850 : void*s=const_cast<void*>((const void*)in.pointer);
238 5850 : void*r=const_cast<void*>((const void*)out.pointer);
239 : #if defined(__PLUMED_HAS_MPI)
240 5850 : if(initialized()) {
241 5849 : if(s==NULL) {
242 : s=MPI_IN_PLACE;
243 : }
244 5849 : MPI_Allgather(s,in.size,in.type,r,out.size/Get_size(),out.type,communicator);
245 : } else {
246 1 : plumed_assert(in.nbytes==out.nbytes);
247 1 : plumed_assert(in.size==out.size);
248 1 : if(s) {
249 1 : std::memcpy(r,s,size_t(in.size)*in.nbytes);
250 : }
251 : }
252 : #else
253 : plumed_assert(in.nbytes==out.nbytes);
254 : plumed_assert(in.size==out.size);
255 : if(s) {
256 : std::memcpy(r,s,size_t(in.size)*in.nbytes);
257 : }
258 : #endif
259 5850 : }
260 :
261 15394 : void Communicator::Recv(Data data,int source,int tag,Status&status) {
262 : #ifdef __PLUMED_HAS_MPI
263 15394 : plumed_massert(initialized(),"you are trying to use an MPI function, but MPI is not initialized");
264 15394 : if(&status==&StatusIgnore) {
265 7759 : MPI_Recv(data.pointer,data.size,data.type,source,tag,communicator,MPI_STATUS_IGNORE);
266 : } else {
267 7635 : MPI_Recv(data.pointer,data.size,data.type,source,tag,communicator,&status.s);
268 : }
269 : #else
270 : (void) data;
271 : (void) source;
272 : (void) tag;
273 : (void) status;
274 : plumed_merror("you are trying to use an MPI function, but PLUMED has been compiled without MPI support");
275 : #endif
276 15394 : }
277 :
278 5222715 : void Communicator::Barrier()const {
279 : #ifdef __PLUMED_HAS_MPI
280 5222715 : if(initialized()) {
281 1785320 : MPI_Barrier(communicator);
282 : }
283 : #endif
284 5222715 : }
285 :
286 1923 : MPI_Comm & Communicator::Get_comm() {
287 1923 : return communicator;
288 : }
289 :
290 27819624 : bool Communicator::initialized() {
291 : #if defined(__PLUMED_HAS_MPI)
292 27819624 : int flag=0;
293 27819624 : MPI_Initialized(&flag);
294 27819624 : if(flag) {
295 : return true;
296 : } else {
297 18194654 : return false;
298 : }
299 : #endif
300 : return false;
301 : }
302 :
303 14986 : void Communicator::Request::wait(Status&s) {
304 : #ifdef __PLUMED_HAS_MPI
305 14986 : plumed_massert(initialized(),"you are trying to use an MPI function, but MPI is not initialized");
306 14986 : if(&s==&StatusIgnore) {
307 14985 : MPI_Wait(&r,MPI_STATUS_IGNORE);
308 : } else {
309 1 : MPI_Wait(&r,&s.s);
310 : }
311 : #else
312 : (void) s;
313 : plumed_merror("you are trying to use an MPI function, but PLUMED has been compiled without MPI support");
314 : #endif
315 14986 : }
316 :
317 : #ifdef __PLUMED_HAS_MPI
318 0 : template<> MPI_Datatype Communicator::getMPIType<float>() {
319 0 : return MPI_FLOAT;
320 : }
321 4804553 : template<> MPI_Datatype Communicator::getMPIType<double>() {
322 4804553 : return MPI_DOUBLE;
323 : }
324 99734 : template<> MPI_Datatype Communicator::getMPIType<int>() {
325 99734 : return MPI_INT;
326 : }
327 295 : template<> MPI_Datatype Communicator::getMPIType<char>() {
328 295 : return MPI_CHAR;
329 : }
330 83699 : template<> MPI_Datatype Communicator::getMPIType<unsigned>() {
331 83699 : return MPI_UNSIGNED;
332 : }
333 24 : template<> MPI_Datatype Communicator::getMPIType<AtomNumber>() {
334 24 : return MPI_UNSIGNED;
335 : }
336 5216639 : template<> MPI_Datatype Communicator::getMPIType<long unsigned>() {
337 5216639 : return MPI_UNSIGNED_LONG;
338 : }
339 6 : template<> MPI_Datatype Communicator::getMPIType<long long unsigned>() {
340 6 : return MPI_UNSIGNED_LONG_LONG;
341 : }
342 0 : template<> MPI_Datatype Communicator::getMPIType<long double>() {
343 0 : return MPI_LONG_DOUBLE;
344 : }
345 : #else
346 : template<> MPI_Datatype Communicator::getMPIType<float>() {
347 : return MPI_Datatype();
348 : }
349 : template<> MPI_Datatype Communicator::getMPIType<double>() {
350 : return MPI_Datatype();
351 : }
352 : template<> MPI_Datatype Communicator::getMPIType<int>() {
353 : return MPI_Datatype();
354 : }
355 : template<> MPI_Datatype Communicator::getMPIType<char>() {
356 : return MPI_Datatype();
357 : }
358 : template<> MPI_Datatype Communicator::getMPIType<unsigned>() {
359 : return MPI_Datatype();
360 : }
361 : template<> MPI_Datatype Communicator::getMPIType<AtomNumber>() {
362 : return MPI_Datatype();
363 : }
364 : template<> MPI_Datatype Communicator::getMPIType<long unsigned>() {
365 : return MPI_Datatype();
366 : }
367 : template<> MPI_Datatype Communicator::getMPIType<long long unsigned>() {
368 : return MPI_Datatype();
369 : }
370 : template<> MPI_Datatype Communicator::getMPIType<long double>() {
371 : return MPI_Datatype();
372 : }
373 : #endif
374 :
375 414 : void Communicator::Split(int color,int key,Communicator&pc)const {
376 : #ifdef __PLUMED_HAS_MPI
377 414 : MPI_Comm_split(communicator,color,key,&pc.communicator);
378 : #else
379 : (void) color;
380 : (void) key;
381 : (void) pc;
382 : plumed_merror("you are trying to use an MPI function, but PLUMED has been compiled without MPI support");
383 : #endif
384 414 : }
385 :
386 7635 : int Communicator::Status::Get_count(MPI_Datatype type)const {
387 : int i;
388 : #ifdef __PLUMED_HAS_MPI
389 7635 : plumed_massert(initialized(),"you are trying to use an MPI function, but MPI is not initialized");
390 7635 : MPI_Get_count(const_cast<MPI_Status*>(&s),type,&i);
391 : #else
392 : i=0;
393 : plumed_merror("you are trying to use an MPI function, but PLUMED has been compiled without MPI support");
394 : #endif
395 7635 : return i;
396 : }
397 :
398 : }
399 :
|
