159 homo, virt, alpha, w_fac, do_abba, unit_nr, block_cols, memory_per_proc_gb)
162 TYPE(
cp_fm_type),
INTENT(IN) :: fm_s_ia, fm_s_bar_ij, fm_s_ab, &
164 REAL(kind=
dp),
DIMENSION(:),
INTENT(IN) :: eps_reduced
165 INTEGER,
INTENT(IN) :: homo, virt
166 REAL(kind=
dp),
INTENT(IN) :: alpha, w_fac
167 LOGICAL,
INTENT(IN) :: do_abba
168 INTEGER,
INTENT(IN) :: unit_nr
169 INTEGER,
INTENT(IN),
OPTIONAL :: block_cols
170 REAL(kind=
dp),
INTENT(IN),
OPTIONAL :: memory_per_proc_gb
172 CHARACTER(LEN=*),
PARAMETER :: routinen =
'bse_matvec_create'
174 CHARACTER(LEN=12) :: n_idle_str, n_ri_str, npe_str
175 INTEGER :: a, handle, i, n_ri, n_ri_slab, &
177 REAL(kind=
dp) :: mem_slabs_gb, n_slab_entries
179 CALL timeset(routinen, handle)
183 IF (
PRESENT(block_cols)) mv_env%block_cols = block_cols
184 IF (
PRESENT(memory_per_proc_gb)) mv_env%memory_per_proc_gb = memory_per_proc_gb
185 mv_env%n_ov = homo*virt
188 mv_env%do_abba = do_abba
189 mv_env%para_env => fm_s_ia%matrix_struct%para_env
192 grid_2d=[mv_env%para_env%num_pe, 1])
196 n_row_block = contiguous_row_block(mv_env%n_ov, mv_env%para_env%num_pe)
197 ALLOCATE (mv_env%row_count(mv_env%para_env%num_pe), mv_env%row_displ(mv_env%para_env%num_pe))
198 DO i = 1, mv_env%para_env%num_pe
199 mv_env%row_displ(i) = min(mv_env%n_ov, (i - 1)*n_row_block)
200 mv_env%row_count(i) = min(mv_env%n_ov, i*n_row_block) - mv_env%row_displ(i)
204 ALLOCATE (mv_env%eps_diff(mv_env%n_ov))
207 mv_env%eps_diff(
ia_of_occ_virt(i, a, virt)) = eps_reduced(homo + a) - eps_reduced(i)
212 CALL slice_slab(mv_env, fm_s_ia, virt, homo, mv_env%B_ia, mv_env%n_ri_loc)
213 IF (w_fac /= 0.0_dp)
THEN
214 CALL slice_slab(mv_env, fm_s_bar_ij, homo, homo, mv_env%B_bar_ij, n_ri_slab)
215 cpassert(n_ri_slab == mv_env%n_ri_loc)
216 CALL slice_slab(mv_env, fm_s_ab, virt, virt, mv_env%B_ab, n_ri_slab)
217 cpassert(n_ri_slab == mv_env%n_ri_loc)
219 CALL slice_slab(mv_env, fm_s_bar_ia, virt, homo, mv_env%B_bar_ia, n_ri_slab)
220 cpassert(n_ri_slab == mv_env%n_ri_loc)
225 IF (mv_env%para_env%num_pe > n_ri .AND. unit_nr > 0)
THEN
226 WRITE (npe_str,
'(I0)') mv_env%para_env%num_pe
227 WRITE (n_ri_str,
'(I0)') n_ri
228 WRITE (n_idle_str,
'(I0)') mv_env%para_env%num_pe - n_ri
229 CALL cp_warn(__location__, &
230 "BSE iterative solver: more MPI ranks ("//trim(npe_str)// &
231 ") than RI basis functions ("//trim(n_ri_str)//
"); "// &
232 trim(n_idle_str)//
" ranks hold no RI slice and idle in the kernel application.")
235 IF (unit_nr > 0)
THEN
237 n_slab_entries = real(homo*virt,
dp)
238 IF (w_fac /= 0.0_dp)
THEN
239 n_slab_entries = n_slab_entries + real(homo,
dp)**2 + real(virt,
dp)**2
240 IF (do_abba) n_slab_entries = n_slab_entries + real(homo*virt,
dp)
242 mem_slabs_gb = n_slab_entries*real(mv_env%n_ri_loc,
dp)*8.0e-9_dp
243 WRITE (unit_nr,
'(T2,A4,T7,A,T71,I10)')
'BSE|', &
244 'Max. number of RI functions per MPI rank', mv_env%n_ri_loc
245 WRITE (unit_nr,
'(T2,A4,T7,A,T67,F14.3)')
'BSE|', &
246 'Memory of the RI slabs per MPI rank (GB)', mem_slabs_gb
249 CALL timestop(handle)
383 INTEGER,
INTENT(IN) :: first_col, ncol
385 TYPE(
cp_fm_type),
INTENT(IN),
OPTIONAL :: fm_bz
386 INTEGER,
INTENT(IN),
OPTIONAL :: first_col_bz
388 CHARACTER(LEN=*),
PARAMETER :: routinen =
'bse_matvec_apply'
390 INTEGER :: a, col, col_shift_b, first_row, handle, handle2, homo, i, ia, iloc, k, last_row, &
391 me, n_outputs, n_small, n_work_bufs, nb, nb_max, nrow_local, nvec, offset, p, peer, rows, &
393 INTEGER,
DIMENSION(:),
POINTER :: row_indices
394 LOGICAL :: do_b, do_screened, has_exchange
395 REAL(kind=
dp) :: mem_avail_gb
396 REAL(kind=
dp),
ALLOCATABLE,
DIMENSION(:),
TARGET :: result_buf, work_buf
397 REAL(kind=
dp),
ALLOCATABLE,
DIMENSION(:, :) :: t_pk
398 REAL(kind=
dp),
CONTIGUOUS,
DIMENSION(:, :), &
399 POINTER :: b_ia_2d, local_result, packed, ra, &
400 ra_virt, rb_occ, rb_virt, t_occ, &
401 t_small_cols, t_small_rows, t_virt, z, &
403 REAL(kind=
dp),
CONTIGUOUS,
DIMENSION(:, :, :), &
404 POINTER :: ra_screen, rb_screen, z_screen
405 INTEGER :: displs(size(mv_env%row_displ)), &
406 counts(size(mv_env%row_count))
408 CALL timeset(routinen, handle)
412 n_small = min(homo, virt)
413 do_b =
PRESENT(fm_bz)
414 do_screened = mv_env%w_fac /= 0.0_dp .AND. mv_env%n_ri_loc > 0
415 has_exchange = mv_env%alpha /= 0.0_dp .AND. mv_env%n_ri_loc > 0
418 cpassert(mv_env%do_abba)
421 IF (
PRESENT(first_col_bz)) col_shift_b = first_col_bz - first_col
423 CALL cp_fm_get_info(fm_z, nrow_local=nrow_local, row_indices=row_indices)
426 me = mv_env%para_env%mepos + 1
427 cpassert(nrow_local == mv_env%row_count(me))
428 cpassert(nrow_local == 0 .OR. row_indices(1) == mv_env%row_displ(me) + 1)
432 IF (do_b) n_outputs = 2
433 n_work_bufs = 2 + n_outputs
434 IF (mv_env%block_cols > 0)
THEN
436 nb_max = min(ncol, mv_env%block_cols)
440 nb_max = int(min(real(ncol,
dp), &
441 mem_avail_gb*1.0e9_dp/(8.0_dp*real(n_work_bufs,
dp)*real(mv_env%n_ov,
dp))))
443 nb_max = max(nb_max, 1)
445 nb_max = min(nb_max, (huge(0)/2)/mv_env%n_ov)
446 cpassert(nb_max >= 1)
450 ALLOCATE (work_buf(2*mv_env%n_ov*nb_max), result_buf(n_outputs*mv_env%n_ov*nb_max))
451 ALLOCATE (t_pk(mv_env%n_ri_loc, nb_max))
452 b_ia_2d(1:mv_env%n_ov, 1:mv_env%n_ri_loc) => mv_env%B_ia
454 DO col = first_col, first_col + ncol - 1, nb_max
455 nb = min(nb_max, first_col + ncol - col)
456 nvec = mv_env%n_ov*nb
458 z(1:mv_env%n_ov, 1:nb) => work_buf(1:nvec)
459 ra(1:mv_env%n_ov, 1:nb) => result_buf(1:nvec)
465 CALL timeset(routinen//
"_gather", handle2)
467 offset = (k - 1)*nrow_local
468 result_buf(offset + 1:offset + nrow_local) = fm_z%local_data(1:nrow_local, col + k - 1)
470 counts = mv_env%row_count*nb
471 displs = mv_env%row_displ*nb
472 CALL mv_env%para_env%allgatherv(result_buf(1:nrow_local*nb), work_buf(nvec + 1:2*nvec), counts, displs)
473 DO peer = 1, mv_env%para_env%num_pe
474 rows = mv_env%row_count(peer)
475 first_row = mv_env%row_displ(peer) + 1
476 last_row = mv_env%row_displ(peer) + rows
478 offset = nvec + displs(peer) + (k - 1)*rows
479 z(first_row:last_row, k) = work_buf(offset + 1:offset + rows)
482 CALL timestop(handle2)
485 CALL timeset(routinen//
"_exchange", handle2)
486 IF (has_exchange)
THEN
487 CALL dgemm(
'T',
'N', mv_env%n_ri_loc, nb, mv_env%n_ov, 1.0_dp, b_ia_2d, mv_env%n_ov, z, mv_env%n_ov, &
488 0.0_dp, t_pk, mv_env%n_ri_loc)
492 IF (.NOT. do_screened) ra(1:mv_env%n_ov, 1:nb) => work_buf(1:nvec)
493 IF (has_exchange)
THEN
494 CALL dgemm(
'N',
'N', mv_env%n_ov, nb, mv_env%n_ri_loc, mv_env%alpha, b_ia_2d, mv_env%n_ov, t_pk, mv_env%n_ri_loc, &
495 0.0_dp, ra, mv_env%n_ov)
496 ELSE IF (.NOT. do_screened)
THEN
499 CALL timestop(handle2)
501 CALL timeset(routinen//
"_pack", handle2)
502 IF (do_screened)
THEN
507 z_screen(1:homo, 1:nb, 1:virt) => result_buf(nvec + 1:2*nvec)
509 z_screen(1:homo, 1:nb, 1:virt) => work_buf(nvec + 1:2*nvec)
511 z_occ(1:homo, 1:nb*virt) => z_screen
512 z_virt(1:homo*nb, 1:virt) => z_screen
523 ra_screen(1:homo, 1:nb, 1:virt) => work_buf(1:nvec)
524 ra_virt(1:homo*nb, 1:virt) => work_buf(1:nvec)
526 rb_screen(1:virt, 1:nb, 1:homo) => work_buf(nvec + 1:2*nvec)
527 rb_occ(1:virt, 1:nb*homo) => work_buf(nvec + 1:2*nvec)
528 rb_virt(1:virt*nb, 1:homo) => work_buf(nvec + 1:2*nvec)
530 IF (has_exchange)
THEN
535 ra_screen(i, k, a) = ra(ia, k)
536 IF (do_b) rb_screen(a, k, i) = ra(ia, k)
541 ra_virt(:, :) = 0.0_dp
542 IF (do_b) rb_occ(:, :) = 0.0_dp
544 t_occ(1:homo, 1:nb*virt) => result_buf(1:nvec)
545 t_virt(1:homo*nb, 1:virt) => result_buf(1:nvec)
547 t_small_cols(1:n_small, 1:nb*n_small) => result_buf(1:n_small*n_small*nb)
548 t_small_rows(1:n_small*nb, 1:n_small) => result_buf(1:n_small*n_small*nb)
550 CALL timestop(handle2)
552 CALL timeset(routinen//
"_W", handle2)
553 IF (do_screened)
THEN
554 DO p = 1, mv_env%n_ri_loc
557 CALL dgemm(
'T',
'N', homo, nb*virt, homo, 1.0_dp, mv_env%B_bar_ij(:, :, p), homo, &
558 z_occ, homo, 0.0_dp, t_occ, homo)
559 CALL dgemm(
'N',
'N', homo*nb, virt, virt, -mv_env%w_fac, t_virt, homo*nb, &
560 mv_env%B_ab(:, :, p), virt, 1.0_dp, ra_virt, homo*nb)
564 IF (homo <= virt)
THEN
565 CALL dgemm(
'N',
'N', homo*nb, homo, virt, 1.0_dp, z_virt, homo*nb, &
566 mv_env%B_bar_ia(:, :, p), virt, 0.0_dp, t_small_rows, homo*nb)
567 CALL dgemm(
'N',
'N', virt, nb*homo, homo, -mv_env%w_fac, mv_env%B_ia(:, :, p), virt, &
568 t_small_cols, homo, 1.0_dp, rb_occ, virt)
570 CALL dgemm(
'N',
'N', virt, nb*virt, homo, 1.0_dp, mv_env%B_ia(:, :, p), virt, &
571 z_occ, homo, 0.0_dp, t_small_cols, virt)
572 CALL dgemm(
'N',
'N', virt*nb, homo, virt, -mv_env%w_fac, t_small_rows, virt*nb, &
573 mv_env%B_bar_ia(:, :, p), virt, 1.0_dp, rb_virt, virt*nb)
578 CALL timestop(handle2)
582 CALL timeset(routinen//
"_reduce", handle2)
583 DO peer = 1, mv_env%para_env%num_pe
584 rows = mv_env%row_count(peer)
585 first_row = mv_env%row_displ(peer) + 1
587 offset = n_outputs*displs(peer) + (k - 1)*rows
588 IF (do_screened)
THEN
590 ia = first_row + iloc - 1
593 result_buf(offset + iloc) = ra_screen(i, k, a)
594 IF (do_b) result_buf(offset + rows*nb + iloc) = rb_screen(a, k, i)
597 last_row = first_row + rows - 1
598 result_buf(offset + 1:offset + rows) = ra(first_row:last_row, k)
599 IF (do_b) result_buf(offset + rows*nb + 1:offset + rows*nb + rows) = ra(first_row:last_row, k)
603 counts = counts*n_outputs
605 packed(1:n_outputs*nvec, 1:1) => result_buf(1:n_outputs*nvec)
606 CALL mv_env%para_env%sum_scatter(packed, work_buf(1:n_outputs*nrow_local*nb), counts)
607 local_result(1:nrow_local, 1:n_outputs*nb) => work_buf(1:n_outputs*nrow_local*nb)
609 DO iloc = 1, nrow_local
610 ia = row_indices(iloc)
611 fm_az%local_data(iloc, col + k - 1) = local_result(iloc, k) + &
612 mv_env%eps_diff(ia)*fm_z%local_data(iloc, col + k - 1)
614 IF (do_b) fm_bz%local_data(1:nrow_local, col + col_shift_b + k - 1) = local_result(:, nb + k)
616 CALL timestop(handle2)
619 DEALLOCATE (work_buf, result_buf, t_pk)
621 CALL timestop(handle)
756 INTEGER,
INTENT(IN) :: unit_nr
757 TYPE(
cp_fm_type),
INTENT(IN),
OPTIONAL :: fm_b_explicit
759 CHARACTER(LEN=*),
PARAMETER :: routinen =
'bse_matvec_selfcheck'
761 INTEGER :: handle, ia, iloc, k, n_ov, n_unit, ncol, &
763 INTEGER,
DIMENSION(:),
POINTER :: row_indices
764 REAL(kind=
dp) :: dev_a, dev_b, dev_diag
765 REAL(kind=
dp),
ALLOCATABLE,
DIMENSION(:) :: diag
766 REAL(kind=
dp),
ALLOCATABLE,
DIMENSION(:, :) :: mv_result, ref_matrix, ref_result, z
770 CALL timeset(routinen, handle)
774 n_unit = min(n_ov, 8)
779 ALLOCATE (z(n_ov, ncol))
785 z(ia, ncol) = sin(real(ia,
dp))
789 CALL cp_fm_create(fm_z, fm_struct, name=
"fm_Z_selfcheck")
790 CALL cp_fm_create(fm_az, fm_struct, name=
"fm_AZ_selfcheck")
792 IF (
PRESENT(fm_b_explicit))
THEN
793 CALL cp_fm_create(fm_bz, fm_struct, name=
"fm_BZ_selfcheck")
798 CALL cp_fm_get_info(fm_z, nrow_local=nrow_local, row_indices=row_indices)
800 DO iloc = 1, nrow_local
801 fm_z%local_data(iloc, k) = z(row_indices(iloc), k)
805 IF (
PRESENT(fm_b_explicit))
THEN
811 ALLOCATE (ref_matrix(n_ov, n_ov), mv_result(n_ov, ncol), ref_result(n_ov, ncol), diag(n_ov))
815 ref_result(:, :) = matmul(ref_matrix, z)
816 dev_a = maxval(abs(mv_result - ref_result))
820 dev_diag = max(dev_diag, abs(diag(ia) - ref_matrix(ia, ia)))
823 IF (
PRESENT(fm_b_explicit))
THEN
826 ref_result(:, :) = matmul(ref_matrix, z)
827 dev_b = maxval(abs(mv_result - ref_result))
830 IF (unit_nr > 0)
THEN
831 WRITE (unit_nr,
'(T2,A10,T13,A,T59,ES22.6)')
'BSE|DEBUG|', &
832 'Max deviation matvec vs explicit A', dev_a
833 IF (
PRESENT(fm_b_explicit))
THEN
834 WRITE (unit_nr,
'(T2,A10,T13,A,T59,ES22.6)')
'BSE|DEBUG|', &
835 'Max deviation matvec vs explicit B', dev_b
837 WRITE (unit_nr,
'(T2,A10,T13,A,T59,ES22.6)')
'BSE|DEBUG|', &
838 'Max deviation diagonal vs explicit A', dev_diag
841 DEALLOCATE (z, ref_matrix, mv_result, ref_result, diag)
846 CALL timestop(handle)