Line data Source code
1 : !--------------------------------------------------------------------------------------------------!
2 : ! CP2K: A general program to perform molecular dynamics simulations !
3 : ! Copyright 2000-2026 CP2K developers group <https://cp2k.org> !
4 : ! !
5 : ! SPDX-License-Identifier: GPL-2.0-or-later !
6 : !--------------------------------------------------------------------------------------------------!
7 :
8 : ! **************************************************************************************************
9 : !> \brief communication routines to reshape / replicate / merge tall-and-skinny matrices.
10 : !> \author Patrick Seewald
11 : ! **************************************************************************************************
12 : MODULE dbt_tas_reshape_ops
13 : USE OMP_LIB, ONLY: omp_destroy_lock,&
14 : omp_get_max_threads,&
15 : omp_get_num_threads,&
16 : omp_get_thread_num,&
17 : omp_init_lock,&
18 : omp_lock_kind,&
19 : omp_set_lock,&
20 : omp_unset_lock
21 : USE dbm_api, ONLY: &
22 : dbm_clear, dbm_distribution_col_dist, dbm_distribution_obj, dbm_distribution_row_dist, &
23 : dbm_finalize, dbm_get_col_block_sizes, dbm_get_distribution, dbm_get_name, &
24 : dbm_get_row_block_sizes, dbm_get_stored_coordinates, dbm_iterator, &
25 : dbm_iterator_blocks_left, dbm_iterator_next_block, dbm_iterator_start, dbm_iterator_stop, &
26 : dbm_put_block, dbm_reserve_blocks, dbm_type
27 : USE dbt_tas_base, ONLY: &
28 : dbt_repl_get_stored_coordinates, dbt_tas_blk_sizes, dbt_tas_clear, dbt_tas_create, &
29 : dbt_tas_distribution_new, dbt_tas_finalize, dbt_tas_get_stored_coordinates, dbt_tas_info, &
30 : dbt_tas_iterator_blocks_left, dbt_tas_iterator_next_block, dbt_tas_iterator_start, &
31 : dbt_tas_iterator_stop, dbt_tas_put_block, dbt_tas_reserve_blocks
32 : USE dbt_tas_global, ONLY: dbt_tas_blk_size_arb,&
33 : dbt_tas_blk_size_repl,&
34 : dbt_tas_dist_arb,&
35 : dbt_tas_dist_repl,&
36 : dbt_tas_distribution,&
37 : dbt_tas_rowcol_data
38 : USE dbt_tas_split, ONLY: colsplit,&
39 : dbt_tas_get_split_info,&
40 : rowsplit
41 : USE dbt_tas_types, ONLY: dbt_tas_distribution_type,&
42 : dbt_tas_iterator,&
43 : dbt_tas_split_info,&
44 : dbt_tas_type
45 : USE dbt_tas_util, ONLY: swap
46 : USE kinds, ONLY: dp,&
47 : int_8
48 : USE message_passing, ONLY: mp_cart_type,&
49 : mp_comm_type,&
50 : mp_request_type,&
51 : mp_waitall
52 : #include "../../base/base_uses.f90"
53 :
54 : IMPLICIT NONE
55 : PRIVATE
56 :
57 : CHARACTER(len=*), PARAMETER, PRIVATE :: moduleN = 'dbt_tas_reshape_ops'
58 :
59 : PUBLIC :: &
60 : dbt_tas_merge, &
61 : dbt_tas_replicate, &
62 : dbt_tas_reshape
63 :
64 : TYPE dbt_buffer_type
65 : INTEGER :: nblock = -1
66 : INTEGER(KIND=int_8), DIMENSION(:, :), ALLOCATABLE :: indx
67 : REAL(dp), DIMENSION(:), ALLOCATABLE :: msg
68 : INTEGER :: endpos = -1
69 : END TYPE dbt_buffer_type
70 :
71 : CONTAINS
72 :
73 : ! **************************************************************************************************
74 : !> \brief copy data (involves reshape)
75 : !> \param matrix_in ...
76 : !> \param matrix_out ...
77 : !> \param summation whether matrix_out = matrix_out + matrix_in
78 : !> \param transposed ...
79 : !> \param move_data memory optimization: move data to matrix_out such that matrix_in is empty on return
80 : !> \author Patrick Seewald
81 : ! **************************************************************************************************
82 200295 : RECURSIVE SUBROUTINE dbt_tas_reshape(matrix_in, matrix_out, summation, transposed, move_data)
83 : TYPE(dbt_tas_type), INTENT(INOUT) :: matrix_in, matrix_out
84 : LOGICAL, INTENT(IN), OPTIONAL :: summation, transposed, move_data
85 :
86 : CHARACTER(LEN=*), PARAMETER :: routineN = 'dbt_tas_reshape'
87 :
88 : INTEGER :: a, b, bcount, handle, handle2, iproc, &
89 : nblk, nblk_per_thread, ndata, numnodes
90 200295 : INTEGER(KIND=int_8), ALLOCATABLE, DIMENSION(:, :) :: blks_to_allocate, index_recv
91 : INTEGER(KIND=int_8), DIMENSION(2) :: blk_index
92 : INTEGER(kind=omp_lock_kind), ALLOCATABLE, &
93 200295 : DIMENSION(:) :: locks
94 200295 : INTEGER, ALLOCATABLE, DIMENSION(:) :: num_blocks_recv, num_blocks_send, &
95 200295 : num_entries_recv, num_entries_send, &
96 200295 : num_rec, num_send
97 : INTEGER, DIMENSION(2) :: blk_size
98 : LOGICAL :: move_prv, tr_in
99 200295 : REAL(KIND=dp), DIMENSION(:, :), POINTER :: block
100 200295 : TYPE(dbt_buffer_type), ALLOCATABLE, DIMENSION(:) :: buffer_recv, buffer_send
101 : TYPE(dbt_tas_iterator) :: iter
102 1201770 : TYPE(dbt_tas_split_info) :: info
103 : TYPE(mp_comm_type) :: mp_comm
104 : TYPE(mp_request_type), ALLOCATABLE, &
105 200295 : DIMENSION(:, :) :: req_array
106 :
107 200295 : CALL timeset(routineN, handle)
108 :
109 200295 : IF (PRESENT(summation)) THEN
110 70670 : IF (.NOT. summation) CALL dbm_clear(matrix_out%matrix)
111 : ELSE
112 129625 : CALL dbm_clear(matrix_out%matrix)
113 : END IF
114 :
115 200295 : IF (PRESENT(move_data)) THEN
116 200295 : move_prv = move_data
117 : ELSE
118 : move_prv = .FALSE.
119 : END IF
120 :
121 200295 : IF (PRESENT(transposed)) THEN
122 200295 : tr_in = transposed
123 : ELSE
124 0 : tr_in = .FALSE.
125 : END IF
126 :
127 200295 : IF (.NOT. matrix_out%valid) THEN
128 0 : CPABORT("can not reshape into invalid matrix")
129 : END IF
130 :
131 200295 : info = dbt_tas_info(matrix_in)
132 200295 : mp_comm = info%mp_comm
133 200295 : numnodes = mp_comm%num_pe
134 927536 : ALLOCATE (buffer_send(0:numnodes - 1))
135 727241 : ALLOCATE (buffer_recv(0:numnodes - 1))
136 600885 : ALLOCATE (num_blocks_recv(0:numnodes - 1))
137 400590 : ALLOCATE (num_blocks_send(0:numnodes - 1))
138 400590 : ALLOCATE (num_entries_recv(0:numnodes - 1))
139 400590 : ALLOCATE (num_entries_send(0:numnodes - 1))
140 600885 : ALLOCATE (num_rec(0:2*numnodes - 1))
141 1053892 : ALLOCATE (num_send(0:2*numnodes - 1), SOURCE=0)
142 2708669 : ALLOCATE (req_array(1:numnodes, 4))
143 400590 : ALLOCATE (locks(0:numnodes - 1))
144 526946 : DO iproc = 0, numnodes - 1
145 526946 : CALL omp_init_lock(locks(iproc))
146 : END DO
147 :
148 200295 : CALL timeset(routineN//"_get_coord", handle2)
149 : !$OMP PARALLEL DEFAULT(NONE) SHARED(matrix_in,matrix_out,tr_in,num_send,locks) &
150 200295 : !$OMP PRIVATE(iter,blk_index,blk_size,iproc)
151 : CALL dbt_tas_iterator_start(iter, matrix_in)
152 : DO WHILE (dbt_tas_iterator_blocks_left(iter))
153 : CALL dbt_tas_iterator_next_block(iter, blk_index(1), blk_index(2), &
154 : row_size=blk_size(1), col_size=blk_size(2))
155 : IF (tr_in) THEN
156 : CALL dbt_tas_get_stored_coordinates(matrix_out, blk_index(2), blk_index(1), iproc)
157 : ELSE
158 : CALL dbt_tas_get_stored_coordinates(matrix_out, blk_index(1), blk_index(2), iproc)
159 : END IF
160 : CALL omp_set_lock(locks(iproc))
161 : num_send(2*iproc) = num_send(2*iproc) + PRODUCT(blk_size)
162 : num_send(2*iproc + 1) = num_send(2*iproc + 1) + 1
163 : CALL omp_unset_lock(locks(iproc))
164 : END DO
165 : CALL dbt_tas_iterator_stop(iter)
166 : !$OMP END PARALLEL
167 200295 : CALL timestop(handle2)
168 :
169 200295 : CALL timeset(routineN//"_alltoall", handle2)
170 200295 : CALL mp_comm%alltoall(num_send, num_rec, 2)
171 200295 : CALL timestop(handle2)
172 :
173 200295 : CALL timeset(routineN//"_buffer_fill", handle2)
174 526946 : DO iproc = 0, numnodes - 1
175 326651 : num_entries_recv(iproc) = num_rec(2*iproc)
176 326651 : num_blocks_recv(iproc) = num_rec(2*iproc + 1)
177 326651 : num_entries_send(iproc) = num_send(2*iproc)
178 326651 : num_blocks_send(iproc) = num_send(2*iproc + 1)
179 :
180 326651 : CALL dbt_buffer_create(buffer_send(iproc), num_blocks_send(iproc), num_entries_send(iproc))
181 526946 : CALL dbt_buffer_create(buffer_recv(iproc), num_blocks_recv(iproc), num_entries_recv(iproc))
182 : END DO
183 :
184 : !$OMP PARALLEL DEFAULT(NONE) SHARED(matrix_in,matrix_out,tr_in,buffer_send,locks) &
185 200295 : !$OMP PRIVATE(iter,blk_index,blk_size,block,iproc)
186 : CALL dbt_tas_iterator_start(iter, matrix_in)
187 : DO WHILE (dbt_tas_iterator_blocks_left(iter))
188 : CALL dbt_tas_iterator_next_block(iter, blk_index(1), blk_index(2), block, &
189 : row_size=blk_size(1), col_size=blk_size(2))
190 : IF (tr_in) THEN
191 : CALL dbt_tas_get_stored_coordinates(matrix_out, blk_index(2), blk_index(1), iproc)
192 : ELSE
193 : CALL dbt_tas_get_stored_coordinates(matrix_out, blk_index(1), blk_index(2), iproc)
194 : END IF
195 : CALL omp_set_lock(locks(iproc))
196 : CALL dbt_buffer_add_block(buffer_send(iproc), blk_index, block, transposed=tr_in)
197 : CALL omp_unset_lock(locks(iproc))
198 : END DO
199 : CALL dbt_tas_iterator_stop(iter)
200 : !$OMP END PARALLEL
201 :
202 200295 : IF (move_prv) CALL dbt_tas_clear(matrix_in)
203 200295 : CALL timestop(handle2)
204 :
205 200295 : CALL timeset(routineN//"_communicate_buffer", handle2)
206 200295 : CALL dbt_tas_communicate_buffer(mp_comm, buffer_recv, buffer_send, req_array)
207 :
208 526946 : DO iproc = 0, numnodes - 1
209 326651 : CALL dbt_buffer_destroy(buffer_send(iproc))
210 526946 : CALL omp_destroy_lock(locks(iproc))
211 : END DO
212 200295 : DEALLOCATE (locks)
213 :
214 200295 : CALL timestop(handle2)
215 :
216 200295 : CALL timeset(routineN//"_buffer_obtain", handle2)
217 :
218 : ! Parallel unpack of received blocks.
219 526946 : nblk = SUM(num_blocks_recv)
220 580023 : ALLOCATE (blks_to_allocate(nblk, 2))
221 :
222 200295 : bcount = 0
223 526946 : DO iproc = 0, numnodes - 1
224 326651 : CALL dbt_buffer_get_index(buffer_recv(iproc), index_recv)
225 6032017 : blks_to_allocate(bcount + 1:bcount + SIZE(index_recv, 1), :) = index_recv(:, :)
226 326651 : bcount = bcount + SIZE(index_recv, 1)
227 853597 : DEALLOCATE (index_recv)
228 : END DO
229 :
230 : !TODO: Parallelize creation of block list.
231 200295 : !$OMP PARALLEL DEFAULT(NONE) SHARED(matrix_out,nblk,blks_to_allocate) PRIVATE(nblk_per_thread,A,b)
232 : nblk_per_thread = nblk/omp_get_num_threads() + 1
233 : a = omp_get_thread_num()*nblk_per_thread + 1
234 : b = MIN(a + nblk_per_thread, nblk)
235 : CALL dbt_tas_reserve_blocks(matrix_out, blks_to_allocate(a:b, 1), blks_to_allocate(a:b, 2))
236 : !$OMP END PARALLEL
237 200295 : DEALLOCATE (blks_to_allocate)
238 :
239 : !$OMP PARALLEL DEFAULT(NONE) SHARED(buffer_recv,matrix_out,numnodes,summation) &
240 200295 : !$OMP PRIVATE(iproc,ndata,blk_index,blk_size,block)
241 : !$OMP DO SCHEDULE(DYNAMIC)
242 : DO iproc = 0, numnodes - 1
243 : ! First, we need to get the index to create block
244 : DO WHILE (dbt_buffer_blocks_left(buffer_recv(iproc)))
245 : CALL dbt_buffer_get_next_block(buffer_recv(iproc), ndata, blk_index)
246 : CALL dbt_tas_blk_sizes(matrix_out, blk_index(1), blk_index(2), blk_size(1), blk_size(2))
247 : ALLOCATE (block(blk_size(1), blk_size(2)))
248 : CALL dbt_buffer_get_next_block(buffer_recv(iproc), ndata, blk_index, block)
249 : CALL dbt_tas_put_block(matrix_out, blk_index(1), blk_index(2), block, summation=summation)
250 : DEALLOCATE (block)
251 : END DO
252 : CALL dbt_buffer_destroy(buffer_recv(iproc))
253 : END DO
254 : !$OMP END DO
255 : !$OMP END PARALLEL
256 :
257 200295 : CALL timestop(handle2)
258 :
259 200295 : CALL dbt_tas_finalize(matrix_out)
260 :
261 200295 : CALL timestop(handle)
262 2255662 : END SUBROUTINE dbt_tas_reshape
263 :
264 : ! **************************************************************************************************
265 : !> \brief Replicate matrix_in such that each submatrix of matrix_out is an exact copy of matrix_in
266 : !> \param matrix_in ...
267 : !> \param info ...
268 : !> \param matrix_out ...
269 : !> \param nodata Don't copy data but create matrix_out
270 : !> \param move_data memory optimization: move data to matrix_out such that matrix_in is empty on return
271 : !> \author Patrick Seewald
272 : ! **************************************************************************************************
273 1112730 : SUBROUTINE dbt_tas_replicate(matrix_in, info, matrix_out, nodata, move_data)
274 : TYPE(dbm_type), INTENT(INOUT) :: matrix_in
275 : TYPE(dbt_tas_split_info), INTENT(IN) :: info
276 : TYPE(dbt_tas_type), INTENT(OUT) :: matrix_out
277 : LOGICAL, INTENT(IN), OPTIONAL :: nodata, move_data
278 :
279 : INTEGER :: a, b, nblk_per_thread, nblkcols, nblkrows
280 : INTEGER, DIMENSION(2) :: pdims
281 370910 : INTEGER, DIMENSION(:), POINTER :: col_blk_size, col_dist, row_blk_size, &
282 185455 : row_dist
283 : TYPE(dbm_distribution_obj) :: dbm_dist
284 185455 : TYPE(dbt_tas_dist_arb), TARGET :: dir_dist
285 185455 : TYPE(dbt_tas_dist_repl), TARGET :: repl_dist
286 :
287 370910 : CLASS(dbt_tas_distribution), ALLOCATABLE :: col_dist_obj, row_dist_obj
288 370910 : CLASS(dbt_tas_rowcol_data), ALLOCATABLE :: row_bsize_obj, col_bsize_obj
289 185455 : TYPE(dbt_tas_blk_size_repl), TARGET :: repl_blksize
290 185455 : TYPE(dbt_tas_blk_size_arb), TARGET :: dir_blksize
291 927275 : TYPE(dbt_tas_distribution_type) :: dist
292 : INTEGER :: numnodes, ngroup, max_threads, cache_idx
293 185455 : INTEGER(kind=omp_lock_kind), ALLOCATABLE, DIMENSION(:) :: locks
294 185455 : TYPE(dbt_buffer_type), ALLOCATABLE, DIMENSION(:) :: buffer_recv, buffer_send
295 185455 : INTEGER, ALLOCATABLE, DIMENSION(:) :: num_blocks_recv, num_blocks_send, &
296 185455 : num_entries_recv, num_entries_send, &
297 185455 : num_rec, num_send
298 185455 : TYPE(mp_request_type), ALLOCATABLE, DIMENSION(:, :) :: req_array
299 185455 : INTEGER, ALLOCATABLE, DIMENSION(:, :) :: blks_to_allocate
300 : INTEGER, DIMENSION(2) :: blk_size
301 : INTEGER, DIMENSION(2) :: blk_index
302 : INTEGER(KIND=int_8), DIMENSION(2) :: blk_index_i8
303 : TYPE(dbm_iterator) :: iter
304 : INTEGER :: i, iproc, bcount, nblk
305 185455 : INTEGER, ALLOCATABLE, DIMENSION(:, :) :: iprocs
306 : LOGICAL :: nodata_prv, move_prv
307 185455 : INTEGER(KIND=int_8), ALLOCATABLE, DIMENSION(:, :) :: index_recv
308 : INTEGER :: ndata
309 185455 : TYPE(mp_cart_type) :: mp_comm
310 :
311 185455 : REAL(KIND=dp), DIMENSION(:, :), POINTER :: block
312 :
313 : CHARACTER(LEN=*), PARAMETER :: routineN = 'dbt_tas_replicate'
314 :
315 : INTEGER :: handle, handle2
316 :
317 185455 : NULLIFY (col_blk_size, row_blk_size)
318 :
319 185455 : CALL timeset(routineN, handle)
320 :
321 185455 : IF (PRESENT(nodata)) THEN
322 57680 : nodata_prv = nodata
323 : ELSE
324 : nodata_prv = .FALSE.
325 : END IF
326 :
327 185455 : IF (PRESENT(move_data)) THEN
328 127775 : move_prv = move_data
329 : ELSE
330 : move_prv = .FALSE.
331 : END IF
332 :
333 185455 : row_blk_size => dbm_get_row_block_sizes(matrix_in)
334 185455 : col_blk_size => dbm_get_col_block_sizes(matrix_in)
335 185455 : nblkrows = SIZE(row_blk_size)
336 185455 : nblkcols = SIZE(col_blk_size)
337 185455 : dbm_dist = dbm_get_distribution(matrix_in)
338 185455 : row_dist => dbm_distribution_row_dist(dbm_dist)
339 185455 : col_dist => dbm_distribution_col_dist(dbm_dist)
340 :
341 185455 : mp_comm = info%mp_comm
342 185455 : ngroup = info%ngroup
343 :
344 185455 : numnodes = mp_comm%num_pe
345 556365 : pdims = mp_comm%num_pe_cart
346 :
347 313869 : SELECT CASE (info%split_rowcol)
348 : CASE (rowsplit)
349 128414 : repl_dist = dbt_tas_dist_repl(row_dist, pdims(1), nblkrows, info%ngroup, info%pgrid_split_size)
350 128414 : dir_dist = dbt_tas_dist_arb(col_dist, pdims(2), INT(nblkcols, KIND=int_8))
351 128414 : repl_blksize = dbt_tas_blk_size_repl(row_blk_size, info%ngroup)
352 128414 : dir_blksize = dbt_tas_blk_size_arb(col_blk_size)
353 128414 : ALLOCATE (row_dist_obj, source=repl_dist)
354 128414 : ALLOCATE (col_dist_obj, source=dir_dist)
355 128414 : ALLOCATE (row_bsize_obj, source=repl_blksize)
356 256828 : ALLOCATE (col_bsize_obj, source=dir_blksize)
357 : CASE (colsplit)
358 57041 : dir_dist = dbt_tas_dist_arb(row_dist, pdims(1), INT(nblkrows, KIND=int_8))
359 57041 : repl_dist = dbt_tas_dist_repl(col_dist, pdims(2), nblkcols, info%ngroup, info%pgrid_split_size)
360 57041 : dir_blksize = dbt_tas_blk_size_arb(row_blk_size)
361 57041 : repl_blksize = dbt_tas_blk_size_repl(col_blk_size, info%ngroup)
362 57041 : ALLOCATE (row_dist_obj, source=dir_dist)
363 57041 : ALLOCATE (col_dist_obj, source=repl_dist)
364 57041 : ALLOCATE (row_bsize_obj, source=dir_blksize)
365 870234 : ALLOCATE (col_bsize_obj, source=repl_blksize)
366 : END SELECT
367 :
368 185455 : CALL dbt_tas_distribution_new(dist, mp_comm, row_dist_obj, col_dist_obj, split_info=info)
369 : CALL dbt_tas_create(matrix_out, TRIM(dbm_get_name(matrix_in))//" replicated", &
370 185455 : dist, row_bsize_obj, col_bsize_obj, own_dist=.TRUE.)
371 :
372 185455 : IF (nodata_prv) THEN
373 57680 : CALL dbt_tas_finalize(matrix_out)
374 57680 : CALL timestop(handle)
375 57680 : RETURN
376 : END IF
377 :
378 590928 : ALLOCATE (buffer_send(0:numnodes - 1))
379 463153 : ALLOCATE (buffer_recv(0:numnodes - 1))
380 383325 : ALLOCATE (num_blocks_recv(0:numnodes - 1))
381 255550 : ALLOCATE (num_blocks_send(0:numnodes - 1))
382 255550 : ALLOCATE (num_entries_recv(0:numnodes - 1))
383 255550 : ALLOCATE (num_entries_send(0:numnodes - 1))
384 383325 : ALLOCATE (num_rec(0:2*numnodes - 1))
385 670756 : ALLOCATE (num_send(0:2*numnodes - 1), SOURCE=0)
386 1724837 : ALLOCATE (req_array(1:numnodes, 4))
387 255550 : ALLOCATE (locks(0:numnodes - 1))
388 127775 : max_threads = 1
389 127775 : !$ max_threads = omp_get_max_threads()
390 511100 : ALLOCATE (iprocs(ngroup, max_threads))
391 335378 : DO iproc = 0, numnodes - 1
392 335378 : CALL omp_init_lock(locks(iproc))
393 : END DO
394 :
395 : !$OMP PARALLEL DEFAULT(NONE) SHARED(matrix_in,matrix_out,num_send,ngroup,iprocs,locks) &
396 127775 : !$OMP PRIVATE(iter,blk_index,blk_size,cache_idx,i,iproc)
397 : cache_idx = omp_get_thread_num() + 1
398 : CALL dbm_iterator_start(iter, matrix_in)
399 : DO WHILE (dbm_iterator_blocks_left(iter))
400 : CALL dbm_iterator_next_block(iter, blk_index(1), blk_index(2), &
401 : row_size=blk_size(1), col_size=blk_size(2))
402 : CALL dbt_repl_get_stored_coordinates(matrix_out, blk_index(1), blk_index(2), &
403 : iprocs(:, cache_idx))
404 : DO i = 1, ngroup
405 : iproc = iprocs(i, cache_idx)
406 : CALL omp_set_lock(locks(iproc))
407 : num_send(2*iproc) = num_send(2*iproc) + PRODUCT(blk_size)
408 : num_send(2*iproc + 1) = num_send(2*iproc + 1) + 1
409 : CALL omp_unset_lock(locks(iproc))
410 : END DO
411 : END DO
412 : CALL dbm_iterator_stop(iter)
413 : !$OMP END PARALLEL
414 :
415 127775 : CALL timeset(routineN//"_alltoall", handle2)
416 127775 : CALL mp_comm%alltoall(num_send, num_rec, 2)
417 127775 : CALL timestop(handle2)
418 :
419 335378 : DO iproc = 0, numnodes - 1
420 207603 : num_entries_recv(iproc) = num_rec(2*iproc)
421 207603 : num_blocks_recv(iproc) = num_rec(2*iproc + 1)
422 207603 : num_entries_send(iproc) = num_send(2*iproc)
423 207603 : num_blocks_send(iproc) = num_send(2*iproc + 1)
424 :
425 207603 : CALL dbt_buffer_create(buffer_send(iproc), num_blocks_send(iproc), num_entries_send(iproc))
426 335378 : CALL dbt_buffer_create(buffer_recv(iproc), num_blocks_recv(iproc), num_entries_recv(iproc))
427 : END DO
428 :
429 : !$OMP PARALLEL DEFAULT(NONE) SHARED(matrix_in,matrix_out,buffer_send,locks,ngroup,iprocs) &
430 127775 : !$OMP PRIVATE(iter,blk_index,blk_size,block,cache_idx,i,iproc)
431 : cache_idx = omp_get_thread_num() + 1
432 : CALL dbm_iterator_start(iter, matrix_in)
433 : DO WHILE (dbm_iterator_blocks_left(iter))
434 : CALL dbm_iterator_next_block(iter, blk_index(1), blk_index(2), block, &
435 : row_size=blk_size(1), col_size=blk_size(2))
436 : CALL dbt_repl_get_stored_coordinates(matrix_out, blk_index(1), blk_index(2), &
437 : iprocs(:, cache_idx))
438 : DO i = 1, ngroup
439 : iproc = iprocs(i, cache_idx)
440 : CALL omp_set_lock(locks(iproc))
441 : CALL dbt_buffer_add_block(buffer_send(iproc), INT(blk_index, KIND=int_8), block)
442 : CALL omp_unset_lock(locks(iproc))
443 : END DO
444 : END DO
445 : CALL dbm_iterator_stop(iter)
446 : !$OMP END PARALLEL
447 :
448 127775 : DEALLOCATE (iprocs)
449 :
450 127775 : IF (move_prv) CALL dbm_clear(matrix_in)
451 :
452 127775 : CALL timeset(routineN//"_communicate_buffer", handle2)
453 127775 : CALL dbt_tas_communicate_buffer(mp_comm, buffer_recv, buffer_send, req_array)
454 :
455 335378 : DO iproc = 0, numnodes - 1
456 207603 : CALL dbt_buffer_destroy(buffer_send(iproc))
457 335378 : CALL omp_destroy_lock(locks(iproc))
458 : END DO
459 127775 : DEALLOCATE (locks)
460 :
461 127775 : CALL timestop(handle2)
462 :
463 : ! Parallel unpack of received blocks.
464 335378 : nblk = SUM(num_blocks_recv)
465 382943 : ALLOCATE (blks_to_allocate(nblk, 2))
466 :
467 127775 : bcount = 0
468 335378 : DO iproc = 0, numnodes - 1
469 207603 : CALL dbt_buffer_get_index(buffer_recv(iproc), index_recv)
470 4820279 : blks_to_allocate(bcount + 1:bcount + SIZE(index_recv, 1), :) = INT(index_recv(:, :))
471 207603 : bcount = bcount + SIZE(index_recv, 1)
472 542981 : DEALLOCATE (index_recv)
473 : END DO
474 :
475 : !TODO: Parallelize creation of block list.
476 127775 : !$OMP PARALLEL DEFAULT(NONE) SHARED(matrix_out,nblk,blks_to_allocate) PRIVATE(nblk_per_thread,A,b)
477 : nblk_per_thread = nblk/omp_get_num_threads() + 1
478 : a = omp_get_thread_num()*nblk_per_thread + 1
479 : b = MIN(a + nblk_per_thread, nblk)
480 : CALL dbm_reserve_blocks(matrix_out%matrix, blks_to_allocate(a:b, 1), blks_to_allocate(a:b, 2))
481 : !$OMP END PARALLEL
482 127775 : DEALLOCATE (blks_to_allocate)
483 :
484 : !$OMP PARALLEL DEFAULT(NONE) SHARED(buffer_recv,matrix_out,numnodes) &
485 127775 : !$OMP PRIVATE(iproc,ndata,blk_index_i8,blk_size,block)
486 : !$OMP DO SCHEDULE(DYNAMIC)
487 : DO iproc = 0, numnodes - 1
488 : ! First, we need to get the index to create block
489 : DO WHILE (dbt_buffer_blocks_left(buffer_recv(iproc)))
490 : CALL dbt_buffer_get_next_block(buffer_recv(iproc), ndata, blk_index_i8)
491 : CALL dbt_tas_blk_sizes(matrix_out, blk_index_i8(1), blk_index_i8(2), blk_size(1), blk_size(2))
492 : ALLOCATE (block(blk_size(1), blk_size(2)))
493 : CALL dbt_buffer_get_next_block(buffer_recv(iproc), ndata, blk_index_i8, block)
494 : CALL dbm_put_block(matrix_out%matrix, INT(blk_index_i8(1)), INT(blk_index_i8(2)), block)
495 : DEALLOCATE (block)
496 : END DO
497 :
498 : CALL dbt_buffer_destroy(buffer_recv(iproc))
499 : END DO
500 : !$OMP END DO
501 : !$OMP END PARALLEL
502 :
503 127775 : CALL dbt_tas_finalize(matrix_out)
504 :
505 127775 : CALL timestop(handle)
506 :
507 2154396 : END SUBROUTINE dbt_tas_replicate
508 :
509 : ! **************************************************************************************************
510 : !> \brief Merge submatrices of matrix_in to matrix_out by sum
511 : !> \param matrix_out ...
512 : !> \param matrix_in ...
513 : !> \param summation ...
514 : !> \param move_data memory optimization: move data to matrix_out such that matrix_in is empty on return
515 : !> \author Patrick Seewald
516 : ! **************************************************************************************************
517 57680 : SUBROUTINE dbt_tas_merge(matrix_out, matrix_in, summation, move_data)
518 : TYPE(dbm_type), INTENT(INOUT) :: matrix_out
519 : TYPE(dbt_tas_type), INTENT(INOUT) :: matrix_in
520 : LOGICAL, INTENT(IN), OPTIONAL :: summation, move_data
521 :
522 : CHARACTER(LEN=*), PARAMETER :: routineN = 'dbt_tas_merge'
523 :
524 : INTEGER :: a, b, bcount, handle, handle2, iproc, &
525 : nblk, nblk_per_thread, ndata, numnodes
526 57680 : INTEGER(KIND=int_8), ALLOCATABLE, DIMENSION(:, :) :: index_recv
527 : INTEGER(KIND=int_8), DIMENSION(2) :: blk_index_i8
528 : INTEGER(kind=omp_lock_kind), ALLOCATABLE, &
529 57680 : DIMENSION(:) :: locks
530 57680 : INTEGER, ALLOCATABLE, DIMENSION(:) :: num_blocks_recv, num_blocks_send, &
531 57680 : num_entries_recv, num_entries_send, &
532 57680 : num_rec, num_send
533 57680 : INTEGER, ALLOCATABLE, DIMENSION(:, :) :: blks_to_allocate
534 : INTEGER, DIMENSION(2) :: blk_index, blk_size
535 115360 : INTEGER, DIMENSION(:), POINTER :: col_block_sizes, row_block_sizes
536 : LOGICAL :: move_prv
537 57680 : REAL(dp), DIMENSION(:, :), POINTER :: block
538 : TYPE(dbm_iterator) :: iter
539 57680 : TYPE(dbt_buffer_type), ALLOCATABLE, DIMENSION(:) :: buffer_recv, buffer_send
540 346080 : TYPE(dbt_tas_split_info) :: info
541 57680 : TYPE(mp_cart_type) :: mp_comm
542 : TYPE(mp_request_type), ALLOCATABLE, &
543 57680 : DIMENSION(:, :) :: req_array
544 :
545 57680 : CALL timeset(routineN, handle)
546 :
547 57680 : IF (PRESENT(summation)) THEN
548 0 : IF (.NOT. summation) CALL dbm_clear(matrix_out)
549 : ELSE
550 57680 : CALL dbm_clear(matrix_out)
551 : END IF
552 :
553 57680 : IF (PRESENT(move_data)) THEN
554 57680 : move_prv = move_data
555 : ELSE
556 : move_prv = .FALSE.
557 : END IF
558 :
559 57680 : info = dbt_tas_info(matrix_in)
560 57680 : CALL dbt_tas_get_split_info(info, mp_comm=mp_comm)
561 57680 : numnodes = mp_comm%num_pe
562 :
563 274528 : ALLOCATE (buffer_send(0:numnodes - 1))
564 216848 : ALLOCATE (buffer_recv(0:numnodes - 1))
565 173040 : ALLOCATE (num_blocks_recv(0:numnodes - 1))
566 115360 : ALLOCATE (num_blocks_send(0:numnodes - 1))
567 115360 : ALLOCATE (num_entries_recv(0:numnodes - 1))
568 115360 : ALLOCATE (num_entries_send(0:numnodes - 1))
569 173040 : ALLOCATE (num_rec(0:2*numnodes - 1))
570 318336 : ALLOCATE (num_send(0:2*numnodes - 1), SOURCE=0)
571 809712 : ALLOCATE (req_array(1:numnodes, 4))
572 115360 : ALLOCATE (locks(0:numnodes - 1))
573 159168 : DO iproc = 0, numnodes - 1
574 159168 : CALL omp_init_lock(locks(iproc))
575 : END DO
576 :
577 : !$OMP PARALLEL DEFAULT(NONE) SHARED(matrix_in,matrix_out,num_send,locks) &
578 57680 : !$OMP PRIVATE(iter,blk_index,blk_size,iproc)
579 : CALL dbm_iterator_start(iter, matrix_in%matrix)
580 : DO WHILE (dbm_iterator_blocks_left(iter))
581 : CALL dbm_iterator_next_block(iter, blk_index(1), blk_index(2), &
582 : row_size=blk_size(1), col_size=blk_size(2))
583 : CALL dbm_get_stored_coordinates(matrix_out, blk_index(1), blk_index(2), iproc)
584 : CALL omp_set_lock(locks(iproc))
585 : num_send(2*iproc) = num_send(2*iproc) + PRODUCT(blk_size)
586 : num_send(2*iproc + 1) = num_send(2*iproc + 1) + 1
587 : CALL omp_unset_lock(locks(iproc))
588 : END DO
589 : CALL dbm_iterator_stop(iter)
590 : !$OMP END PARALLEL
591 :
592 57680 : CALL timeset(routineN//"_alltoall", handle2)
593 57680 : CALL mp_comm%alltoall(num_send, num_rec, 2)
594 57680 : CALL timestop(handle2)
595 :
596 159168 : DO iproc = 0, numnodes - 1
597 101488 : num_entries_recv(iproc) = num_rec(2*iproc)
598 101488 : num_blocks_recv(iproc) = num_rec(2*iproc + 1)
599 101488 : num_entries_send(iproc) = num_send(2*iproc)
600 101488 : num_blocks_send(iproc) = num_send(2*iproc + 1)
601 :
602 101488 : CALL dbt_buffer_create(buffer_send(iproc), num_blocks_send(iproc), num_entries_send(iproc))
603 159168 : CALL dbt_buffer_create(buffer_recv(iproc), num_blocks_recv(iproc), num_entries_recv(iproc))
604 : END DO
605 :
606 : !$OMP PARALLEL DEFAULT(NONE) SHARED(matrix_in,matrix_out,buffer_send,locks) &
607 57680 : !$OMP PRIVATE(iter,blk_index,blk_size,block,iproc)
608 : CALL dbm_iterator_start(iter, matrix_in%matrix)
609 : DO WHILE (dbm_iterator_blocks_left(iter))
610 : CALL dbm_iterator_next_block(iter, blk_index(1), blk_index(2), block, &
611 : row_size=blk_size(1), col_size=blk_size(2))
612 : CALL dbm_get_stored_coordinates(matrix_out, blk_index(1), blk_index(2), iproc)
613 : CALL omp_set_lock(locks(iproc))
614 : CALL dbt_buffer_add_block(buffer_send(iproc), INT(blk_index, KIND=int_8), block)
615 : CALL omp_unset_lock(locks(iproc))
616 : END DO
617 : CALL dbm_iterator_stop(iter)
618 : !$OMP END PARALLEL
619 :
620 57680 : IF (move_prv) CALL dbt_tas_clear(matrix_in)
621 :
622 57680 : CALL timeset(routineN//"_communicate_buffer", handle2)
623 57680 : CALL dbt_tas_communicate_buffer(mp_comm, buffer_recv, buffer_send, req_array)
624 :
625 159168 : DO iproc = 0, numnodes - 1
626 101488 : CALL dbt_buffer_destroy(buffer_send(iproc))
627 159168 : CALL omp_destroy_lock(locks(iproc))
628 : END DO
629 57680 : DEALLOCATE (locks)
630 :
631 57680 : CALL timestop(handle2)
632 :
633 : ! Parallel unpack of received blocks.
634 159168 : nblk = SUM(num_blocks_recv)
635 163912 : ALLOCATE (blks_to_allocate(nblk, 2))
636 :
637 57680 : bcount = 0
638 159168 : DO iproc = 0, numnodes - 1
639 101488 : CALL dbt_buffer_get_index(buffer_recv(iproc), index_recv)
640 2272692 : blks_to_allocate(bcount + 1:bcount + SIZE(index_recv, 1), :) = INT(index_recv(:, :))
641 101488 : bcount = bcount + SIZE(index_recv, 1)
642 260656 : DEALLOCATE (index_recv)
643 : END DO
644 :
645 : !TODO: Parallelize creation of block list.
646 57680 : !$OMP PARALLEL DEFAULT(NONE) SHARED(matrix_out,nblk,blks_to_allocate) PRIVATE(nblk_per_thread,A,b)
647 : nblk_per_thread = nblk/omp_get_num_threads() + 1
648 : a = omp_get_thread_num()*nblk_per_thread + 1
649 : b = MIN(a + nblk_per_thread, nblk)
650 : CALL dbm_reserve_blocks(matrix_out, blks_to_allocate(a:b, 1), blks_to_allocate(a:b, 2))
651 : !$OMP END PARALLEL
652 57680 : DEALLOCATE (blks_to_allocate)
653 :
654 57680 : row_block_sizes => dbm_get_row_block_sizes(matrix_out)
655 57680 : col_block_sizes => dbm_get_col_block_sizes(matrix_out)
656 :
657 : !$OMP PARALLEL DEFAULT(NONE) SHARED(buffer_recv,matrix_out,numnodes,row_block_sizes,col_block_sizes) &
658 57680 : !$OMP PRIVATE(iproc,ndata,blk_index_i8,blk_size,block)
659 : !$OMP DO SCHEDULE(DYNAMIC)
660 : DO iproc = 0, numnodes - 1
661 : ! First, we need to get the index to create block
662 : DO WHILE (dbt_buffer_blocks_left(buffer_recv(iproc)))
663 : CALL dbt_buffer_get_next_block(buffer_recv(iproc), ndata, blk_index_i8)
664 : blk_size(1) = row_block_sizes(INT(blk_index_i8(1)))
665 : blk_size(2) = col_block_sizes(INT(blk_index_i8(2)))
666 : ALLOCATE (block(blk_size(1), blk_size(2)))
667 : CALL dbt_buffer_get_next_block(buffer_recv(iproc), ndata, blk_index_i8, block)
668 : CALL dbm_put_block(matrix_out, INT(blk_index_i8(1)), INT(blk_index_i8(2)), block, summation=.TRUE.)
669 : DEALLOCATE (block)
670 : END DO
671 : CALL dbt_buffer_destroy(buffer_recv(iproc))
672 : END DO
673 : !$OMP END DO
674 : !$OMP END PARALLEL
675 :
676 57680 : CALL dbm_finalize(matrix_out)
677 :
678 57680 : CALL timestop(handle)
679 491376 : END SUBROUTINE dbt_tas_merge
680 :
681 : ! **************************************************************************************************
682 : !> \brief get all indices from buffer
683 : !> \param buffer ...
684 : !> \param index ...
685 : !> \author Patrick Seewald
686 : ! **************************************************************************************************
687 635742 : SUBROUTINE dbt_buffer_get_index(buffer, index)
688 : TYPE(dbt_buffer_type), INTENT(IN) :: buffer
689 : INTEGER(KIND=int_8), ALLOCATABLE, &
690 : DIMENSION(:, :), INTENT(OUT) :: index
691 :
692 : CHARACTER(LEN=*), PARAMETER :: routineN = 'dbt_buffer_get_index'
693 :
694 : INTEGER :: handle
695 : INTEGER, DIMENSION(2) :: indx_shape
696 :
697 635742 : CALL timeset(routineN, handle)
698 :
699 3814452 : indx_shape = SHAPE(buffer%indx) - [0, 1]
700 2367195 : ALLOCATE (INDEX(indx_shape(1), indx_shape(2)))
701 13124988 : INDEX(:, :) = buffer%indx(1:indx_shape(1), 1:indx_shape(2))
702 635742 : CALL timestop(handle)
703 635742 : END SUBROUTINE dbt_buffer_get_index
704 :
705 : ! **************************************************************************************************
706 : !> \brief how many blocks left in iterator
707 : !> \param buffer ...
708 : !> \return ...
709 : !> \author Patrick Seewald
710 : ! **************************************************************************************************
711 6244623 : PURE FUNCTION dbt_buffer_blocks_left(buffer)
712 : TYPE(dbt_buffer_type), INTENT(IN) :: buffer
713 : LOGICAL :: dbt_buffer_blocks_left
714 :
715 6244623 : dbt_buffer_blocks_left = buffer%endpos < buffer%nblock
716 6244623 : END FUNCTION dbt_buffer_blocks_left
717 :
718 : ! **************************************************************************************************
719 : !> \brief Create block buffer for MPI communication.
720 : !> \param buffer block buffer
721 : !> \param nblock number of blocks
722 : !> \param ndata total number of block entries
723 : !> \author Patrick Seewald
724 : ! **************************************************************************************************
725 1271484 : SUBROUTINE dbt_buffer_create(buffer, nblock, ndata)
726 : TYPE(dbt_buffer_type), INTENT(OUT) :: buffer
727 : INTEGER, INTENT(IN) :: nblock, ndata
728 :
729 1271484 : buffer%nblock = nblock
730 1271484 : buffer%endpos = 0
731 3462906 : ALLOCATE (buffer%msg(ndata))
732 3462906 : ALLOCATE (buffer%indx(nblock, 3))
733 1271484 : END SUBROUTINE dbt_buffer_create
734 :
735 : ! **************************************************************************************************
736 : !> \brief ...
737 : !> \param buffer ...
738 : !> \author Patrick Seewald
739 : ! **************************************************************************************************
740 1271484 : SUBROUTINE dbt_buffer_destroy(buffer)
741 : TYPE(dbt_buffer_type), INTENT(INOUT) :: buffer
742 :
743 1271484 : DEALLOCATE (buffer%msg)
744 1271484 : DEALLOCATE (buffer%indx)
745 1271484 : buffer%nblock = -1
746 1271484 : buffer%endpos = -1
747 1271484 : END SUBROUTINE dbt_buffer_destroy
748 :
749 : ! **************************************************************************************************
750 : !> \brief insert a block into block buffer (at current iterator position)
751 : !> \param buffer ...
752 : !> \param index index of block
753 : !> \param block ...
754 : !> \param transposed ...
755 : !> \author Patrick Seewald
756 : ! **************************************************************************************************
757 5608881 : SUBROUTINE dbt_buffer_add_block(buffer, index, block, transposed)
758 : TYPE(dbt_buffer_type), INTENT(INOUT) :: buffer
759 : INTEGER(KIND=int_8), DIMENSION(2), INTENT(IN) :: index
760 : REAL(dp), DIMENSION(:, :), INTENT(IN) :: block
761 : LOGICAL, INTENT(IN), OPTIONAL :: transposed
762 :
763 : INTEGER :: ndata, p, p_data
764 : INTEGER(KIND=int_8), DIMENSION(2) :: index_prv
765 : LOGICAL :: tr
766 :
767 5608881 : IF (PRESENT(transposed)) THEN
768 2526032 : tr = transposed
769 : ELSE
770 : tr = .FALSE.
771 : END IF
772 :
773 5608881 : index_prv(:) = INDEX(:)
774 5608881 : IF (tr) THEN
775 845367 : CALL swap(index_prv)
776 : END IF
777 16826643 : ndata = PRODUCT(SHAPE(block))
778 :
779 5608881 : p = buffer%endpos
780 5608881 : IF (p == 0) THEN
781 : p_data = 0
782 : ELSE
783 5148912 : p_data = INT(buffer%indx(p, 3))
784 : END IF
785 :
786 5608881 : IF (tr) THEN
787 90241755 : buffer%msg(p_data + 1:p_data + ndata) = RESHAPE(TRANSPOSE(block), [ndata])
788 : ELSE
789 732122010 : buffer%msg(p_data + 1:p_data + ndata) = RESHAPE(block, [ndata])
790 : END IF
791 :
792 16826643 : buffer%indx(p + 1, 1:2) = index_prv(:)
793 5608881 : IF (p > 0) THEN
794 5148912 : buffer%indx(p + 1, 3) = buffer%indx(p, 3) + INT(ndata, KIND=int_8)
795 : ELSE
796 459969 : buffer%indx(p + 1, 3) = INT(ndata, KIND=int_8)
797 : END IF
798 5608881 : buffer%endpos = buffer%endpos + 1
799 5608881 : END SUBROUTINE dbt_buffer_add_block
800 :
801 : ! **************************************************************************************************
802 : !> \brief get next block from buffer. Iterator is advanced only if block is retrieved or advance_iter.
803 : !> \param buffer ...
804 : !> \param ndata ...
805 : !> \param index ...
806 : !> \param block ...
807 : !> \param advance_iter ...
808 : !> \author Patrick Seewald
809 : ! **************************************************************************************************
810 11217762 : SUBROUTINE dbt_buffer_get_next_block(buffer, ndata, index, block, advance_iter)
811 : TYPE(dbt_buffer_type), INTENT(INOUT) :: buffer
812 : INTEGER, INTENT(OUT) :: ndata
813 : INTEGER(KIND=int_8), DIMENSION(2), INTENT(OUT) :: index
814 : REAL(dp), DIMENSION(:, :), INTENT(OUT), OPTIONAL :: block
815 : LOGICAL, INTENT(IN), OPTIONAL :: advance_iter
816 :
817 : INTEGER :: p, p_data
818 : LOGICAL :: do_advance
819 :
820 11217762 : do_advance = .FALSE.
821 11217762 : IF (PRESENT(advance_iter)) THEN
822 0 : do_advance = advance_iter
823 11217762 : ELSE IF (PRESENT(block)) THEN
824 5608881 : do_advance = .TRUE.
825 : END IF
826 :
827 11217762 : p = buffer%endpos
828 11217762 : IF (p == 0) THEN
829 : p_data = 0
830 : ELSE
831 10297824 : p_data = INT(buffer%indx(p, 3))
832 : END IF
833 :
834 10297824 : IF (p > 0) THEN
835 10297824 : ndata = INT(buffer%indx(p + 1, 3) - buffer%indx(p, 3))
836 : ELSE
837 919938 : ndata = INT(buffer%indx(p + 1, 3))
838 : END IF
839 33653286 : INDEX(:) = buffer%indx(p + 1, 1:2)
840 :
841 11217762 : IF (PRESENT(block)) THEN
842 16826643 : block(:, :) = RESHAPE(buffer%msg(p_data + 1:p_data + ndata), SHAPE(block))
843 : END IF
844 :
845 11217762 : IF (do_advance) buffer%endpos = buffer%endpos + 1
846 11217762 : END SUBROUTINE dbt_buffer_get_next_block
847 :
848 : ! **************************************************************************************************
849 : !> \brief communicate buffer
850 : !> \param mp_comm ...
851 : !> \param buffer_recv ...
852 : !> \param buffer_send ...
853 : !> \param req_array ...
854 : !> \author Patrick Seewald
855 : ! **************************************************************************************************
856 4471718 : SUBROUTINE dbt_tas_communicate_buffer(mp_comm, buffer_recv, buffer_send, req_array)
857 : CLASS(mp_comm_type), INTENT(IN) :: mp_comm
858 : TYPE(dbt_buffer_type), DIMENSION(0:), &
859 : INTENT(INOUT) :: buffer_recv, buffer_send
860 : TYPE(mp_request_type), DIMENSION(:, :), &
861 : INTENT(OUT) :: req_array
862 :
863 : CHARACTER(LEN=*), PARAMETER :: routineN = 'dbt_tas_communicate_buffer'
864 :
865 : INTEGER :: handle, iproc, numnodes, &
866 : rec_counter, send_counter
867 :
868 385750 : CALL timeset(routineN, handle)
869 385750 : numnodes = mp_comm%num_pe
870 :
871 385750 : IF (numnodes > 1) THEN
872 :
873 249992 : send_counter = 0
874 249992 : rec_counter = 0
875 :
876 749976 : DO iproc = 0, numnodes - 1
877 749976 : IF (buffer_recv(iproc)%nblock > 0) THEN
878 342467 : rec_counter = rec_counter + 1
879 342467 : CALL mp_comm%irecv(buffer_recv(iproc)%indx, iproc, req_array(rec_counter, 3), tag=4)
880 342467 : CALL mp_comm%irecv(buffer_recv(iproc)%msg, iproc, req_array(rec_counter, 4), tag=7)
881 : END IF
882 : END DO
883 :
884 749976 : DO iproc = 0, numnodes - 1
885 749976 : IF (buffer_send(iproc)%nblock > 0) THEN
886 342467 : send_counter = send_counter + 1
887 342467 : CALL mp_comm%isend(buffer_send(iproc)%indx, iproc, req_array(send_counter, 1), tag=4)
888 342467 : CALL mp_comm%isend(buffer_send(iproc)%msg, iproc, req_array(send_counter, 2), tag=7)
889 : END IF
890 : END DO
891 :
892 249992 : IF (send_counter > 0) THEN
893 217688 : CALL mp_waitall(req_array(1:send_counter, 1:2))
894 : END IF
895 249992 : IF (rec_counter > 0) THEN
896 237876 : CALL mp_waitall(req_array(1:rec_counter, 3:4))
897 : END IF
898 :
899 : ELSE
900 135758 : IF (buffer_recv(0)%nblock > 0) THEN
901 5181190 : buffer_recv(0)%indx(:, :) = buffer_send(0)%indx(:, :)
902 463517707 : buffer_recv(0)%msg(:) = buffer_send(0)%msg(:)
903 : END IF
904 : END IF
905 385750 : CALL timestop(handle)
906 385750 : END SUBROUTINE dbt_tas_communicate_buffer
907 :
908 257975 : END MODULE dbt_tas_reshape_ops
|
