abstract_kernel Derived Type

type, public, abstract :: abstract_kernel

Abstract kernel type

This kernel type is used in reshape_handle_generic type and is resposible for packing/unpacking/permute operations.


Inherits

type~~abstract_kernel~~InheritsGraph type~abstract_kernel abstract_kernel type~abstract_compressor abstract_compressor type~abstract_kernel->type~abstract_compressor compressor type~kernel_type_t kernel_type_t type~abstract_kernel->type~kernel_type_t kernel_type type~string string type~abstract_kernel->type~string kernel_string

Inherited by

type~~abstract_kernel~~InheritedByGraph type~abstract_kernel abstract_kernel type~abstract_backend abstract_backend type~abstract_backend->type~abstract_kernel pack_kernel, unpack_kernel type~kernel_device kernel_device type~kernel_device->type~abstract_kernel type~kernel_host kernel_host type~kernel_host->type~abstract_kernel type~reshape_handle_generic reshape_handle_generic type~reshape_handle_generic->type~abstract_kernel pack_kernel, unpack_kernel type~reshape_handle_generic->type~abstract_backend comm_handle type~backend_cufftmp backend_cufftmp type~backend_cufftmp->type~abstract_backend type~backend_mpi backend_mpi type~backend_mpi->type~abstract_backend type~backend_nccl backend_nccl type~backend_nccl->type~abstract_backend

Components

Type Visibility Attributes Name Initial
logical, public :: is_created = .false.

Kernel is created flag.
logical, public :: is_dummy = .false.

If kernel should do anything or not.
logical, public :: is_dummy_kernel = .false.

If kernel is of type KERNEL_DUMMY
logical, public :: is_dummy_compressed = .false.
type(kernel_type_t), public :: kernel_type

Type of the kernel
type(string), public :: kernel_string
integer(kind=int32), public, allocatable :: neighbor_data(:,:)

Neighbor data for pipelined unpacking
integer(kind=int32), public, allocatable :: dims(:)

Local dimensions to process
class(abstract_compressor), public, pointer :: compressor

Compressor pointer. Compressor itself is created by generic handle and passed here
logical, public :: is_compress

Enable compression
logical, public :: is_decompress

Enable decompression
integer(kind=int64), public :: base_storage

Type-Bound Procedures

procedure, public, pass(self) :: create

Creates kernel

  • private subroutine create(self, dims, effort, base_storage, kernel_type, neighbor_data, force_effort, with_compression, with_decompression)

    Creates kernel

    Arguments

    Type IntentOptional Attributes Name
    class(abstract_kernel), intent(inout) :: self

    Abstract kernel
    integer(kind=int32), intent(in) :: dims(:)

    Local dimensions to process
    type(dtfft_effort_t), intent(in) :: effort

    Effort level for generating transpose kernels
    integer(kind=int64), intent(in) :: base_storage

    Number of bytes needed to store single element
    type(kernel_type_t), intent(in) :: kernel_type

    Type of kernel to build
    integer(kind=int32), intent(in), optional :: neighbor_data(:,:)

    Optional pointers for unpack kernels
    logical, intent(in), optional :: force_effort

    Should effort be forced or not
    logical, intent(in), optional :: with_compression

    Enable compression after executing kernel
    logical, intent(in), optional :: with_decompression

    Enable decompression before executing kernel

procedure, public, pass(self) :: execute

Executes kernel

  • private subroutine execute(self, in, out, stream, neighbor, aux, csize, csizes, skip_compression, skip_rank, sync)

    Executes kernel

    Arguments

    Type IntentOptional Attributes Name
    class(abstract_kernel), intent(inout) :: self

    Abstract kernel
    type(c_ptr), intent(in) :: in

    Source buffer, can be device or host pointer
    type(c_ptr), intent(in) :: out

    Target buffer, can be device or host pointer
    type(dtfft_stream_t), intent(in) :: stream

    Stream to execute on, used only for device pointers
    integer(kind=int32), intent(in), optional :: neighbor

    Source rank for pipelined unpacking
    type(c_ptr), intent(in), optional :: aux

    Target buffer, can be device or host pointer
    integer(kind=int32), intent(inout), optional :: csize

    Compressed buffer size
    integer(kind=int32), intent(inout), optional :: csizes(:)

    Multiple compression sizes. This should only be used with CUDA backends
    logical, intent(in), optional :: skip_compression

    Skip compression/decompression stage. Should be used when packing/unpacking from itself.
    integer(kind=int32), intent(in), optional :: skip_rank

    Skip compression/decompression for specific rank when neighbor is not specified.
    logical, intent(in), optional :: sync

    Sync stream after packing/compression. Should be used only for fused backends

procedure, public, pass(self) :: destroy

Destroys kernel

  • private subroutine destroy(self)

    Destroys kernel

    Arguments

    Type IntentOptional Attributes Name
    class(abstract_kernel), intent(inout) :: self

    Abstract kernel

procedure, public, pass(self) :: set_compressor

  • private subroutine set_compressor(self, compressor)

    Sets created compressor for the kernel

    Arguments

    Type IntentOptional Attributes Name
    class(abstract_kernel), intent(inout) :: self

    Abstract kernel
    class(abstract_compressor), intent(in), target :: compressor

    Compressor to set

procedure(create_interface), public, deferred :: create_private

Creates underlying kernel

  • subroutine create_interface(self, effort, base_storage, force_effort) Prototype

    Creates underlying kernel

    Arguments

    Type IntentOptional Attributes Name
    class(abstract_kernel), intent(inout) :: self

    Abstract kernel
    type(dtfft_effort_t), intent(in) :: effort

    Effort level for generating transpose kernels
    integer(kind=int64), intent(in) :: base_storage

    Number of bytes needed to store single element
    logical, intent(in), optional :: force_effort

    Should effort be forced or not

procedure(execute_interface), public, deferred :: execute_private

Executes underlying kernel

  • subroutine execute_interface(self, in, out, stream, sync, neighbor) Prototype

    Executes underlying kernel

    Arguments

    Type IntentOptional Attributes Name
    class(abstract_kernel), intent(inout) :: self

    Abstract kernel
    type(c_ptr), intent(in) :: in

    Source buffer, can be device or host pointer
    type(c_ptr), intent(in) :: out

    Target buffer, can be device or host pointer
    type(dtfft_stream_t), intent(in) :: stream

    Stream to execute on, used only for device pointers
    logical, intent(in) :: sync

    Sync stream after kernel execution
    integer(kind=int32), intent(in), optional :: neighbor

    Source rank for pipelined unpacking

procedure(destroy_interface), public, deferred :: destroy_private

Destroys underlying kernel

  • subroutine destroy_interface(self) Prototype

    Destroys underlying kernel

    Arguments

    Type IntentOptional Attributes Name
    class(abstract_kernel), intent(inout) :: self

    Abstract kernel