Branch data Line data Source code
1 : : !{\src2tex{textfont=tt}}
2 : : !!****f* ABINIT/xmpi_ibcast
3 : : !! NAME
4 : : !! xmpi_ibcast
5 : : !!
6 : : !! FUNCTION
7 : : !! This module contains functions that calls MPI routine MPI_IBCAST,
8 : : !! to broadcast data from one processor to other procs inside a communicator,
9 : : !! if we compile the code using the MPI CPP flags.
10 : : !! xmpi_ibcast is the generic function.
11 : : !!
12 : : !! COPYRIGHT
13 : : !! Copyright (C) 2001-2026 ABINIT group (MG)
14 : : !! This file is distributed under the terms of the
15 : : !! GNU General Public License, see ~ABINIT/COPYING
16 : : !! or http://www.gnu.org/copyleft/gpl.txt .
17 : : !!
18 : : !! SOURCE
19 : : !!***
20 : :
21 : : !!****f* ABINIT/xmpi_ibcast_int1d
22 : : !! NAME
23 : : !! xmpi_ibcast_int1d
24 : : !!
25 : : !! FUNCTION
26 : : !! Sends data from one processor to others inside comm without blocking
27 : : !! Target: integer one-dimensional arrays.
28 : : !!
29 : : !! INPUTS
30 : : !! root: rank of broadcast root (integer)
31 : : !! comm: MPI communicator
32 : : !!
33 : : !! OUTPUT
34 : : !! ierr= exit status, a non-zero value meaning there is an error
35 : : !!
36 : : !! SIDE EFFECTS
37 : : !! xval= buffer array
38 : : !!
39 : : !! SOURCE
40 : :
41 [ # # ]: 0 : subroutine xmpi_ibcast_int1d(xval, root, comm, request, ierr)
42 : :
43 : : !Arguments-------------------------
44 : : integer ABI_ASYNC, intent(inout) :: xval(:)
45 : : integer, intent(in) :: root, comm
46 : : integer, intent(out) :: request, ierr
47 : :
48 : : ! *************************************************************************
49 : :
50 : 0 : ierr=0
51 : : #ifdef HAVE_MPI_IBCAST
52 [ # # ]: 0 : if (comm /= MPI_COMM_SELF .and. comm /= MPI_COMM_NULL) then
53 [ # # # # ]: 0 : call MPI_IBCAST(xval, product(shape(xval)), MPI_INTEGER, root, comm, request, ierr)
54 : 0 : xmpi_count_requests = xmpi_count_requests + 1
55 : 0 : return
56 : : end if
57 : : #endif
58 : :
59 : : ! Call the blocking version and return null request.
60 : 0 : call xmpi_bcast(xval, root, comm, ierr)
61 : 0 : request = xmpi_request_null
62 : :
63 : : end subroutine xmpi_ibcast_int1d
64 : : !!***
65 : :
66 : : !!****f* ABINIT/xmpi_ibcast_int4d
67 : : !! NAME
68 : : !! xmpi_ibcast_int4d
69 : : !!
70 : : !! FUNCTION
71 : : !! Sends data from one processor to others inside comm without blocking
72 : : !! Target: integer one-dimensional arrays.
73 : : !!
74 : : !! INPUTS
75 : : !! root: rank of broadcast root (integer)
76 : : !! comm: MPI communicator
77 : : !!
78 : : !! OUTPUT
79 : : !! ierr= exit status, a non-zero value meaning there is an error
80 : : !!
81 : : !! SIDE EFFECTS
82 : : !! xval= buffer array
83 : : !!
84 : : !! SOURCE
85 : :
86 [ # # ]: 0 : subroutine xmpi_ibcast_int4d(xval, root, comm, request, ierr)
87 : :
88 : : !Arguments-------------------------
89 : : integer ABI_ASYNC, intent(inout) :: xval(:,:,:,:)
90 : : integer, intent(in) :: root, comm
91 : : integer, intent(out) :: request, ierr
92 : :
93 : : ! *************************************************************************
94 : :
95 : 0 : ierr=0
96 : : #ifdef HAVE_MPI_IBCAST
97 [ # # ]: 0 : if (comm /= MPI_COMM_SELF .and. comm /= MPI_COMM_NULL) then
98 [ # # # # ]: 0 : call MPI_IBCAST(xval, product(shape(xval)), MPI_INTEGER, root, comm, request, ierr)
99 : 0 : xmpi_count_requests = xmpi_count_requests + 1
100 : 0 : return
101 : : end if
102 : : #endif
103 : :
104 : : ! Call the blocking version and return null request.
105 : 0 : call xmpi_bcast(xval, root, comm, ierr)
106 : 0 : request = xmpi_request_null
107 : :
108 : : end subroutine xmpi_ibcast_int4d
109 : : !!***
110 : :
111 : : !!****f* ABINIT/xmpi_ibcast_dp1d
112 : : !! NAME
113 : : !! xmpi_ibcast_int1d
114 : : !!
115 : : !! FUNCTION
116 : : !! Sends data from one processor to others inside comm without blocking
117 : : !! Target: double one-dimensional dp arrays.
118 : : !!
119 : : !! INPUTS
120 : : !! root: rank of broadcast root (integer)
121 : : !! comm: MPI communicator
122 : : !!
123 : : !! OUTPUT
124 : : !! ierr= exit status, a non-zero value meaning there is an error
125 : : !!
126 : : !! SIDE EFFECTS
127 : : !! xval= buffer array
128 : : !!
129 : : !! SOURCE
130 : :
131 [ - + ]: 16633 : subroutine xmpi_ibcast_dp1d(xval, root, comm, request, ierr)
132 : :
133 : : !Arguments-------------------------
134 : : real(dp) ABI_ASYNC, intent(inout) :: xval(:)
135 : : integer, intent(in) :: root, comm
136 : : integer, intent(out) :: request, ierr
137 : :
138 : : ! *************************************************************************
139 : :
140 : 16633 : ierr=0
141 : : #ifdef HAVE_MPI_IBCAST
142 [ + + ]: 16633 : if (comm /= MPI_COMM_SELF .and. comm /= MPI_COMM_NULL) then
143 [ + + - + ]: 9704 : call MPI_IBCAST(xval, product(shape(xval)), MPI_DOUBLE_PRECISION, root, comm, request, ierr)
144 : 4852 : xmpi_count_requests = xmpi_count_requests + 1
145 : 4852 : return
146 : : end if
147 : : #endif
148 : :
149 : : ! Call the blocking version and return null request.
150 : 11781 : call xmpi_bcast(xval, root, comm, ierr)
151 : 11781 : request = xmpi_request_null
152 : :
153 : : end subroutine xmpi_ibcast_dp1d
154 : : !!***
155 : :
156 : : !!****f* ABINIT/xmpi_ibcast_dp2d
157 : : !! NAME
158 : : !! xmpi_ibcast_dp2d
159 : : !!
160 : : !! FUNCTION
161 : : !! Sends data from one processor to others inside comm without blocking
162 : : !! Target: double two-dimensional dp arrays.
163 : : !!
164 : : !! INPUTS
165 : : !! root: rank of broadcast root (integer)
166 : : !! comm: MPI communicator
167 : : !!
168 : : !! OUTPUT
169 : : !! ierr= exit status, a non-zero value meaning there is an error
170 : : !!
171 : : !! SIDE EFFECTS
172 : : !! xval= buffer array
173 : : !!
174 : : !! SOURCE
175 : :
176 [ - + ]: 11781 : subroutine xmpi_ibcast_dp2d(xval, root, comm, request, ierr)
177 : :
178 : : !Arguments-------------------------
179 : : real(dp) ABI_ASYNC, intent(inout) :: xval(:, :)
180 : : integer, intent(in) :: root, comm
181 : : integer, intent(out) :: request, ierr
182 : :
183 : : ! *************************************************************************
184 : :
185 : 11781 : ierr=0
186 : : #ifdef HAVE_MPI_IBCAST
187 [ - + ]: 11781 : if (comm /= MPI_COMM_SELF .and. comm /= MPI_COMM_NULL) then
188 [ # # # # ]: 0 : call MPI_IBCAST(xval, product(shape(xval)), MPI_DOUBLE_PRECISION, root, comm, request, ierr)
189 : 0 : xmpi_count_requests = xmpi_count_requests + 1
190 : 0 : return
191 : : end if
192 : : #endif
193 : :
194 : : ! Call the blocking version and return null request.
195 : 11781 : call xmpi_bcast(xval, root, comm, ierr)
196 : 11781 : request = xmpi_request_null
197 : :
198 : : end subroutine xmpi_ibcast_dp2d
199 : : !!***
200 : :
201 : : !!****f* ABINIT/xmpi_ibcast_dp3d
202 : : !! NAME
203 : : !! xmpi_ibcast_dp3d
204 : : !!
205 : : !! FUNCTION
206 : : !! Sends data from one processor to others inside comm without blocking
207 : : !! Target: double three-dimensional dp arrays.
208 : : !!
209 : : !! INPUTS
210 : : !! root: rank of broadcast root (integer)
211 : : !! comm: MPI communicator
212 : : !!
213 : : !! OUTPUT
214 : : !! ierr= exit status, a non-zero value meaning there is an error
215 : : !!
216 : : !! SIDE EFFECTS
217 : : !! xval= buffer array
218 : : !!
219 : : !! SOURCE
220 : :
221 [ # # ]: 0 : subroutine xmpi_ibcast_dp3d(xval, root, comm, request, ierr)
222 : :
223 : : !Arguments-------------------------
224 : : real(dp) ABI_ASYNC, intent(inout) :: xval(:, :, :)
225 : : integer, intent(in) :: root, comm
226 : : integer, intent(out) :: request, ierr
227 : :
228 : : ! *************************************************************************
229 : :
230 : 0 : ierr=0
231 : : #ifdef HAVE_MPI_IBCAST
232 [ # # ]: 0 : if (comm /= MPI_COMM_SELF .and. comm /= MPI_COMM_NULL) then
233 [ # # # # ]: 0 : call MPI_IBCAST(xval, product(shape(xval)), MPI_DOUBLE_PRECISION, root, comm, request, ierr)
234 : 0 : xmpi_count_requests = xmpi_count_requests + 1
235 : 0 : return
236 : : end if
237 : : #endif
238 : :
239 : : ! Call the blocking version and return null request.
240 : 0 : call xmpi_bcast(xval, root, comm, ierr)
241 : 0 : request = xmpi_request_null
242 : :
243 : : end subroutine xmpi_ibcast_dp3d
244 : : !!***
245 : :
246 : : !!****f* ABINIT/xmpi_ibcast_dp4d
247 : : !! NAME
248 : : !! xmpi_ibcast_dp4d
249 : : !!
250 : : !! FUNCTION
251 : : !! Sends data from one processor to others inside comm without blocking
252 : : !! Target: double three-dimensional dp arrays.
253 : : !!
254 : : !! INPUTS
255 : : !! root: rank of broadcast root (integer)
256 : : !! comm: MPI communicator
257 : : !!
258 : : !! OUTPUT
259 : : !! ierr= exit status, a non-zero value meaning there is an error
260 : : !!
261 : : !! SIDE EFFECTS
262 : : !! xval= buffer array
263 : : !!
264 : : !! SOURCE
265 : :
266 [ - + ]: 4852 : subroutine xmpi_ibcast_dp4d(xval, root, comm, request, ierr)
267 : :
268 : : !Arguments-------------------------
269 : : real(dp) ABI_ASYNC, intent(inout) :: xval(:, :, :, :)
270 : : integer, intent(in) :: root, comm
271 : : integer, intent(out) :: request, ierr
272 : :
273 : : ! *************************************************************************
274 : :
275 : 4852 : ierr=0
276 : : #ifdef HAVE_MPI_IBCAST
277 [ + - ]: 4852 : if (comm /= MPI_COMM_SELF .and. comm /= MPI_COMM_NULL) then
278 [ + + - + ]: 24260 : call MPI_IBCAST(xval, product(shape(xval)), MPI_DOUBLE_PRECISION, root, comm, request, ierr)
279 : 4852 : xmpi_count_requests = xmpi_count_requests + 1
280 : 4852 : return
281 : : end if
282 : : #endif
283 : :
284 : : ! Call the blocking version and return null request.
285 : 0 : call xmpi_bcast(xval, root, comm, ierr)
286 : 0 : request = xmpi_request_null
287 : :
288 : : end subroutine xmpi_ibcast_dp4d
289 : : !!***
290 : :
291 : : !!****f* ABINIT/xmpi_ibcast_dpc2d
292 : : !! NAME
293 : : !! xmpi_ibcast_dpc2d
294 : : !!
295 : : !! FUNCTION
296 : : !! Sends data from one processor to others inside comm without blocking
297 : : !! Target: double precision two-dimensional complex arrays.
298 : : !!
299 : : !! INPUTS
300 : : !! root: rank of broadcast root (integer)
301 : : !! comm: MPI communicator
302 : : !!
303 : : !! OUTPUT
304 : : !! ierr= exit status, a non-zero value meaning there is an error
305 : : !!
306 : : !! SIDE EFFECTS
307 : : !! xval= buffer array
308 : : !!
309 : : !! SOURCE
310 : :
311 [ # # ]: 0 : subroutine xmpi_ibcast_dpc2d(xval, root, comm, request, ierr)
312 : :
313 : : !Arguments-------------------------
314 : : complex(dp) ABI_ASYNC, intent(inout) :: xval(:, :)
315 : : integer, intent(in) :: root, comm
316 : : integer, intent(out) :: request, ierr
317 : :
318 : : ! *************************************************************************
319 : :
320 : 0 : ierr=0
321 : : #ifdef HAVE_MPI_IBCAST
322 [ # # ]: 0 : if (comm /= MPI_COMM_SELF .and. comm /= MPI_COMM_NULL) then
323 [ # # # # ]: 0 : call MPI_IBCAST(xval, product(shape(xval)), MPI_DOUBLE_COMPLEX, root, comm, request, ierr)
324 : 0 : xmpi_count_requests = xmpi_count_requests + 1
325 : 0 : return
326 : : end if
327 : : #endif
328 : :
329 : : ! Call the blocking version and return null request.
330 : 0 : call xmpi_bcast(xval, root, comm, ierr)
331 : 0 : request = xmpi_request_null
332 : :
333 : : end subroutine xmpi_ibcast_dpc2d
334 : : !!***
335 : :
336 : : !!****f* ABINIT/xmpi_ibcast_spc2d
337 : : !! NAME
338 : : !! xmpi_ibcast_spc2d
339 : : !!
340 : : !! FUNCTION
341 : : !! Sends data from one processor to others inside comm without blocking
342 : : !! Target: single precision two-dimensional complex arrays.
343 : : !!
344 : : !! INPUTS
345 : : !! root: rank of broadcast root (integer)
346 : : !! comm: MPI communicator
347 : : !!
348 : : !! OUTPUT
349 : : !! ierr= exit status, a non-zero value meaning there is an error
350 : : !!
351 : : !! SIDE EFFECTS
352 : : !! xval= buffer array
353 : : !!
354 : : !! SOURCE
355 : :
356 [ # # ]: 0 : subroutine xmpi_ibcast_spc2d(xval, root, comm, request, ierr)
357 : :
358 : : !Arguments-------------------------
359 : : complex(sp) ABI_ASYNC, intent(inout) :: xval(:, :)
360 : : integer, intent(in) :: root, comm
361 : : integer, intent(out) :: request, ierr
362 : :
363 : : ! *************************************************************************
364 : :
365 : 0 : ierr=0
366 : : #ifdef HAVE_MPI_IBCAST
367 [ # # ]: 0 : if (comm /= MPI_COMM_SELF .and. comm /= MPI_COMM_NULL) then
368 [ # # # # ]: 0 : call MPI_IBCAST(xval, product(shape(xval)), MPI_COMPLEX, root, comm, request, ierr)
369 : 0 : xmpi_count_requests = xmpi_count_requests + 1
370 : 0 : return
371 : : end if
372 : : #endif
373 : :
374 : : ! Call the blocking version and return null request.
375 : 0 : call xmpi_bcast(xval, root, comm, ierr)
376 : 0 : request = xmpi_request_null
377 : :
378 : : end subroutine xmpi_ibcast_spc2d
379 : : !!***
|
