193 class(batch_t),
intent(inout) :: this
194 integer,
optional,
intent(in) :: np
196 logical,
optional,
intent(in) :: async
198 integer :: ist_linear, ist, ip, np_
206 select case (this%status())
209 assert(np_ <= int(this%pack_size(2), int32))
214 assert(np_ <= int(this%pack_size(2), int32))
219 do ist = 1, int(this%pack_size(1), int32)
220 this%dff_pack(ist, ip) =
m_zero
227 do ist = 1, int(this%pack_size(1), int32)
228 this%sff_pack(ist, ip) = 0.0_real32
235 do ist = 1, int(this%pack_size(1), int32)
236 this%cff_pack(ist, ip) = cmplx(0.0_real32, 0.0_real32, real32)
243 do ist = 1, int(this%pack_size(1), int32)
244 this%zff_pack(ist, ip) =
m_z0
252 assert(np_ <= ubound(this%dff_linear, dim=1))
253 do ist_linear = 1, this%nst_linear
256 this%dff_linear(ip, ist_linear) =
m_zero
261 assert(np_ <= ubound(this%sff_linear, dim=1))
262 do ist_linear = 1, this%nst_linear
265 this%sff_linear(ip, ist_linear) = 0.0_real32
270 assert(np_ <= ubound(this%cff_linear, dim=1))
271 do ist_linear = 1, this%nst_linear
274 this%cff_linear(ip, ist_linear) = cmplx(0.0_real32, 0.0_real32, real32)
279 assert(np_ <= ubound(this%zff_linear, dim=1))
280 do ist_linear = 1, this%nst_linear
283 this%zff_linear(ip, ist_linear) =
m_z0
289 message(1) =
"batch_set_zero: unknown batch status."
303 class(
batch_t),
intent(in) :: this
304 integer,
intent(in) :: sp
305 integer,
intent(in) :: ep
307 integer,
intent(in) :: ldpsi1
308 integer,
intent(in) :: ldpsi2
310 integer :: tsize, ii, it
312 integer,
allocatable :: linear_to_ist(:), linear_to_idim(:)
313 type(
accel_mem_t) :: buff_linear_to_ist, buff_linear_to_idim
318 select case (this%status())
325 safe_allocate(linear_to_ist(1:this%nst_linear*tsize))
326 safe_allocate(linear_to_idim(1:this%nst_linear*tsize))
327 do ii = 1, this%nst_linear
329 linear_to_ist(tsize*(ii-1)+it) = tsize*(this%linear_to_ist(ii) - 1) + it - 1
330 linear_to_idim(tsize*(ii-1)+it) = this%linear_to_idim(ii) - 1
352 call accel_kernel_run(kernel, (/1_int64, int(ep - sp + 1, int64)/), (/this%pack_size_real(1), 1_int64/))
356 safe_deallocate_a(linear_to_ist)
357 safe_deallocate_a(linear_to_idim)
370 class(
batch_t),
intent(inout) :: this
371 integer,
intent(in) :: sp
372 integer,
intent(in) :: ep
374 integer,
intent(in) :: ldpsi1
375 integer,
intent(in) :: ldpsi2
377 integer :: tsize, ii, it
379 integer,
allocatable :: linear_to_ist(:), linear_to_idim(:)
380 type(
accel_mem_t) :: buff_linear_to_ist, buff_linear_to_idim
385 select case (this%status())
392 safe_allocate(linear_to_ist(1:this%nst_linear*tsize))
393 safe_allocate(linear_to_idim(1:this%nst_linear*tsize))
394 do ii = 1, this%nst_linear
396 linear_to_ist(tsize*(ii-1)+it) = tsize*(this%linear_to_ist(ii) - 1) + it - 1
397 linear_to_idim(tsize*(ii-1)+it) = this%linear_to_idim(ii) - 1
419 call accel_kernel_run(kernel, (/1_int64, int(ep - sp + 1, int64)/), (/this%pack_size_real(1), 1_int64/))
423 safe_deallocate_a(linear_to_ist)
424 safe_deallocate_a(linear_to_idim)
438 integer pure function batch_points_block_size() result(block_size)
448 integer,
intent(in) :: np
449 class(batch_t),
intent(in) :: xx
450 class(batch_t),
intent(in) :: yy
451 class(batch_t),
intent(inout) :: zz
452 logical,
optional,
intent(in) :: conjugate_yy
456 integer(int64),
dimension(3) :: gsizes, bsizes
457 type(accel_kernel_t),
save,
target :: kernel_zmul_conj
458 type(accel_kernel_t),
save,
target :: kernel_zmul
459 type(accel_kernel_t),
save,
target :: kernel_dmul
460 type(accel_kernel_t),
pointer :: kernel
463 call xx%check_compatibility_with(yy)
464 call xx%check_compatibility_with(zz)
466 conj_yy = optional_default(conjugate_yy, .
true.)
468 select case (xx%status())
469 case (batch_not_packed)
470 if (xx%type() == type_cmplx)
then
473 do ii = 1, xx%nst_linear
476 zz%zff_linear(ip, ii) = xx%zff_linear(ip, ii)*conjg(yy%zff_linear(ip, ii))
483 do ii = 1, xx%nst_linear
486 zz%zff_linear(ip, ii) = xx%zff_linear(ip, ii)*yy%zff_linear(ip, ii)
494 do ii = 1, xx%nst_linear
497 zz%dff_linear(ip, ii) = xx%dff_linear(ip, ii)*yy%dff_linear(ip, ii)
505 if (xx%type() == type_cmplx)
then
510 do ii = 1, xx%nst_linear
511 zz%zff_pack(ii, ip) = xx%zff_pack(ii, ip)*conjg(yy%zff_pack(ii, ip))
518 do ii = 1, xx%nst_linear
519 zz%zff_pack(ii, ip) = xx%zff_pack(ii, ip)*yy%zff_pack(ii, ip)
527 do ii = 1, xx%nst_linear
528 zz%dff_pack(ii, ip) = xx%dff_pack(ii, ip)*yy%dff_pack(ii, ip)
533 case (batch_device_packed)
534 if (xx%type() == type_cmplx)
then
536 kernel => kernel_zmul_conj
537 call accel_kernel_start_call(kernel,
'batch_mul.cu',
'mul_batch<complex<double>, Conjugation::Yes>')
539 kernel => kernel_zmul
540 call accel_kernel_start_call(kernel,
'batch_mul.cu',
'mul_batch<complex<double>, Conjugation::No>')
543 call accel_set_kernel_arg(kernel, 0, np)
544 call accel_set_kernel_arg(kernel, 1, xx%ff_device)
545 call accel_set_kernel_arg(kernel, 2,
log2(int(xx%pack_size(1), int32)))
546 call accel_set_kernel_arg(kernel, 3, yy%ff_device)
547 call accel_set_kernel_arg(kernel, 4,
log2(int(yy%pack_size(1), int32)))
548 call accel_set_kernel_arg(kernel, 5, zz%ff_device)
549 call accel_set_kernel_arg(kernel, 6,
log2(int(zz%pack_size(1), int32)))
551 call accel_grid_size_extend_dim(int(np, int64), xx%pack_size(1), gsizes, bsizes, kernel)
553 kernel => kernel_dmul
554 call accel_kernel_start_call(kernel,
'batch_mul.cu',
'mul_batch<double>')
556 call accel_set_kernel_arg(kernel, 0, np)
557 call accel_set_kernel_arg(kernel, 1, xx%ff_device)
558 call accel_set_kernel_arg(kernel, 2,
log2(int(xx%pack_size_real(1), int32)))
559 call accel_set_kernel_arg(kernel, 3, yy%ff_device)
560 call accel_set_kernel_arg(kernel, 4,
log2(int(yy%pack_size_real(1), int32)))
561 call accel_set_kernel_arg(kernel, 5, zz%ff_device)
562 call accel_set_kernel_arg(kernel, 6,
log2(int(zz%pack_size_real(1), int32)))
564 call accel_grid_size_extend_dim(int(np, int64), xx%pack_size_real(1), gsizes, bsizes, kernel)
567 call accel_kernel_run(kernel, gsizes, bsizes)
575 integer,
intent(in) :: np
576 integer,
intent(in) :: map(:)
577 class(batch_t),
intent(in) :: xx
578 class(batch_t),
intent(in) :: yy
579 class(batch_t),
intent(inout) :: zz
580 type(accel_mem_t) :: buff_map
584 if (xx%status() /= batch_device_packed)
then
585 if (xx%type() == type_float)
then
592 call accel_create_buffer(buff_map, accel_mem_read_only, type_integer, np)
593 call accel_write_buffer(buff_map, np, map)
595 call accel_free_buffer(buff_map)
603 integer,
intent(in) :: np
604 class(accel_mem_t),
intent(in) :: map
605 class(batch_t),
intent(in) :: xx
606 class(batch_t),
intent(in) :: yy
607 class(batch_t),
intent(inout) :: zz
609 type(accel_kernel_t),
save :: kernel
610 integer(int64),
dimension(3) :: gsizes, bsizes
614 call accel_kernel_start_call(kernel,
'copy.cu',
'add_with_map<double>')
616 call accel_set_kernel_arg(kernel, 0, np)
617 call accel_set_kernel_arg(kernel, 1, map)
618 call accel_set_kernel_arg(kernel, 2, xx%ff_device)
619 call accel_set_kernel_arg(kernel, 3,
log2(int(xx%pack_size_real(1), int32)))
620 call accel_set_kernel_arg(kernel, 4, yy%ff_device)
621 call accel_set_kernel_arg(kernel, 5,
log2(int(yy%pack_size_real(1), int32)))
622 call accel_set_kernel_arg(kernel, 6, zz%ff_device)
623 call accel_set_kernel_arg(kernel, 7,
log2(int(zz%pack_size_real(1), int32)))
626 call accel_grid_size_extend_dim(int(np, int64), xx%pack_size_real(1), gsizes, bsizes, kernel)
628 call accel_kernel_run(kernel, gsizes, bsizes)
635 integer,
intent(in) :: np
636 integer,
intent(in) :: map(:)
637 class(batch_t),
intent(in) :: xx
638 class(batch_t),
intent(inout) :: yy
639 type(accel_mem_t) :: buff_map
643 if (xx%status() /= batch_device_packed)
then
644 if (xx%type() == type_float)
then
651 call accel_create_buffer(buff_map, accel_mem_read_only, type_integer, np)
652 call accel_write_buffer(buff_map, np, map)
654 call accel_free_buffer(buff_map)
662 integer,
intent(in) :: np
663 class(accel_mem_t),
intent(in) :: map
664 class(batch_t),
intent(in) :: xx
665 class(batch_t),
intent(inout) :: yy
667 type(accel_kernel_t),
save :: kernel
668 integer(int64),
dimension(3) :: gsizes, bsizes
672 call accel_kernel_start_call(kernel,
'copy.cu',
'copy_with_map<double>')
676 call accel_set_kernel_arg(kernel, 0, np)
677 call accel_set_kernel_arg(kernel, 1, map)
678 call accel_set_kernel_arg(kernel, 2, xx%ff_device)
679 call accel_set_kernel_arg(kernel, 3,
log2(int(xx%pack_size_real(1), int32)))
680 call accel_set_kernel_arg(kernel, 4, yy%ff_device)
681 call accel_set_kernel_arg(kernel, 5,
log2(int(yy%pack_size_real(1), int32)))
684 call accel_grid_size_extend_dim(int(np, int64), xx%pack_size_real(1), gsizes, bsizes, kernel)
686 call accel_kernel_run(kernel, gsizes, bsizes)
698 integer,
intent(in) :: np
699 class(batch_t),
intent(in) :: xx
700 class(batch_t),
intent(inout) :: yy
701 class(batch_t),
intent(inout) :: zz
703 integer :: ist_linear, ip
704 type(accel_kernel_t),
save :: kernel
705 integer(int64),
dimension(3) :: gsizes, bsizes
709 assert(xx%type() == type_cmplx)
710 assert(yy%type() == type_float)
711 assert(zz%type() == type_float)
712 assert(xx%status() == yy%status())
713 assert(xx%status() == zz%status())
714 assert(np <= xx%pack_size(2))
715 assert(np <= yy%pack_size(2))
716 assert(np <= zz%pack_size(2))
718 select case (xx%status())
719 case (batch_not_packed)
720 do ist_linear = 1, xx%nst_linear
723 yy%dff_linear(ip, ist_linear) = real(xx%zff_linear(ip, ist_linear), real64)
724 zz%dff_linear(ip, ist_linear) = aimag(xx%zff_linear(ip, ist_linear))
730 do ist_linear = 1, xx%nst_linear
731 yy%dff_pack(ist_linear, ip) = real(xx%zff_pack(ist_linear, ip), real64)
732 zz%dff_pack(ist_linear, ip) = aimag(xx%zff_pack(ist_linear, ip))
735 case (batch_device_packed)
736 call accel_kernel_start_call(kernel,
'split.cu',
'split_complex<double>')
738 call accel_set_kernel_arg(kernel, 0, np)
739 call accel_set_kernel_arg(kernel, 1, xx%ff_device)
740 call accel_set_kernel_arg(kernel, 2,
log2(int(xx%pack_size(1), int32)))
741 call accel_set_kernel_arg(kernel, 3, yy%ff_device)
742 call accel_set_kernel_arg(kernel, 4,
log2(int(yy%pack_size(1), int32)))
743 call accel_set_kernel_arg(kernel, 5, zz%ff_device)
744 call accel_set_kernel_arg(kernel, 6,
log2(int(zz%pack_size(1), int32)))
747 call accel_grid_size_extend_dim(int(np, int64), xx%pack_size(1), gsizes, bsizes, kernel)
749 call accel_kernel_run(kernel, gsizes, bsizes)
764 class(batch_t),
intent(in) :: src
765 class(batch_t),
intent(inout) :: dst
766 integer,
intent(in) :: np
769 integer(int64) :: gsizes(3), bsizes(3)
770 logical :: is_cplx, to_single
771 character(len=47) :: kernel_name
775 type(accel_kernel_t),
save,
target :: kernels(1:2, 1:2)
776 type(accel_kernel_t),
pointer :: kernel
780 assert(src%nst_linear == dst%nst_linear)
781 assert(src%status() == dst%status())
782 assert(type_is_complex(src%type()) .eqv. type_is_complex(dst%type()))
783 assert(type_is_single(src%type()) .neqv. type_is_single(dst%type()))
785 is_cplx = type_is_complex(src%type())
786 to_single = type_is_single(dst%type())
788 select case (src%status())
789 case (batch_device_packed)
791 kernel_name = merge(
'precision_copy<complex<double>, complex<float>>', &
792 'precision_copy<complex<float>, complex<double>>', to_single)
794 kernel_name = merge(
'precision_copy<double, float>',
'precision_copy<float, double>', to_single)
796 kernel => kernels(merge(2, 1, is_cplx), merge(2, 1, to_single))
797 call accel_kernel_start_call(kernel,
'precision_copy.cu', trim(kernel_name))
798 call accel_set_kernel_arg(kernel, 0, np)
799 call accel_set_kernel_arg(kernel, 1, src%nst_linear)
800 call accel_set_kernel_arg(kernel, 2, src%ff_device)
801 call accel_set_kernel_arg(kernel, 3,
log2(int(src%pack_size(1), int32)))
802 call accel_set_kernel_arg(kernel, 4, dst%ff_device)
803 call accel_set_kernel_arg(kernel, 5,
log2(int(dst%pack_size(1), int32)))
804 call accel_grid_size_extend_dim(int(np, int64), dst%pack_size(1), gsizes, bsizes, kernel)
805 call accel_kernel_run(kernel, gsizes, bsizes)
813 do ist = 1, dst%nst_linear
814 dst%cff_pack(ist, ip) = cmplx(src%zff_pack(ist, ip), kind=real32)
820 do ist = 1, dst%nst_linear
821 dst%sff_pack(ist, ip) = real(src%dff_pack(ist, ip), kind=real32)
829 do ist = 1, dst%nst_linear
830 dst%zff_pack(ist, ip) = src%cff_pack(ist, ip)
836 do ist = 1, dst%nst_linear
837 dst%dff_pack(ist, ip) = src%sff_pack(ist, ip)
843 case (batch_not_packed)
847 do ist = 1, dst%nst_linear
849 dst%cff_linear(ip, ist) = cmplx(src%zff_linear(ip, ist), kind=real32)
854 do ist = 1, dst%nst_linear
856 dst%sff_linear(ip, ist) = real(src%dff_linear(ip, ist), kind=real32)
863 do ist = 1, dst%nst_linear
865 dst%zff_linear(ip, ist) = src%cff_linear(ip, ist)
870 do ist = 1, dst%nst_linear
872 dst%dff_linear(ip, ist) = src%sff_linear(ip, ist)
887#include "batch_ops_inc.F90"
890#include "complex.F90"
891#include "batch_ops_inc.F90"
897#include "batch_ops_inc.F90"
900#include "complex.F90"
901#include "batch_ops_inc.F90"
908#include "batch_ops_inc.F90"
911#include "complex.F90"
912#include "batch_ops_inc.F90"
919#include "batch_ops_inc.F90"
922#include "complex.F90"
923#include "batch_ops_inc.F90"
930#include "batch_ops_inc.F90"
933#include "complex.F90"
934#include "batch_ops_inc.F90"
941#include "batch_ops_inc.F90"
944#include "complex.F90"
945#include "batch_ops_inc.F90"
952#include "batch_ops_inc.F90"
955#include "complex32.F90"
956#include "batch_ops_inc.F90"
batchified version of the BLAS axpy routine:
batchified linear combination:
batchified multiplication by mesh function with optional conjugation:
batchified scale with optional conjugation:
scale a batch by a constant or vector
There are several ways how to call batch_set_state and batch_get_state:
double log2(double __x) __attribute__((__nothrow__
subroutine, public accel_free_buffer(this, async)
subroutine, public accel_kernel_start_call(this, file_name, kernel_name, flags)
integer, parameter, public accel_mem_read_only
This module implements batches of mesh functions.
integer, parameter, public batch_not_packed
functions are stored in CPU memory, unpacked order
integer, parameter, public batch_device_packed
functions are stored in device memory in packed order
integer, parameter, public batch_packed
functions are stored in CPU memory, in transposed (packed) order
This module implements common operations on batches of mesh functions.
subroutine zbatch_get_state3(this, ii, np, psi, async)
subroutine dbatch_get_state3(this, ii, np, psi, async)
subroutine batch_copy_with_map_accel(np, map, xx, yy)
subroutine zbatch_get_state1(this, ist, np, psi, async)
Write a get of state with np points from a batch.
subroutine, public zbatch_copy_with_map_to_array(np, map, xx, array)
Transfer a batch from the mesh to an array on the submesh (defined by a map)
subroutine, public dbatch_ax_function_py(np, aa, psi, yy)
This routine performs a set of axpy operations adding the same function psi to all functions of a bat...
subroutine dbatch_set_state1(this, ist, np, psi)
Write a single state with np points into a batch at position ist.
subroutine dbatch_axpy_const(np, aa, xx, yy)
This routine applies a 'pair-wise' axpy operation to all functions of the batches xx and yy,...
subroutine zbatch_axpby(np, aa, xx, bb, yy)
calculate yy(ist,:) = aa*xx(ist,:) + bb*yy(ist,:) for a batch
subroutine cbatch_axpy_const(np, aa, xx, yy)
This routine applies a 'pair-wise' axpy operation to all functions of the batches xx and yy,...
subroutine zbatch_get_points(this, sp, ep, psi)
copy a set of points into a mesh function
subroutine dbatch_xpay_vec(np, xx, aa, yy, a_start, a_full)
calculate yy(ist,:) = xx(ist,:) + aa(ist)*yy(ist,:) for a batch
subroutine dbatch_scal_vec(np, aa, xx, a_start, a_full)
subroutine dbatch_set_state2(this, index, np, psi)
Write a single state with np points into a batch at position defined by index.
subroutine dbatch_copy_with_map(np, map, xx, yy)
subroutine cbatch_get_state2(this, index, np, psi, async)
subroutine, public dbatch_copy_with_map_to_array(np, map, xx, array)
Transfer a batch from the mesh to an array on the submesh (defined by a map)
subroutine dbatch_scal2v(np, aa, xx, yy, conjugate_xx)
calculate yy(ist,:) = aa*CJ(xx(ist,:)) for a batch
subroutine dbatch_get_state2(this, index, np, psi, async)
subroutine dbatch_axpy_vec(np, aa, xx, yy, a_start, a_full)
A simple switch between specialized kernels and generic kernels.
subroutine dbatch_set_state3(this, ii, np, psi)
Write a set of state with np points into a batch.
subroutine zbatch_axpy_const(np, aa, xx, yy)
This routine applies a 'pair-wise' axpy operation to all functions of the batches xx and yy,...
subroutine sbatch_set_state3(this, ii, np, psi)
Write a set of state with np points into a batch.
subroutine zbatch_scal_const(np, aa, xx)
scale all functions in a batch by constant aa
subroutine zbatch_get_state2(this, index, np, psi, async)
subroutine zbatch_xpay_const(np, xx, aa, yy)
calculate yy(ist) = xx(ist) + aa*yy(ist) for a batch
subroutine, public batch_split_complex(np, xx, yy, zz)
extract the real and imaginary parts of a complex batch
subroutine batch_add_with_map_accel(np, map, xx, yy, zz)
subroutine dbatch_set_points(this, sp, ep, psi)
copy a set of points into a mesh function
subroutine dbatch_get_state1(this, ist, np, psi, async)
Write a get of state with np points from a batch.
subroutine zbatch_copy_with_map(np, map, xx, yy)
subroutine dbatch_mul_mf(np, ff, xx, yy, conjugate_xx)
calculate yy(ist,:) = ff(:) * CJ(xx(ist,:)) for a batch
subroutine, public batch_set_zero(this, np, async)
fill all mesh functions of the batch with zero
subroutine, public zbatch_ax_function_py(np, aa, psi, yy)
This routine performs a set of axpy operations adding the same function psi to all functions of a bat...
subroutine zbatch_axpy_vec(np, aa, xx, yy, a_start, a_full)
A simple switch between specialized kernels and generic kernels.
subroutine cbatch_set_state1(this, ist, np, psi)
Write a single state with np points into a batch at position ist.
subroutine batch_set_points_accel(this, sp, ep, psi, ldpsi1, ldpsi2)
GPU version of batch_set_points.
subroutine dbatch_xpay_const(np, xx, aa, yy)
calculate yy(ist) = xx(ist) + aa*yy(ist) for a batch
subroutine dbatch_axpby(np, aa, xx, bb, yy)
calculate yy(ist,:) = aa*xx(ist,:) + bb*yy(ist,:) for a batch
subroutine dbatch_get_points(this, sp, ep, psi)
copy a set of points into a mesh function
subroutine zbatch_scal2v(np, aa, xx, yy, conjugate_xx)
calculate yy(ist,:) = aa*CJ(xx(ist,:)) for a batch
integer pure function, public batch_points_block_size()
determine the device block size
subroutine dbatch_add_with_map(np, map, xx, yy, zz)
subroutine zbatch_gemv(np, xx, aa, bb, yy, aa2, bb2, yy2)
Linear combination of batches: yy(ist) = bb(ist) yy(ist) + sum_k aa(k, ist) xx(k)(ist)
subroutine zbatch_mul_mf(np, ff, xx, yy, conjugate_xx)
calculate yy(ist,:) = ff(:) * CJ(xx(ist,:)) for a batch
subroutine sbatch_get_state1(this, ist, np, psi, async)
Write a get of state with np points from a batch.
subroutine sbatch_get_state2(this, index, np, psi, async)
subroutine zbatch_xpay_vec(np, xx, aa, yy, a_start, a_full)
calculate yy(ist,:) = xx(ist,:) + aa(ist)*yy(ist,:) for a batch
subroutine sbatch_set_state1(this, ist, np, psi)
Write a single state with np points into a batch at position ist.
subroutine, public batch_copy_precision(src, dst, np)
Copy the data of a batch to another batch of the same logical shape but the opposite precision (doubl...
subroutine cbatch_get_state3(this, ii, np, psi, async)
subroutine batch_mul_cj(np, xx, yy, zz, conjugate_yy)
Point-wise multiply two batches with optional conjugation on yy: zz_i = xx_i * CJ(yy_i)
subroutine sbatch_get_state3(this, ii, np, psi, async)
subroutine dbatch_gemv(np, xx, aa, bb, yy, aa2, bb2, yy2)
Linear combination of batches: yy(ist) = bb(ist) yy(ist) + sum_k aa(k, ist) xx(k)(ist)
subroutine sbatch_set_state2(this, index, np, psi)
Write a single state with np points into a batch at position defined by index.
subroutine zbatch_set_state1(this, ist, np, psi)
Write a single state with np points into a batch at position ist.
subroutine batch_add_with_map_cpu(np, map, xx, yy, zz)
subroutine zbatch_scal_vec(np, aa, xx, a_start, a_full)
subroutine cbatch_set_state3(this, ii, np, psi)
Write a set of state with np points into a batch.
subroutine zbatch_set_state2(this, index, np, psi)
Write a single state with np points into a batch at position defined by index.
subroutine sbatch_axpy_const(np, aa, xx, yy)
This routine applies a 'pair-wise' axpy operation to all functions of the batches xx and yy,...
subroutine, public zbatch_axpy_function(np, aa, xx, psi, nst)
This routine performs a set of axpy operations for each function x of a batch (xx),...
subroutine zbatch_set_points(this, sp, ep, psi)
copy a set of points into a mesh function
subroutine zbatch_add_with_map(np, map, xx, yy, zz)
subroutine, public dbatch_axpy_function(np, aa, xx, psi, nst)
This routine performs a set of axpy operations for each function x of a batch (xx),...
subroutine batch_get_points_accel(this, sp, ep, psi, ldpsi1, ldpsi2)
GPU version of batch_get_points.
subroutine cbatch_set_state2(this, index, np, psi)
Write a single state with np points into a batch at position defined by index.
subroutine zbatch_set_state3(this, ii, np, psi)
Write a set of state with np points into a batch.
subroutine cbatch_get_state1(this, ist, np, psi, async)
Write a get of state with np points from a batch.
subroutine batch_copy_with_map_cpu(np, map, xx, yy)
subroutine dbatch_scal_const(np, aa, xx)
scale all functions in a batch by constant aa
This module contains interfaces for BLAS routines You should not use these routines directly....
real(real64), parameter, public m_zero
logical pure function, public not_in_openmp()
complex(real64), parameter, public m_z0
This module is intended to contain "only mathematical" functions and procedures.
subroutine, public messages_not_implemented(feature, namespace)
character(len=256), dimension(max_lines), public message
to be output by fatal, warning
subroutine, public messages_fatal(no_lines, only_root_writes, namespace)
/* To use the profiling module, call profiling_in and profiling_out with the label of the region as a...
subroutine, public profiling_out(label)
Increment out counter and sum up difference between entry and exit time.
subroutine, public profiling_in(label, exclude)
Increment in counter and save entry time.
type(type_t), parameter, public type_cmplx_single
type(type_t), parameter, public type_float_single
integer pure function, public types_get_size(this)
type(type_t), parameter, public type_integer
type(type_t), parameter, public type_float
Class defining batches of mesh functions.