(git:ed6f26b)
Loading...
Searching...
No Matches
dbt_tas_test.F
Go to the documentation of this file.
1!--------------------------------------------------------------------------------------------------!
2! CP2K: A general program to perform molecular dynamics simulations !
3! Copyright 2000-2025 CP2K developers group <https://cp2k.org> !
4! !
5! SPDX-License-Identifier: GPL-2.0-or-later !
6!--------------------------------------------------------------------------------------------------!
7
8! **************************************************************************************************
9!> \brief testing infrastructure for tall-and-skinny matrices
10!> \author Patrick Seewald
11! **************************************************************************************************
12MODULE dbt_tas_test
13 USE dbm_api, ONLY: &
14 dbm_add, dbm_checksum, dbm_create, dbm_distribution_new, dbm_distribution_obj, &
15 dbm_distribution_release, dbm_finalize, dbm_get_col_block_sizes, dbm_get_name, &
16 dbm_get_row_block_sizes, dbm_maxabs, dbm_multiply, dbm_redistribute, dbm_release, &
17 dbm_scale, dbm_type
18 USE dbm_tests, ONLY: generate_larnv_seed
19 USE dbt_tas_base, ONLY: &
20 dbt_tas_convert_to_dbm, dbt_tas_create, dbt_tas_distribution_new, dbt_tas_finalize, &
21 dbt_tas_get_stored_coordinates, dbt_tas_info, dbt_tas_nblkcols_total, &
22 dbt_tas_nblkrows_total, dbt_tas_put_block
23 USE dbt_tas_global, ONLY: dbt_tas_blk_size_arb,&
24 dbt_tas_default_distvec,&
25 dbt_tas_dist_cyclic
26 USE dbt_tas_mm, ONLY: dbt_tas_multiply
27 USE dbt_tas_split, ONLY: dbt_tas_get_split_info,&
28 dbt_tas_mp_comm
29 USE dbt_tas_types, ONLY: dbt_tas_distribution_type,&
30 dbt_tas_type
31 USE kinds, ONLY: dp,&
32 int_8
33 USE message_passing, ONLY: mp_cart_type,&
34 mp_comm_type
35#include "../../base/base_uses.f90"
36
37 IMPLICIT NONE
38 PRIVATE
39
40 PUBLIC :: &
41 dbt_tas_benchmark_mm, &
42 dbt_tas_checksum, &
43 dbt_tas_random_bsizes, &
44 dbt_tas_setup_test_matrix, &
45 dbt_tas_test_mm, &
46 dbt_tas_reset_randmat_seed
47
48 INTEGER, SAVE :: randmat_counter = 0
49 INTEGER, PARAMETER, PRIVATE :: rand_seed_init = 12341313
50
51CONTAINS
52
53! **************************************************************************************************
54!> \brief Setup tall-and-skinny matrix for testing
55!> \param matrix ...
56!> \param mp_comm_out ...
57!> \param mp_comm ...
58!> \param nrows ...
59!> \param ncols ...
60!> \param rbsizes ...
61!> \param cbsizes ...
62!> \param dist_splitsize ...
63!> \param name ...
64!> \param sparsity ...
65!> \param reuse_comm ...
66!> \author Patrick Seewald
67! **************************************************************************************************
68 SUBROUTINE dbt_tas_setup_test_matrix(matrix, mp_comm_out, mp_comm, nrows, ncols, rbsizes, &
69 cbsizes, dist_splitsize, name, sparsity, reuse_comm)
70 TYPE(dbt_tas_type), INTENT(OUT) :: matrix
71 TYPE(mp_cart_type), INTENT(OUT) :: mp_comm_out
72
73 CLASS(mp_comm_type), INTENT(IN) :: mp_comm
74 INTEGER(KIND=int_8), INTENT(IN) :: nrows, ncols
75 INTEGER, DIMENSION(nrows), INTENT(IN) :: rbsizes
76 INTEGER, DIMENSION(ncols), INTENT(IN) :: cbsizes
77 INTEGER, DIMENSION(2), INTENT(IN) :: dist_splitsize
78 CHARACTER(len=*), INTENT(IN) :: name
79 REAL(kind=dp), INTENT(IN) :: sparsity
80 LOGICAL, INTENT(IN), OPTIONAL :: reuse_comm
81
82 CHARACTER(LEN=*), PARAMETER :: routinen = 'dbt_tas_setup_test_matrix'
83
84 INTEGER :: col_size, handle, max_col_size, max_nze, &
85 max_row_size, mynode, node_holds_blk, &
86 nze, row_size
87 INTEGER(KIND=int_8) :: col, col_s, ncol, nrow, row, row_s
88 INTEGER, DIMENSION(2) :: pdims
89 INTEGER, DIMENSION(4) :: iseed, jseed
90 LOGICAL :: reuse_comm_prv, tr
91 REAL(kind=dp), ALLOCATABLE, DIMENSION(:, :) :: values
92 REAL(kind=dp), DIMENSION(1) :: rn
93 TYPE(dbt_tas_blk_size_arb) :: cbsize_obj, rbsize_obj
94 TYPE(dbt_tas_dist_cyclic) :: col_dist_obj, row_dist_obj
95 TYPE(dbt_tas_distribution_type) :: dist
96
97 ! we don't reserve blocks prior to putting them, so this time is meaningless and should not
98 ! be considered in benchmark!
99 CALL timeset(routinen, handle)
100
101 ! Check that the counter was initialised (or has not overflowed)
102 cpassert(randmat_counter .NE. 0)
103 ! the counter goes into the seed. Every new call gives a new random matrix
104 randmat_counter = randmat_counter + 1
105
106 IF (PRESENT(reuse_comm)) THEN
107 reuse_comm_prv = reuse_comm
108 ELSE
109 reuse_comm_prv = .false.
110 END IF
111
112 IF (reuse_comm_prv) THEN
113 mp_comm_out = mp_comm
114 ELSE
115 mp_comm_out = dbt_tas_mp_comm(mp_comm, nrows, ncols)
116 END IF
117
118 mynode = mp_comm_out%mepos
119 pdims = mp_comm_out%num_pe_cart
120
121 row_dist_obj = dbt_tas_dist_cyclic(dist_splitsize(1), pdims(1), nrows)
122 col_dist_obj = dbt_tas_dist_cyclic(dist_splitsize(2), pdims(2), ncols)
123
124 rbsize_obj = dbt_tas_blk_size_arb(rbsizes)
125 cbsize_obj = dbt_tas_blk_size_arb(cbsizes)
126
127 CALL dbt_tas_distribution_new(dist, mp_comm_out, row_dist_obj, col_dist_obj)
128 CALL dbt_tas_create(matrix, name=trim(name), dist=dist, &
129 row_blk_size=rbsize_obj, col_blk_size=cbsize_obj, own_dist=.true.)
130
131 max_row_size = maxval(rbsizes)
132 max_col_size = maxval(cbsizes)
133 max_nze = max_row_size*max_col_size
134
135 nrow = dbt_tas_nblkrows_total(matrix)
136 ncol = dbt_tas_nblkcols_total(matrix)
137
138 ALLOCATE (values(max_row_size, max_col_size))
139
140 jseed = generate_larnv_seed(7, 42, 3, 42, randmat_counter)
141
142 DO row = 1, dbt_tas_nblkrows_total(matrix)
143 DO col = 1, dbt_tas_nblkcols_total(matrix)
144 CALL dlarnv(1, jseed, 1, rn)
145 IF (rn(1) .LT. sparsity) THEN
146 tr = .false.
147 row_s = row; col_s = col
148 CALL dbt_tas_get_stored_coordinates(matrix, row_s, col_s, node_holds_blk)
149
150 IF (node_holds_blk .EQ. mynode) THEN
151 row_size = rbsize_obj%data(row_s)
152 col_size = cbsize_obj%data(col_s)
153 nze = row_size*col_size
154 iseed = generate_larnv_seed(int(row_s), int(nrow), int(col_s), int(ncol), randmat_counter)
155 CALL dlarnv(1, iseed, max_nze, values)
156 CALL dbt_tas_put_block(matrix, row_s, col_s, values(1:row_size, 1:col_size))
157 END IF
158 END IF
159 END DO
160 END DO
161
162 CALL dbt_tas_finalize(matrix)
163
164 CALL timestop(handle)
165
166 END SUBROUTINE
167
168! **************************************************************************************************
169!> \brief Benchmark routine. Due to random sparsity (as opposed to structured sparsity pattern),
170!> this may not be representative for actual applications.
171!> \param transa ...
172!> \param transb ...
173!> \param transc ...
174!> \param matrix_a ...
175!> \param matrix_b ...
176!> \param matrix_c ...
177!> \param compare_dbm ...
178!> \param filter_eps ...
179!> \param io_unit ...
180!> \author Patrick Seewald
181! **************************************************************************************************
182 SUBROUTINE dbt_tas_benchmark_mm(transa, transb, transc, matrix_a, matrix_b, matrix_c, compare_dbm, filter_eps, io_unit)
183
184 LOGICAL, INTENT(IN) :: transa, transb, transc
185 TYPE(dbt_tas_type), INTENT(INOUT) :: matrix_a, matrix_b, matrix_c
186 LOGICAL, INTENT(IN) :: compare_dbm
187 REAL(kind=dp), INTENT(IN), OPTIONAL :: filter_eps
188 INTEGER, INTENT(IN), OPTIONAL :: io_unit
189
190 INTEGER :: handle1, handle2
191 INTEGER, CONTIGUOUS, DIMENSION(:), POINTER :: cd_a, cd_b, cd_c, col_block_sizes_a, &
192 col_block_sizes_b, col_block_sizes_c, rd_a, rd_b, rd_c, row_block_sizes_a, &
193 row_block_sizes_b, row_block_sizes_c
194 INTEGER, DIMENSION(2) :: npdims
195 TYPE(dbm_distribution_obj) :: dist_a, dist_b, dist_c
196 TYPE(dbm_type) :: dbm_a, dbm_a_mm, dbm_b, dbm_b_mm, dbm_c, &
197 dbm_c_mm
198 TYPE(mp_cart_type) :: comm_dbm, mp_comm
199
200!
201! TODO: Dedup with code in dbt_tas_test_mm.
202!
203 IF (PRESENT(io_unit)) THEN
204 IF (io_unit > 0) THEN
205 WRITE (io_unit, "(A)") "starting tall-and-skinny benchmark"
206 END IF
207 END IF
208 CALL timeset("benchmark_tas_mm", handle1)
209 CALL dbt_tas_multiply(transa, transb, transc, 1.0_dp, matrix_a, matrix_b, &
210 0.0_dp, matrix_c, &
211 filter_eps=filter_eps, unit_nr=io_unit)
212 CALL timestop(handle1)
213 IF (PRESENT(io_unit)) THEN
214 IF (io_unit > 0) THEN
215 WRITE (io_unit, "(A)") "tall-and-skinny benchmark completed"
216 END IF
217 END IF
218
219 IF (compare_dbm) THEN
220 CALL dbt_tas_convert_to_dbm(matrix_a, dbm_a)
221 CALL dbt_tas_convert_to_dbm(matrix_b, dbm_b)
222 CALL dbt_tas_convert_to_dbm(matrix_c, dbm_c)
223
224 CALL dbt_tas_get_split_info(dbt_tas_info(matrix_a), mp_comm=mp_comm)
225 npdims(:) = 0
226 CALL comm_dbm%create(mp_comm, 2, npdims)
227
228 ALLOCATE (rd_a(SIZE(dbm_get_row_block_sizes(dbm_a))))
229 ALLOCATE (rd_b(SIZE(dbm_get_row_block_sizes(dbm_b))))
230 ALLOCATE (rd_c(SIZE(dbm_get_row_block_sizes(dbm_c))))
231 ALLOCATE (cd_a(SIZE(dbm_get_col_block_sizes(dbm_a))))
232 ALLOCATE (cd_b(SIZE(dbm_get_col_block_sizes(dbm_b))))
233 ALLOCATE (cd_c(SIZE(dbm_get_col_block_sizes(dbm_c))))
234
235 CALL dbt_tas_default_distvec(int(SIZE(dbm_get_row_block_sizes(dbm_a))), &
236 npdims(1), dbm_get_row_block_sizes(dbm_a), rd_a)
237 CALL dbt_tas_default_distvec(int(SIZE(dbm_get_col_block_sizes(dbm_a))), &
238 npdims(2), dbm_get_col_block_sizes(dbm_a), cd_a)
239 CALL dbt_tas_default_distvec(int(SIZE(dbm_get_row_block_sizes(dbm_b))), &
240 npdims(1), dbm_get_row_block_sizes(dbm_b), rd_b)
241 CALL dbt_tas_default_distvec(int(SIZE(dbm_get_col_block_sizes(dbm_b))), &
242 npdims(2), dbm_get_col_block_sizes(dbm_b), cd_b)
243 CALL dbt_tas_default_distvec(int(SIZE(dbm_get_row_block_sizes(dbm_c))), &
244 npdims(1), dbm_get_row_block_sizes(dbm_c), rd_c)
245 CALL dbt_tas_default_distvec(int(SIZE(dbm_get_col_block_sizes(dbm_c))), &
246 npdims(2), dbm_get_col_block_sizes(dbm_c), cd_c)
247
248 CALL dbm_distribution_new(dist_a, comm_dbm, rd_a, cd_a)
249 CALL dbm_distribution_new(dist_b, comm_dbm, rd_b, cd_b)
250 CALL dbm_distribution_new(dist_c, comm_dbm, rd_c, cd_c)
251 DEALLOCATE (rd_a, rd_b, rd_c, cd_a, cd_b, cd_c)
252
253 ! Store pointers in intermediate variables to workaround a CCE error.
254 row_block_sizes_a => dbm_get_row_block_sizes(dbm_a)
255 col_block_sizes_a => dbm_get_col_block_sizes(dbm_a)
256 row_block_sizes_b => dbm_get_row_block_sizes(dbm_b)
257 col_block_sizes_b => dbm_get_col_block_sizes(dbm_b)
258 row_block_sizes_c => dbm_get_row_block_sizes(dbm_c)
259 col_block_sizes_c => dbm_get_col_block_sizes(dbm_c)
260
261 CALL dbm_create(matrix=dbm_a_mm, name=dbm_get_name(dbm_a), dist=dist_a, &
262 row_block_sizes=row_block_sizes_a, col_block_sizes=col_block_sizes_a)
263
264 CALL dbm_create(matrix=dbm_b_mm, name=dbm_get_name(dbm_b), dist=dist_b, &
265 row_block_sizes=row_block_sizes_b, col_block_sizes=col_block_sizes_b)
266
267 CALL dbm_create(matrix=dbm_c_mm, name=dbm_get_name(dbm_c), dist=dist_c, &
268 row_block_sizes=row_block_sizes_c, col_block_sizes=col_block_sizes_c)
269
270 CALL dbm_finalize(dbm_a_mm)
271 CALL dbm_finalize(dbm_b_mm)
272 CALL dbm_finalize(dbm_c_mm)
273
274 CALL dbm_redistribute(dbm_a, dbm_a_mm)
275 CALL dbm_redistribute(dbm_b, dbm_b_mm)
276 IF (PRESENT(io_unit)) THEN
277 IF (io_unit > 0) THEN
278 WRITE (io_unit, "(A)") "starting dbm benchmark"
279 END IF
280 END IF
281 CALL timeset("benchmark_block_mm", handle2)
282 CALL dbm_multiply(transa, transb, 1.0_dp, dbm_a_mm, dbm_b_mm, &
283 0.0_dp, dbm_c_mm, filter_eps=filter_eps)
284 CALL timestop(handle2)
285 IF (PRESENT(io_unit)) THEN
286 IF (io_unit > 0) THEN
287 WRITE (io_unit, "(A)") "dbm benchmark completed"
288 END IF
289 END IF
290
291 CALL dbm_release(dbm_a)
292 CALL dbm_release(dbm_b)
293 CALL dbm_release(dbm_c)
294 CALL dbm_release(dbm_a_mm)
295 CALL dbm_release(dbm_b_mm)
296 CALL dbm_release(dbm_c_mm)
297 CALL dbm_distribution_release(dist_a)
298 CALL dbm_distribution_release(dist_b)
299 CALL dbm_distribution_release(dist_c)
300
301 CALL comm_dbm%free()
302 END IF
303
304 END SUBROUTINE
305
306! **************************************************************************************************
307!> \brief Test tall-and-skinny matrix multiplication for accuracy
308!> \param transa ...
309!> \param transb ...
310!> \param transc ...
311!> \param matrix_a ...
312!> \param matrix_b ...
313!> \param matrix_c ...
314!> \param filter_eps ...
315!> \param unit_nr ...
316!> \param log_verbose ...
317!> \author Patrick Seewald
318! **************************************************************************************************
319 SUBROUTINE dbt_tas_test_mm(transa, transb, transc, matrix_a, matrix_b, matrix_c, filter_eps, unit_nr, log_verbose)
320 LOGICAL, INTENT(IN) :: transa, transb, transc
321 TYPE(dbt_tas_type), INTENT(INOUT) :: matrix_a, matrix_b, matrix_c
322 REAL(kind=dp), INTENT(IN), OPTIONAL :: filter_eps
323 INTEGER, INTENT(IN) :: unit_nr
324 LOGICAL, INTENT(IN), OPTIONAL :: log_verbose
325
326 REAL(kind=dp), PARAMETER :: test_tol = 1.0e-10_dp
327
328 CHARACTER(LEN=8) :: status_str
329 INTEGER :: io_unit, mynode
330 INTEGER, CONTIGUOUS, DIMENSION(:), POINTER :: cd_a, cd_b, cd_c, col_block_sizes_a, &
331 col_block_sizes_b, col_block_sizes_c, rd_a, rd_b, rd_c, row_block_sizes_a, &
332 row_block_sizes_b, row_block_sizes_c
333 INTEGER, DIMENSION(2) :: npdims
334 LOGICAL :: abort, transa_prv, transb_prv
335 REAL(kind=dp) :: norm, rc_cs, sq_cs
336 TYPE(dbm_distribution_obj) :: dist_a, dist_b, dist_c
337 TYPE(dbm_type) :: dbm_a, dbm_a_mm, dbm_b, dbm_b_mm, dbm_c, &
338 dbm_c_mm, dbm_c_mm_check
339 TYPE(mp_cart_type) :: comm_dbm, mp_comm
340
341!
342! TODO: Dedup with code in dbt_tas_benchmark_mm.
343!
344
345 CALL dbt_tas_get_split_info(dbt_tas_info(matrix_a), mp_comm=mp_comm)
346 mynode = mp_comm%mepos
347 abort = .false.
348 io_unit = -1
349 IF (mynode .EQ. 0) io_unit = unit_nr
350
351 CALL dbt_tas_multiply(transa, transb, transc, 1.0_dp, matrix_a, matrix_b, &
352 0.0_dp, matrix_c, &
353 filter_eps=filter_eps, unit_nr=io_unit, log_verbose=log_verbose, optimize_dist=.true.)
354
355 CALL dbt_tas_convert_to_dbm(matrix_a, dbm_a)
356 CALL dbt_tas_convert_to_dbm(matrix_b, dbm_b)
357 CALL dbt_tas_convert_to_dbm(matrix_c, dbm_c)
358
359 npdims(:) = 0
360 CALL comm_dbm%create(mp_comm, 2, npdims)
361
362 ALLOCATE (rd_a(SIZE(dbm_get_row_block_sizes(dbm_a))))
363 ALLOCATE (rd_b(SIZE(dbm_get_row_block_sizes(dbm_b))))
364 ALLOCATE (rd_c(SIZE(dbm_get_row_block_sizes(dbm_c))))
365 ALLOCATE (cd_a(SIZE(dbm_get_col_block_sizes(dbm_a))))
366 ALLOCATE (cd_b(SIZE(dbm_get_col_block_sizes(dbm_b))))
367 ALLOCATE (cd_c(SIZE(dbm_get_col_block_sizes(dbm_c))))
368
369 CALL dbt_tas_default_distvec(int(SIZE(dbm_get_row_block_sizes(dbm_a))), &
370 npdims(1), dbm_get_row_block_sizes(dbm_a), rd_a)
371 CALL dbt_tas_default_distvec(int(SIZE(dbm_get_col_block_sizes(dbm_a))), &
372 npdims(2), dbm_get_col_block_sizes(dbm_a), cd_a)
373 CALL dbt_tas_default_distvec(int(SIZE(dbm_get_row_block_sizes(dbm_b))), &
374 npdims(1), dbm_get_row_block_sizes(dbm_b), rd_b)
375 CALL dbt_tas_default_distvec(int(SIZE(dbm_get_col_block_sizes(dbm_b))), &
376 npdims(2), dbm_get_col_block_sizes(dbm_b), cd_b)
377 CALL dbt_tas_default_distvec(int(SIZE(dbm_get_row_block_sizes(dbm_c))), &
378 npdims(1), dbm_get_row_block_sizes(dbm_c), rd_c)
379 CALL dbt_tas_default_distvec(int(SIZE(dbm_get_col_block_sizes(dbm_c))), &
380 npdims(2), dbm_get_col_block_sizes(dbm_c), cd_c)
381
382 CALL dbm_distribution_new(dist_a, comm_dbm, rd_a, cd_a)
383 CALL dbm_distribution_new(dist_b, comm_dbm, rd_b, cd_b)
384 CALL dbm_distribution_new(dist_c, comm_dbm, rd_c, cd_c)
385 DEALLOCATE (rd_a, rd_b, rd_c, cd_a, cd_b, cd_c)
386
387 ! Store pointers in intermediate variables to workaround a CCE error.
388 row_block_sizes_a => dbm_get_row_block_sizes(dbm_a)
389 col_block_sizes_a => dbm_get_col_block_sizes(dbm_a)
390 row_block_sizes_b => dbm_get_row_block_sizes(dbm_b)
391 col_block_sizes_b => dbm_get_col_block_sizes(dbm_b)
392 row_block_sizes_c => dbm_get_row_block_sizes(dbm_c)
393 col_block_sizes_c => dbm_get_col_block_sizes(dbm_c)
394
395 CALL dbm_create(matrix=dbm_a_mm, name="matrix a", dist=dist_a, &
396 row_block_sizes=row_block_sizes_a, col_block_sizes=col_block_sizes_a)
397
398 CALL dbm_create(matrix=dbm_b_mm, name="matrix b", dist=dist_b, &
399 row_block_sizes=row_block_sizes_b, col_block_sizes=col_block_sizes_b)
400
401 CALL dbm_create(matrix=dbm_c_mm, name="matrix c", dist=dist_c, &
402 row_block_sizes=row_block_sizes_c, col_block_sizes=col_block_sizes_c)
403
404 CALL dbm_create(matrix=dbm_c_mm_check, name="matrix c check", dist=dist_c, &
405 row_block_sizes=row_block_sizes_c, col_block_sizes=col_block_sizes_c)
406
407 CALL dbm_finalize(dbm_a_mm)
408 CALL dbm_finalize(dbm_b_mm)
409 CALL dbm_finalize(dbm_c_mm)
410 CALL dbm_finalize(dbm_c_mm_check)
411
412 CALL dbm_redistribute(dbm_a, dbm_a_mm)
413 CALL dbm_redistribute(dbm_b, dbm_b_mm)
414 CALL dbm_redistribute(dbm_c, dbm_c_mm_check)
415
416 transa_prv = transa; transb_prv = transb
417
418 IF (.NOT. transc) THEN
419 CALL dbm_multiply(transa_prv, transb_prv, 1.0_dp, &
420 dbm_a_mm, dbm_b_mm, &
421 0.0_dp, dbm_c_mm, filter_eps=filter_eps)
422 ELSE
423 transa_prv = .NOT. transa_prv
424 transb_prv = .NOT. transb_prv
425 CALL dbm_multiply(transb_prv, transa_prv, 1.0_dp, &
426 dbm_b_mm, dbm_a_mm, &
427 0.0_dp, dbm_c_mm, filter_eps=filter_eps)
428 END IF
429
430 sq_cs = dbm_checksum(dbm_c_mm)
431 rc_cs = dbm_checksum(dbm_c_mm_check)
432 CALL dbm_scale(dbm_c_mm_check, -1.0_dp)
433 CALL dbm_add(dbm_c_mm_check, dbm_c_mm)
434 norm = dbm_maxabs(dbm_c_mm_check)
435
436 IF (io_unit > 0) THEN
437 IF (abs(norm) > test_tol) THEN
438 status_str = " failed!"
439 abort = .true.
440 ELSE
441 status_str = " passed!"
442 abort = .false.
443 END IF
444 WRITE (io_unit, "(A)") &
445 trim(dbm_get_name(matrix_a%matrix))//" x "// &
446 trim(dbm_get_name(matrix_b%matrix))//trim(status_str)
447 WRITE (io_unit, "(A,1X,E9.2,1X,E9.2)") "checksums", sq_cs, rc_cs
448 WRITE (io_unit, "(A,1X,E9.2)") "difference norm", norm
449 IF (abort) cpabort("DBT TAS test failed")
450 END IF
451
452 CALL dbm_release(dbm_a)
453 CALL dbm_release(dbm_a_mm)
454 CALL dbm_release(dbm_b)
455 CALL dbm_release(dbm_b_mm)
456 CALL dbm_release(dbm_c)
457 CALL dbm_release(dbm_c_mm)
458 CALL dbm_release(dbm_c_mm_check)
459
460 CALL dbm_distribution_release(dist_a)
461 CALL dbm_distribution_release(dist_b)
462 CALL dbm_distribution_release(dist_c)
463
464 CALL comm_dbm%free()
465
466 END SUBROUTINE dbt_tas_test_mm
467
468! **************************************************************************************************
469!> \brief Calculate checksum of tall-and-skinny matrix consistent with dbm_checksum
470!> \param matrix ...
471!> \return ...
472!> \author Patrick Seewald
473! **************************************************************************************************
474 FUNCTION dbt_tas_checksum(matrix)
475 TYPE(dbt_tas_type), INTENT(IN) :: matrix
476 REAL(kind=dp) :: dbt_tas_checksum
477
478 TYPE(dbm_type) :: dbm_m
479
480 CALL dbt_tas_convert_to_dbm(matrix, dbm_m)
481 dbt_tas_checksum = dbm_checksum(dbm_m)
482 CALL dbm_release(dbm_m)
483 END FUNCTION
484
485! **************************************************************************************************
486!> \brief Create random block sizes
487!> \param sizes ...
488!> \param repeat ...
489!> \param dbt_sizes ...
490!> \author Patrick Seewald
491! **************************************************************************************************
492 SUBROUTINE dbt_tas_random_bsizes(sizes, repeat, dbt_sizes)
493 INTEGER, DIMENSION(:), INTENT(IN) :: sizes
494 INTEGER, INTENT(IN) :: repeat
495 INTEGER, DIMENSION(:), INTENT(OUT) :: dbt_sizes
496
497 INTEGER :: d, size_i
498
499 DO d = 1, SIZE(dbt_sizes)
500 size_i = mod((d - 1)/repeat, SIZE(sizes)) + 1
501 dbt_sizes(d) = sizes(size_i)
502 END DO
503 END SUBROUTINE
504
505! **************************************************************************************************
506!> \brief Reset the seed used for generating random matrices to default value
507!> \author Patrick Seewald
508! **************************************************************************************************
509 SUBROUTINE dbt_tas_reset_randmat_seed()
510 randmat_counter = rand_seed_init
511 END SUBROUTINE
512
513END MODULE
dbt_tas_base::dbt_tas_create
Definition dbt_tas_base.F:89
dbt_tas_split::dbt_tas_mp_comm
Definition dbt_tas_split.F:54
dbm_api
Definition dbm_api.F:8
dbm_api::dbm_multiply
subroutine, public dbm_multiply(transa, transb, alpha, matrix_a, matrix_b, beta, matrix_c, retain_sparsity, filter_eps, flop)
Computes matrix product: matrix_c = alpha * matrix_a * matrix_b + beta * matrix_c.
Definition dbm_api.F:736
dbm_api::dbm_redistribute
subroutine, public dbm_redistribute(matrix, redist)
Copies content of matrix_b into matrix_a. Matrices may have different distributions.
Definition dbm_api.F:412
dbm_api::dbm_maxabs
real(kind=dp) function, public dbm_maxabs(matrix)
Returns the absolute value of the larges element of the entire given matrix.
Definition dbm_api.F:996
dbm_api::dbm_scale
subroutine, public dbm_scale(matrix, alpha)
Multiplies all entries in the given matrix by the given factor alpha.
Definition dbm_api.F:631
dbm_api::dbm_distribution_release
subroutine, public dbm_distribution_release(dist)
Decreases the reference counter of the given distribution.
Definition dbm_api.F:1401
dbm_api::dbm_create
subroutine, public dbm_create(matrix, name, dist, row_block_sizes, col_block_sizes)
Creates a new matrix.
Definition dbm_api.F:293
dbm_api::dbm_get_row_block_sizes
integer function, dimension(:), pointer, contiguous, public dbm_get_row_block_sizes(matrix)
Returns the row block sizes of the given matrix.
Definition dbm_api.F:1103
dbm_api::dbm_get_name
character(len=default_string_length) function, public dbm_get_name(matrix)
Returns the name of the matrix of the given matrix.
Definition dbm_api.F:1023
dbm_api::dbm_checksum
real(kind=dp) function, public dbm_checksum(matrix)
Computes a checksum of the given matrix.
Definition dbm_api.F:969
dbm_api::dbm_add
subroutine, public dbm_add(matrix_a, matrix_b)
Adds matrix_b to matrix_a.
Definition dbm_api.F:692
dbm_api::dbm_finalize
subroutine, public dbm_finalize(matrix)
Needed to be called for DBCSR after blocks where inserted. For DBM it's a no-opt.
Definition dbm_api.F:339
dbm_api::dbm_release
subroutine, public dbm_release(matrix)
Releases a matrix and all its ressources.
Definition dbm_api.F:354
dbm_api::dbm_get_col_block_sizes
integer function, dimension(:), pointer, contiguous, public dbm_get_col_block_sizes(matrix)
Returns the column block sizes of the given matrix.
Definition dbm_api.F:1130
dbm_api::dbm_distribution_new
subroutine, public dbm_distribution_new(dist, mp_comm, row_dist_block, col_dist_block)
Creates a new two dimensional distribution.
Definition dbm_api.F:1294
dbm_tests
Definition dbm_tests.F:8
dbm_tests::generate_larnv_seed
integer function, dimension(4), public generate_larnv_seed(irow, nrow, icol, ncol, ival)
Generate a seed respecting the lapack constraints,.
Definition dbm_tests.F:435
dbt_tas_base
Tall-and-skinny matrices: base routines similar to DBM API, mostly wrappers around existing DBM routi...
Definition dbt_tas_base.F:13
dbt_tas_base::dbt_tas_convert_to_dbm
subroutine, public dbt_tas_convert_to_dbm(matrix_rect, matrix_dbm)
Convert a tall-and-skinny matrix into a normal DBM matrix. This is not recommended for matrices with ...
Definition dbt_tas_base.F:524
dbt_tas_base::dbt_tas_get_stored_coordinates
subroutine, public dbt_tas_get_stored_coordinates(matrix, row, column, processor)
As dbt_get_stored_coordinates.
Definition dbt_tas_base.F:462
dbt_tas_base::dbt_tas_nblkrows_total
pure integer(kind=int_8) function, public dbt_tas_nblkrows_total(matrix)
...
Definition dbt_tas_base.F:838
dbt_tas_base::dbt_tas_nblkcols_total
pure integer(kind=int_8) function, public dbt_tas_nblkcols_total(matrix)
...
Definition dbt_tas_base.F:864
dbt_tas_base::dbt_tas_finalize
subroutine, public dbt_tas_finalize(matrix)
...
Definition dbt_tas_base.F:327
dbt_tas_base::dbt_tas_distribution_new
subroutine, public dbt_tas_distribution_new(dist, mp_comm, row_dist, col_dist, split_info, nosplit)
create new distribution. Exactly like dbm_distribution_new but with custom types for row_dist and col...
Definition dbt_tas_base.F:346
dbt_tas_base::dbt_tas_info
type(dbt_tas_split_info) function, pointer, public dbt_tas_info(matrix)
get info on mpi grid splitting
Definition dbt_tas_base.F:825
dbt_tas_base::dbt_tas_put_block
subroutine, public dbt_tas_put_block(matrix, row, col, block, summation)
As dbm_put_block.
Definition dbt_tas_base.F:1084
dbt_tas_global
Global data (distribution and block sizes) for tall-and-skinny matrices For very sparse matrices with...
Definition dbt_tas_global.F:17
dbt_tas_global::dbt_tas_default_distvec
subroutine, public dbt_tas_default_distvec(nblk, nproc, blk_size, dist)
get a load-balanced and randomized distribution along one tensor dimension
Definition dbt_tas_global.F:485
dbt_tas_mm
Matrix multiplication for tall-and-skinny matrices. This uses the k-split (non-recursive) CARMA algor...
Definition dbt_tas_mm.F:18
dbt_tas_mm::dbt_tas_multiply
recursive subroutine, public dbt_tas_multiply(transa, transb, transc, alpha, matrix_a, matrix_b, beta, matrix_c, optimize_dist, split_opt, filter_eps, flop, move_data_a, move_data_b, retain_sparsity, simple_split, unit_nr, log_verbose)
tall-and-skinny matrix-matrix multiplication. Undocumented dummy arguments are identical to arguments...
Definition dbt_tas_mm.F:105
dbt_tas_split
methods to split tall-and-skinny matrices along longest dimension. Basically, we are splitting proces...
Definition dbt_tas_split.F:13
dbt_tas_split::dbt_tas_get_split_info
subroutine, public dbt_tas_get_split_info(info, mp_comm, nsplit, igroup, mp_comm_group, split_rowcol, pgrid_offset)
Get info on split.
Definition dbt_tas_split.F:427
dbt_tas_test
testing infrastructure for tall-and-skinny matrices
Definition dbt_tas_test.F:12
dbt_tas_test::dbt_tas_test_mm
subroutine, public dbt_tas_test_mm(transa, transb, transc, matrix_a, matrix_b, matrix_c, filter_eps, unit_nr, log_verbose)
Test tall-and-skinny matrix multiplication for accuracy.
Definition dbt_tas_test.F:320
dbt_tas_test::dbt_tas_reset_randmat_seed
subroutine, public dbt_tas_reset_randmat_seed()
Reset the seed used for generating random matrices to default value.
Definition dbt_tas_test.F:510
dbt_tas_test::dbt_tas_benchmark_mm
subroutine, public dbt_tas_benchmark_mm(transa, transb, transc, matrix_a, matrix_b, matrix_c, compare_dbm, filter_eps, io_unit)
Benchmark routine. Due to random sparsity (as opposed to structured sparsity pattern),...
Definition dbt_tas_test.F:183
dbt_tas_test::dbt_tas_setup_test_matrix
subroutine, public dbt_tas_setup_test_matrix(matrix, mp_comm_out, mp_comm, nrows, ncols, rbsizes, cbsizes, dist_splitsize, name, sparsity, reuse_comm)
Setup tall-and-skinny matrix for testing.
Definition dbt_tas_test.F:70
dbt_tas_test::dbt_tas_checksum
real(kind=dp) function, public dbt_tas_checksum(matrix)
Calculate checksum of tall-and-skinny matrix consistent with dbm_checksum.
Definition dbt_tas_test.F:475
dbt_tas_test::dbt_tas_random_bsizes
subroutine, public dbt_tas_random_bsizes(sizes, repeat, dbt_sizes)
Create random block sizes.
Definition dbt_tas_test.F:493
dbt_tas_types
DBT tall-and-skinny base types. Mostly wrappers around existing DBM routines.
Definition dbt_tas_types.F:13
kinds
Defines the basic variable types.
Definition kinds.F:23
kinds::int_8
integer, parameter, public int_8
Definition kinds.F:54
kinds::dp
integer, parameter, public dp
Definition kinds.F:34
message_passing
Interface to the message passing library MPI.
Definition message_passing.F:23
dbm_api::dbm_distribution_obj
Definition dbm_api.F:122
dbm_api::dbm_type
Definition dbm_api.F:130
dbt_tas_global::dbt_tas_blk_size_arb
type for arbitrary block sizes
Definition dbt_tas_global.F:112
dbt_tas_global::dbt_tas_dist_cyclic
type for cyclic (round robin) distribution:
Definition dbt_tas_global.F:60
dbt_tas_types::dbt_tas_distribution_type
Definition dbt_tas_types.F:66
dbt_tas_types::dbt_tas_type
Definition dbt_tas_types.F:102
message_passing::mp_cart_type
Definition message_passing.F:740
message_passing::mp_comm_type
Definition message_passing.F:189