dtfft_plan_t Derived Type

type, public, abstract :: dtfft_plan_t

Abstract class for all dtFFT plans


Inherits

type~~dtfft_plan_t~~InheritsGraph type~dtfft_plan_t dtfft_plan_t MPI_Comm MPI_Comm type~dtfft_plan_t->MPI_Comm comm, comms c_ptr c_ptr type~dtfft_plan_t->c_ptr aux_ptr type~abstract_transpose_plan abstract_transpose_plan type~dtfft_plan_t->type~abstract_transpose_plan plan type~dtfft_effort_t dtfft_effort_t type~dtfft_plan_t->type~dtfft_effort_t effort type~dtfft_executor_t dtfft_executor_t type~dtfft_plan_t->type~dtfft_executor_t executor type~dtfft_platform_t dtfft_platform_t type~dtfft_plan_t->type~dtfft_platform_t platform type~dtfft_precision_t dtfft_precision_t type~dtfft_plan_t->type~dtfft_precision_t precision type~dtfft_stream_t dtfft_stream_t type~dtfft_plan_t->type~dtfft_stream_t stream type~fft_executor fft_executor type~dtfft_plan_t->type~fft_executor fft type~pencil pencil type~dtfft_plan_t->type~pencil pencils type~backend_helper backend_helper type~abstract_transpose_plan->type~backend_helper helper type~dtfft_backend_t dtfft_backend_t type~abstract_transpose_plan->type~dtfft_backend_t backend type~dtfft_stream_t->c_ptr stream type~abstract_executor abstract_executor type~fft_executor->type~abstract_executor fft type~abstract_executor->c_ptr plan_forward, plan_backward type~backend_helper->MPI_Comm comms type~backend_helper->c_ptr nccl_register type~backend_helper->type~pencil pencils type~dtfft_transpose_t dtfft_transpose_t type~backend_helper->type~dtfft_transpose_t tranpose_type type~ncclcomm ncclComm type~backend_helper->type~ncclcomm nccl_comm type~ncclcomm->c_ptr member

Inherited by

type~~dtfft_plan_t~~InheritedByGraph type~dtfft_plan_t dtfft_plan_t type~dtfft_core_c2c dtfft_core_c2c type~dtfft_core_c2c->type~dtfft_plan_t type~dtfft_plan_r2r_t dtfft_plan_r2r_t type~dtfft_plan_r2r_t->type~dtfft_plan_t type~plan_c plan_c type~plan_c->type~dtfft_plan_t p type~dtfft_plan_c2c_t dtfft_plan_c2c_t type~dtfft_plan_c2c_t->type~dtfft_core_c2c type~dtfft_plan_r2c_t dtfft_plan_r2c_t type~dtfft_plan_r2c_t->type~dtfft_core_c2c

Components

Type Visibility Attributes Name Initial
integer(kind=int8), private :: ndims

Number of global dimensions
integer(kind=int32), private, allocatable :: dims(:)

Global dimensions
type(dtfft_precision_t), private :: precision

Precision of transform
logical, private :: is_created = .false.

Plan creation flag
logical, private :: is_transpose_plan = .false.

Plan is transpose only
logical, private :: is_aux_alloc = .false.

Auxiliary buffer is allocated internally
logical, private :: is_z_slab = .false.

Using Z-slab optimization

Only 3D plan.

When .true., then data is distributed only Z direction and it creates a possibility for optimization:

  • 2 dimensional FFT plan is created for both X and Y dimensions
  • Single call to MPI_Alltoall is required to transpose data from X-align to Z align

For CUDA build this optimization means single CUDA kernel that tranposes data directly from X to Z
type(dtfft_effort_t), private :: effort

User defined type of effort
integer(kind=int64), private :: storage_size

Single element size in bytes
type(dtfft_executor_t), private :: executor

FFT executor type
type(MPI_Comm), private :: comm

Grid communicator
type(MPI_Comm), private, allocatable :: comms(:)

Local 1d communicators
class(abstract_transpose_plan), private, allocatable :: plan

Transpose plan handle
type(pencil), private, allocatable :: pencils(:)

Information about data aligment and datatypes
type(dtfft_platform_t), private :: platform

Execution platform
type(dtfft_stream_t), private :: stream

CUDA Stream associated with current plan
type(c_ptr), private :: aux_ptr

Auxiliary pointer
type(fft_executor), private, allocatable :: fft(:)

Internal fft runners
integer(kind=int32), private, allocatable :: fft_mapping(:)

Memory and plan creation optimization. In case same FFTs needs to be run in different dimensions only single FFT plan needs to be created

Type-Bound Procedures

procedure, public, pass(self), non_overridable :: transpose

Performs single transposition

  • private subroutine transpose(self, in, out, transpose_type, error_code)

    Performs single transposition

    Read more…

    Arguments

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

    Abstract plan
    type(*), intent(inout), target :: in(..)

    Incoming buffer of any rank and kind. Note that this buffer will be modified in GPU build
    type(*), intent(inout), target :: out(..)

    Resulting buffer of any rank and kind
    type(dtfft_transpose_t), intent(in) :: transpose_type

    Type of transposition.
    integer(kind=int32), intent(out), optional :: error_code

    Optional error code returned to user

procedure, public, pass(self), non_overridable :: transpose_ptr

Performs single transposition using type(c_ptr) pointers instead of buffers

  • private subroutine transpose_ptr(self, in, out, transpose_type, error_code)

    Performs single transposition using type(c_ptr) pointers instead of buffers

    Read more…

    Arguments

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

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

    Incoming pointer. Note that values of this pointer will be modified in GPU build
    type(c_ptr), intent(in) :: out

    Resulting pointer
    type(dtfft_transpose_t), intent(in) :: transpose_type

    Type of transposition.
    integer(kind=int32), intent(out), optional :: error_code

    Optional error code returned to user

procedure, public, pass(self), non_overridable :: execute

Executes plan

  • private subroutine execute(self, in, out, execute_type, aux, error_code)

    Executes plan

    Arguments

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

    Abstract plan
    type(*), intent(inout), target :: in(..)

    Incoming buffer of any rank and kind
    type(*), intent(inout), target :: out(..)

    Resulting buffer of any rank and kind
    type(dtfft_execute_t), intent(in) :: execute_type

    Type of execution.
    type(*), intent(inout), optional, target :: aux(..)

    Optional auxiliary buffer. Size of buffer must be greater than value returned by alloc_size parameter of get_local_sizes subroutine
    integer(kind=int32), intent(out), optional :: error_code

    Optional error code returned to user

procedure, public, pass(self), non_overridable :: execute_ptr

Executes plan using type(c_ptr) pointers instead of buffers

  • private subroutine execute_ptr(self, in, out, execute_type, aux, error_code)

    Executes plan using type(c_ptr) pointers instead of buffers

    Arguments

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

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

    Incoming pointer. Note that values of this pointer will be modified in GPU build
    type(c_ptr), intent(in) :: out

    Resulting pointer
    type(dtfft_execute_t), intent(in) :: execute_type

    Type of execution.
    type(c_ptr), intent(in) :: aux

    Optional auxiliary buffer. Size of buffer must be greater than value returned by alloc_size parameter of get_local_sizes subroutine
    integer(kind=int32), intent(out), optional :: error_code

    Optional error code returned to user

procedure, public, pass(self), non_overridable :: destroy

Destroys plan

  • private subroutine destroy(self, error_code)

    Destroys plan, frees all memory

    Arguments

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

    Abstract plan
    integer(kind=int32), intent(out), optional :: error_code

    Optional Error Code returned to user

procedure, public, pass(self), non_overridable :: get_local_sizes

Returns local starts and counts in real and fourier spaces

  • private subroutine get_local_sizes(self, in_starts, in_counts, out_starts, out_counts, alloc_size, error_code)

    Obtain local starts and counts in real and fourier spaces

    Arguments

    Type IntentOptional Attributes Name
    class(dtfft_plan_t), intent(in) :: self

    Abstract plan
    integer(kind=int32), intent(out), optional :: in_starts(:)

    Starts of local portion of data in real space (0-based)
    integer(kind=int32), intent(out), optional :: in_counts(:)

    Number of elements of local portion of data in ‘real’ space
    integer(kind=int32), intent(out), optional :: out_starts(:)

    Starts of local portion of data in fourier space (0-based)
    integer(kind=int32), intent(out), optional :: out_counts(:)

    Number of elements of local portion of data in fourier space
    integer(kind=int64), intent(out), optional :: alloc_size

    Minimal number of elements required to execute plan
    integer(kind=int32), intent(out), optional :: error_code

    Optional error code returned to user

procedure, public, pass(self), non_overridable :: get_alloc_size

Wrapper around get_local_sizes to obtain number of elements only

  • private function get_alloc_size(self, error_code) result(alloc_size)

    Wrapper around get_local_sizes to obtain number of elements only

    Arguments

    Type IntentOptional Attributes Name
    class(dtfft_plan_t), intent(in) :: self

    Abstract plan
    integer(kind=int32), intent(out), optional :: error_code

    Optional error code returned to user

    Return Value integer(kind=int64)

    Minimal number of elements required to execute plan

procedure, public, pass(self), non_overridable :: get_z_slab_enabled

Returns logical value is Z-slab optimization is enabled

  • private function get_z_slab_enabled(self, error_code)

    Returns logical value is Z-slab optimization enabled internally

    Arguments

    Type IntentOptional Attributes Name
    class(dtfft_plan_t), intent(in) :: self

    Abstract plan
    integer(kind=int32), intent(out), optional :: error_code

    Optional error code returned to user

    Return Value logical

procedure, public, pass(self), non_overridable :: get_pencil

Returns pencil decomposition

  • private function get_pencil(self, dim, error_code)

    Returns pencil decomposition

    Arguments

    Type IntentOptional Attributes Name
    class(dtfft_plan_t), intent(in) :: self

    Abstract plan
    integer(kind=int32), intent(in) :: dim

    Required dimension:

    Read more…
    integer(kind=int32), intent(out), optional :: error_code

    Optional error code returned to user

    Return Value type(dtfft_pencil_t)

procedure, public, pass(self), non_overridable :: get_element_size

Returns number of bytes required to store single element.

  • private function get_element_size(self, error_code)

    Returns number of bytes required to store single element.

    Arguments

    Type IntentOptional Attributes Name
    class(dtfft_plan_t), intent(in) :: self

    Abstract plan
    integer(kind=int32), intent(out), optional :: error_code

    Optional error code returned to user

    Return Value integer(kind=int64)

procedure, public, pass(self), non_overridable :: get_alloc_bytes

Returns minimum number of bytes required to execute plan

  • private function get_alloc_bytes(self, error_code)

    Returns minimum number of bytes required to execute plan

    Arguments

    Type IntentOptional Attributes Name
    class(dtfft_plan_t), intent(in) :: self

    Abstract plan
    integer(kind=int32), intent(out), optional :: error_code

    Optional error code returned to user

    Return Value integer(kind=int64)

procedure, public, pass(self), non_overridable :: report

Prints plan details

  • private subroutine report(self, error_code)

    Prints plan-related information to stdout

    Arguments

    Type IntentOptional Attributes Name
    class(dtfft_plan_t), intent(in) :: self

    Abstract plan
    integer(kind=int32), intent(out), optional :: error_code

    Optional error code returned to user

procedure, public, pass(self), non_overridable :: mem_alloc_ptr

Allocates memory for type(c_ptr)

  • private subroutine mem_alloc_ptr(self, alloc_bytes, ptr, error_code)

    Allocates memory specific for this plan

    Arguments

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

    Abstract plan
    integer(kind=int64), intent(in) :: alloc_bytes

    Number of bytes to allocate
    type(c_ptr), intent(out) :: ptr

    Allocated pointer
    integer(kind=int32), intent(out), optional :: error_code

    Optional error code returned to user

generic, public :: mem_alloc => mem_alloc_r32_1d, mem_alloc_r64_1d, mem_alloc_r32_2d, mem_alloc_r64_2d, mem_alloc_r32_3d, mem_alloc_r64_3d, mem_alloc_c32_1d, mem_alloc_c64_1d, mem_alloc_c32_2d, mem_alloc_c64_2d, mem_alloc_c32_3d, mem_alloc_c64_3d

Allocates memory specific for this plan

  • private subroutine mem_alloc_r32_1d(self, alloc_size, ptr, lbound, error_code)

    Allocates pointer of rank 1

    Arguments

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

    Abstract plan
    integer(kind=int64), intent(in) :: alloc_size

    Number of elements to allocate
    real(kind=real32), intent(out), pointer :: ptr(:)
    integer(kind=int32), intent(in), optional :: lbound
    integer(kind=int32), intent(out), optional :: error_code

    Optional error code returned to user

  • private subroutine mem_alloc_r64_1d(self, alloc_size, ptr, lbound, error_code)

    Allocates pointer of rank 1

    Arguments

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

    Abstract plan
    integer(kind=int64), intent(in) :: alloc_size

    Number of elements to allocate
    real(kind=real64), intent(out), pointer :: ptr(:)
    integer(kind=int32), intent(in), optional :: lbound
    integer(kind=int32), intent(out), optional :: error_code

    Optional error code returned to user

  • private subroutine mem_alloc_r32_2d(self, alloc_size, ptr, sizes, lbounds, error_code)

    Allocates pointer of rank 2

    Arguments

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

    Abstract plan
    integer(kind=int64), intent(in) :: alloc_size

    Number of elements to allocate
    real(kind=real32), intent(out), pointer :: ptr(:,:)
    integer(kind=int32), intent(in) :: sizes(2)
    integer(kind=int32), intent(in), optional :: lbounds(2)
    integer(kind=int32), intent(out), optional :: error_code

    Optional error code returned to user

  • private subroutine mem_alloc_r64_2d(self, alloc_size, ptr, sizes, lbounds, error_code)

    Allocates pointer of rank 2

    Arguments

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

    Abstract plan
    integer(kind=int64), intent(in) :: alloc_size

    Number of elements to allocate
    real(kind=real64), intent(out), pointer :: ptr(:,:)
    integer(kind=int32), intent(in) :: sizes(2)
    integer(kind=int32), intent(in), optional :: lbounds(2)
    integer(kind=int32), intent(out), optional :: error_code

    Optional error code returned to user

  • private subroutine mem_alloc_r32_3d(self, alloc_size, ptr, sizes, lbounds, error_code)

    Allocates pointer of rank 3

    Arguments

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

    Abstract plan
    integer(kind=int64), intent(in) :: alloc_size

    Number of elements to allocate
    real(kind=real32), intent(out), pointer :: ptr(:,:,:)
    integer(kind=int32), intent(in) :: sizes(3)
    integer(kind=int32), intent(in), optional :: lbounds(3)
    integer(kind=int32), intent(out), optional :: error_code

    Optional error code returned to user

  • private subroutine mem_alloc_r64_3d(self, alloc_size, ptr, sizes, lbounds, error_code)

    Allocates pointer of rank 3

    Arguments

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

    Abstract plan
    integer(kind=int64), intent(in) :: alloc_size

    Number of elements to allocate
    real(kind=real64), intent(out), pointer :: ptr(:,:,:)
    integer(kind=int32), intent(in) :: sizes(3)
    integer(kind=int32), intent(in), optional :: lbounds(3)
    integer(kind=int32), intent(out), optional :: error_code

    Optional error code returned to user

  • private subroutine mem_alloc_c32_1d(self, alloc_size, ptr, lbound, error_code)

    Allocates pointer of rank 1

    Arguments

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

    Abstract plan
    integer(kind=int64), intent(in) :: alloc_size

    Number of elements to allocate
    complex(kind=real32), intent(out), pointer :: ptr(:)
    integer(kind=int32), intent(in), optional :: lbound
    integer(kind=int32), intent(out), optional :: error_code

    Optional error code returned to user

  • private subroutine mem_alloc_c64_1d(self, alloc_size, ptr, lbound, error_code)

    Allocates pointer of rank 1

    Arguments

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

    Abstract plan
    integer(kind=int64), intent(in) :: alloc_size

    Number of elements to allocate
    complex(kind=real64), intent(out), pointer :: ptr(:)
    integer(kind=int32), intent(in), optional :: lbound
    integer(kind=int32), intent(out), optional :: error_code

    Optional error code returned to user

  • private subroutine mem_alloc_c32_2d(self, alloc_size, ptr, sizes, lbounds, error_code)

    Allocates pointer of rank 2

    Arguments

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

    Abstract plan
    integer(kind=int64), intent(in) :: alloc_size

    Number of elements to allocate
    complex(kind=real32), intent(out), pointer :: ptr(:,:)
    integer(kind=int32), intent(in) :: sizes(2)
    integer(kind=int32), intent(in), optional :: lbounds(2)
    integer(kind=int32), intent(out), optional :: error_code

    Optional error code returned to user

  • private subroutine mem_alloc_c64_2d(self, alloc_size, ptr, sizes, lbounds, error_code)

    Allocates pointer of rank 2

    Arguments

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

    Abstract plan
    integer(kind=int64), intent(in) :: alloc_size

    Number of elements to allocate
    complex(kind=real64), intent(out), pointer :: ptr(:,:)
    integer(kind=int32), intent(in) :: sizes(2)
    integer(kind=int32), intent(in), optional :: lbounds(2)
    integer(kind=int32), intent(out), optional :: error_code

    Optional error code returned to user

  • private subroutine mem_alloc_c32_3d(self, alloc_size, ptr, sizes, lbounds, error_code)

    Allocates pointer of rank 3

    Arguments

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

    Abstract plan
    integer(kind=int64), intent(in) :: alloc_size

    Number of elements to allocate
    complex(kind=real32), intent(out), pointer :: ptr(:,:,:)
    integer(kind=int32), intent(in) :: sizes(3)
    integer(kind=int32), intent(in), optional :: lbounds(3)
    integer(kind=int32), intent(out), optional :: error_code

    Optional error code returned to user

  • private subroutine mem_alloc_c64_3d(self, alloc_size, ptr, sizes, lbounds, error_code)

    Allocates pointer of rank 3

    Arguments

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

    Abstract plan
    integer(kind=int64), intent(in) :: alloc_size

    Number of elements to allocate
    complex(kind=real64), intent(out), pointer :: ptr(:,:,:)
    integer(kind=int32), intent(in) :: sizes(3)
    integer(kind=int32), intent(in), optional :: lbounds(3)
    integer(kind=int32), intent(out), optional :: error_code

    Optional error code returned to user

procedure, public, pass(self), non_overridable :: mem_free_ptr

Frees previously allocated memory for type(c_ptr)

  • private subroutine mem_free_ptr(self, ptr, error_code)

    Frees previously allocated memory specific for this plan

    Arguments

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

    Abstract plan
    type(c_ptr), intent(in) :: ptr

    Pointer allocated with mem_alloc
    integer(kind=int32), intent(out), optional :: error_code

    Optional error code returned to user

generic, public :: mem_free => mem_free_r32_1d, mem_free_r32_2d, mem_free_r32_3d, mem_free_r64_1d, mem_free_r64_2d, mem_free_r64_3d, mem_free_c32_1d, mem_free_c32_2d, mem_free_c32_3d, mem_free_c64_1d, mem_free_c64_2d, mem_free_c64_3d

Frees previously allocated memory specific for this plan

  • private subroutine mem_free_r32_1d(self, ptr, error_code)

    Frees previously allocated memory specific for this plan

    Arguments

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

    Abstract plan
    real(kind=real32), intent(inout), target :: ptr(:)

    Pointer allocated with mem_alloc
    integer(kind=int32), intent(out), optional :: error_code

    Optional error code returned to user

  • private subroutine mem_free_r32_2d(self, ptr, error_code)

    Frees previously allocated memory specific for this plan

    Arguments

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

    Abstract plan
    real(kind=real32), intent(inout), target :: ptr(:,:)

    Pointer allocated with mem_alloc
    integer(kind=int32), intent(out), optional :: error_code

    Optional error code returned to user

  • private subroutine mem_free_r32_3d(self, ptr, error_code)

    Frees previously allocated memory specific for this plan

    Arguments

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

    Abstract plan
    real(kind=real32), intent(inout), target :: ptr(:,:,:)

    Pointer allocated with mem_alloc
    integer(kind=int32), intent(out), optional :: error_code

    Optional error code returned to user

  • private subroutine mem_free_r64_1d(self, ptr, error_code)

    Frees previously allocated memory specific for this plan

    Arguments

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

    Abstract plan
    real(kind=real64), intent(inout), target :: ptr(:)

    Pointer allocated with mem_alloc
    integer(kind=int32), intent(out), optional :: error_code

    Optional error code returned to user

  • private subroutine mem_free_r64_2d(self, ptr, error_code)

    Frees previously allocated memory specific for this plan

    Arguments

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

    Abstract plan
    real(kind=real64), intent(inout), target :: ptr(:,:)

    Pointer allocated with mem_alloc
    integer(kind=int32), intent(out), optional :: error_code

    Optional error code returned to user

  • private subroutine mem_free_r64_3d(self, ptr, error_code)

    Frees previously allocated memory specific for this plan

    Arguments

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

    Abstract plan
    real(kind=real64), intent(inout), target :: ptr(:,:,:)

    Pointer allocated with mem_alloc
    integer(kind=int32), intent(out), optional :: error_code

    Optional error code returned to user

  • private subroutine mem_free_c32_1d(self, ptr, error_code)

    Frees previously allocated memory specific for this plan

    Arguments

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

    Abstract plan
    complex(kind=real32), intent(inout), target :: ptr(:)

    Pointer allocated with mem_alloc
    integer(kind=int32), intent(out), optional :: error_code

    Optional error code returned to user

  • private subroutine mem_free_c32_2d(self, ptr, error_code)

    Frees previously allocated memory specific for this plan

    Arguments

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

    Abstract plan
    complex(kind=real32), intent(inout), target :: ptr(:,:)

    Pointer allocated with mem_alloc
    integer(kind=int32), intent(out), optional :: error_code

    Optional error code returned to user

  • private subroutine mem_free_c32_3d(self, ptr, error_code)

    Frees previously allocated memory specific for this plan

    Arguments

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

    Abstract plan
    complex(kind=real32), intent(inout), target :: ptr(:,:,:)

    Pointer allocated with mem_alloc
    integer(kind=int32), intent(out), optional :: error_code

    Optional error code returned to user

  • private subroutine mem_free_c64_1d(self, ptr, error_code)

    Frees previously allocated memory specific for this plan

    Arguments

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

    Abstract plan
    complex(kind=real64), intent(inout), target :: ptr(:)

    Pointer allocated with mem_alloc
    integer(kind=int32), intent(out), optional :: error_code

    Optional error code returned to user

  • private subroutine mem_free_c64_2d(self, ptr, error_code)

    Frees previously allocated memory specific for this plan

    Arguments

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

    Abstract plan
    complex(kind=real64), intent(inout), target :: ptr(:,:)

    Pointer allocated with mem_alloc
    integer(kind=int32), intent(out), optional :: error_code

    Optional error code returned to user

  • private subroutine mem_free_c64_3d(self, ptr, error_code)

    Frees previously allocated memory specific for this plan

    Arguments

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

    Abstract plan
    complex(kind=real64), intent(inout), target :: ptr(:,:,:)

    Pointer allocated with mem_alloc
    integer(kind=int32), intent(out), optional :: error_code

    Optional error code returned to user

procedure, public, pass(self), non_overridable :: get_platform

Returns plan execution platform

  • private function get_platform(self, error_code)

    Returns execution platform of the plan (HOST or CUDA)

    Arguments

    Type IntentOptional Attributes Name
    class(dtfft_plan_t), intent(in) :: self

    Abstract plan
    integer(kind=int32), intent(out), optional :: error_code

    Optional error code returned to user

    Return Value type(dtfft_platform_t)

procedure, public, pass(self), non_overridable :: get_backend

Returns selected GPU backend during autotuning

  • private function get_backend(self, error_code)

    Returns selected GPU backend during autotuning

    Arguments

    Type IntentOptional Attributes Name
    class(dtfft_plan_t), intent(in) :: self

    Abstract plan
    integer(kind=int32), intent(out), optional :: error_code

    Optional error code returned to user

    Return Value type(dtfft_backend_t)

generic, public :: get_stream => get_stream_ptr, get_stream_int64

Returns CUDA stream associated with plan

  • private subroutine get_stream_ptr(self, stream, error_code)

    Returns CUDA stream associated with plan

    Arguments

    Type IntentOptional Attributes Name
    class(dtfft_plan_t), intent(in) :: self

    Abstract plan
    type(dtfft_stream_t), intent(out) :: stream

    dtFFT Stream
    integer(kind=int32), intent(out), optional :: error_code

    Optional error code returned to user

  • private subroutine get_stream_int64(self, stream, error_code)

    Returns CUDA stream associated with plan

    Arguments

    Type IntentOptional Attributes Name
    class(dtfft_plan_t), intent(in) :: self

    Abstract plan
    integer(kind=int64), intent(out) :: stream

    CUDA-Fortran Stream
    integer(kind=int32), intent(out), optional :: error_code

    Optional error code returned to user

procedure, private, pass(self), non_overridable :: get_stream_ptr

Returns CUDA stream associated with plan

  • private subroutine get_stream_ptr(self, stream, error_code)

    Returns CUDA stream associated with plan

    Arguments

    Type IntentOptional Attributes Name
    class(dtfft_plan_t), intent(in) :: self

    Abstract plan
    type(dtfft_stream_t), intent(out) :: stream

    dtFFT Stream
    integer(kind=int32), intent(out), optional :: error_code

    Optional error code returned to user

procedure, private, pass(self), non_overridable :: get_stream_int64

Returns CUDA stream associated with plan

  • private subroutine get_stream_int64(self, stream, error_code)

    Returns CUDA stream associated with plan

    Arguments

    Type IntentOptional Attributes Name
    class(dtfft_plan_t), intent(in) :: self

    Abstract plan
    integer(kind=int64), intent(out) :: stream

    CUDA-Fortran Stream
    integer(kind=int32), intent(out), optional :: error_code

    Optional error code returned to user

procedure, private, pass(self), non_overridable :: execute_private

Executes plan

  • private subroutine execute_private(self, in, out, execute_type, aux, inplace)

    Executes plan with specified auxiliary buffer

    Arguments

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

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

    Source pointer
    type(c_ptr), intent(in) :: out

    Target pointer
    type(dtfft_execute_t), intent(in) :: execute_type

    Type of execution.
    type(c_ptr), intent(in) :: aux

    Auxiliary pointer.
    logical, intent(in) :: inplace

    Inplace execution flag

procedure, private, pass(self), non_overridable :: check_create_args

Check arguments provided to create subroutines

  • private function check_create_args(self, dims, comm, precision, effort, executor, kinds)

    Check arguments provided by user and sets private variables

    Arguments

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

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

    Global dimensions of transform
    type(MPI_Comm), intent(in), optional :: comm

    Optional MPI Communicator
    type(dtfft_precision_t), intent(in), optional :: precision

    Precision of transform: DTFFT_SINGLE or DTFFT_DOUBLE
    type(dtfft_effort_t), intent(in), optional :: effort

    How thoroughly dtFFT searches for the optimal plan
    type(dtfft_executor_t), intent(in), optional :: executor

    Type of External FFT Executor
    type(dtfft_r2r_kind_t), intent(in), optional :: kinds(:)

    Kinds of R2R transform

    Return Value integer(kind=int32)

procedure, private, pass(self), non_overridable :: create_private

Creates core

  • private function create_private(self, dims, sngl_type, sngl_storage_size, dbl_type, dbl_storage_size, comm, precision, effort, executor, kinds)

    Creates core

    Arguments

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

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

    Global dimensions of transform
    type(MPI_Datatype), intent(in) :: sngl_type

    MPI_Datatype for single precision plan
    integer(kind=int64), intent(in) :: sngl_storage_size

    Number of bytes needed to store single element (single precision)
    type(MPI_Datatype), intent(in) :: dbl_type

    MPI_Datatype for double precision plan
    integer(kind=int64), intent(in) :: dbl_storage_size

    Number of bytes needed to store single element (double precision)
    type(MPI_Comm), intent(in), optional :: comm

    User-defined communicator
    type(dtfft_precision_t), intent(in), optional :: precision

    Precision of transform: DTFFT_SINGLE or DTFFT_DOUBLE
    type(dtfft_effort_t), intent(in), optional :: effort

    How thoroughly dtFFT searches for the optimal plan
    type(dtfft_executor_t), intent(in), optional :: executor

    Type of External FFT Executor
    type(dtfft_r2r_kind_t), intent(in), optional :: kinds(:)

    Kinds of R2R transform

    Return Value integer(kind=int32)

procedure, private, pass(self), non_overridable :: alloc_fft_plans

Allocates fft_executor classes

procedure, private, pass(self), non_overridable :: check_aux

Checks if aux buffer was passed and if not will allocate one internally

  • private subroutine check_aux(self, aux)

    Checks if aux buffer was passed by user and if not will allocate one internally

    Arguments

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

    Abstract plan
    type(c_ptr), intent(in) :: aux

    Optional auxiliary buffer.

procedure, private, pass(self), non_overridable :: mem_alloc_r32_1d

Allocates memory for 1d real32 pointer

  • private subroutine mem_alloc_r32_1d(self, alloc_size, ptr, lbound, error_code)

    Allocates pointer of rank 1

    Arguments

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

    Abstract plan
    integer(kind=int64), intent(in) :: alloc_size

    Number of elements to allocate
    real(kind=real32), intent(out), pointer :: ptr(:)
    integer(kind=int32), intent(in), optional :: lbound
    integer(kind=int32), intent(out), optional :: error_code

    Optional error code returned to user

procedure, private, pass(self), non_overridable :: mem_alloc_r64_1d

Allocates memory for 1d real64 pointer

  • private subroutine mem_alloc_r64_1d(self, alloc_size, ptr, lbound, error_code)

    Allocates pointer of rank 1

    Arguments

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

    Abstract plan
    integer(kind=int64), intent(in) :: alloc_size

    Number of elements to allocate
    real(kind=real64), intent(out), pointer :: ptr(:)
    integer(kind=int32), intent(in), optional :: lbound
    integer(kind=int32), intent(out), optional :: error_code

    Optional error code returned to user

procedure, private, pass(self), non_overridable :: mem_alloc_r32_2d

Allocates memory for 2d real32 pointer

  • private subroutine mem_alloc_r32_2d(self, alloc_size, ptr, sizes, lbounds, error_code)

    Allocates pointer of rank 2

    Arguments

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

    Abstract plan
    integer(kind=int64), intent(in) :: alloc_size

    Number of elements to allocate
    real(kind=real32), intent(out), pointer :: ptr(:,:)
    integer(kind=int32), intent(in) :: sizes(2)
    integer(kind=int32), intent(in), optional :: lbounds(2)
    integer(kind=int32), intent(out), optional :: error_code

    Optional error code returned to user

procedure, private, pass(self), non_overridable :: mem_alloc_r64_2d

Allocates memory for 2d real64 pointer

  • private subroutine mem_alloc_r64_2d(self, alloc_size, ptr, sizes, lbounds, error_code)

    Allocates pointer of rank 2

    Arguments

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

    Abstract plan
    integer(kind=int64), intent(in) :: alloc_size

    Number of elements to allocate
    real(kind=real64), intent(out), pointer :: ptr(:,:)
    integer(kind=int32), intent(in) :: sizes(2)
    integer(kind=int32), intent(in), optional :: lbounds(2)
    integer(kind=int32), intent(out), optional :: error_code

    Optional error code returned to user

procedure, private, pass(self), non_overridable :: mem_alloc_r32_3d

Allocates memory for 2d real32 pointer

  • private subroutine mem_alloc_r32_3d(self, alloc_size, ptr, sizes, lbounds, error_code)

    Allocates pointer of rank 3

    Arguments

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

    Abstract plan
    integer(kind=int64), intent(in) :: alloc_size

    Number of elements to allocate
    real(kind=real32), intent(out), pointer :: ptr(:,:,:)
    integer(kind=int32), intent(in) :: sizes(3)
    integer(kind=int32), intent(in), optional :: lbounds(3)
    integer(kind=int32), intent(out), optional :: error_code

    Optional error code returned to user

procedure, private, pass(self), non_overridable :: mem_alloc_r64_3d

Allocates memory for 2d real64 pointer

  • private subroutine mem_alloc_r64_3d(self, alloc_size, ptr, sizes, lbounds, error_code)

    Allocates pointer of rank 3

    Arguments

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

    Abstract plan
    integer(kind=int64), intent(in) :: alloc_size

    Number of elements to allocate
    real(kind=real64), intent(out), pointer :: ptr(:,:,:)
    integer(kind=int32), intent(in) :: sizes(3)
    integer(kind=int32), intent(in), optional :: lbounds(3)
    integer(kind=int32), intent(out), optional :: error_code

    Optional error code returned to user

procedure, private, pass(self), non_overridable :: mem_alloc_c32_1d

Allocates memory for 1d complex32 pointer

  • private subroutine mem_alloc_c32_1d(self, alloc_size, ptr, lbound, error_code)

    Allocates pointer of rank 1

    Arguments

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

    Abstract plan
    integer(kind=int64), intent(in) :: alloc_size

    Number of elements to allocate
    complex(kind=real32), intent(out), pointer :: ptr(:)
    integer(kind=int32), intent(in), optional :: lbound
    integer(kind=int32), intent(out), optional :: error_code

    Optional error code returned to user

procedure, private, pass(self), non_overridable :: mem_alloc_c64_1d

Allocates memory for 1d complex64 pointer

  • private subroutine mem_alloc_c64_1d(self, alloc_size, ptr, lbound, error_code)

    Allocates pointer of rank 1

    Arguments

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

    Abstract plan
    integer(kind=int64), intent(in) :: alloc_size

    Number of elements to allocate
    complex(kind=real64), intent(out), pointer :: ptr(:)
    integer(kind=int32), intent(in), optional :: lbound
    integer(kind=int32), intent(out), optional :: error_code

    Optional error code returned to user

procedure, private, pass(self), non_overridable :: mem_alloc_c32_2d

Allocates memory for 2d complex32 pointer

  • private subroutine mem_alloc_c32_2d(self, alloc_size, ptr, sizes, lbounds, error_code)

    Allocates pointer of rank 2

    Arguments

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

    Abstract plan
    integer(kind=int64), intent(in) :: alloc_size

    Number of elements to allocate
    complex(kind=real32), intent(out), pointer :: ptr(:,:)
    integer(kind=int32), intent(in) :: sizes(2)
    integer(kind=int32), intent(in), optional :: lbounds(2)
    integer(kind=int32), intent(out), optional :: error_code

    Optional error code returned to user

procedure, private, pass(self), non_overridable :: mem_alloc_c64_2d

Allocates memory for 2d complex64 pointer

  • private subroutine mem_alloc_c64_2d(self, alloc_size, ptr, sizes, lbounds, error_code)

    Allocates pointer of rank 2

    Arguments

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

    Abstract plan
    integer(kind=int64), intent(in) :: alloc_size

    Number of elements to allocate
    complex(kind=real64), intent(out), pointer :: ptr(:,:)
    integer(kind=int32), intent(in) :: sizes(2)
    integer(kind=int32), intent(in), optional :: lbounds(2)
    integer(kind=int32), intent(out), optional :: error_code

    Optional error code returned to user

procedure, private, pass(self), non_overridable :: mem_alloc_c32_3d

Allocates memory for 3d complex32 pointer

  • private subroutine mem_alloc_c32_3d(self, alloc_size, ptr, sizes, lbounds, error_code)

    Allocates pointer of rank 3

    Arguments

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

    Abstract plan
    integer(kind=int64), intent(in) :: alloc_size

    Number of elements to allocate
    complex(kind=real32), intent(out), pointer :: ptr(:,:,:)
    integer(kind=int32), intent(in) :: sizes(3)
    integer(kind=int32), intent(in), optional :: lbounds(3)
    integer(kind=int32), intent(out), optional :: error_code

    Optional error code returned to user

procedure, private, pass(self), non_overridable :: mem_alloc_c64_3d

Allocates memory for 3d complex64 pointer

  • private subroutine mem_alloc_c64_3d(self, alloc_size, ptr, sizes, lbounds, error_code)

    Allocates pointer of rank 3

    Arguments

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

    Abstract plan
    integer(kind=int64), intent(in) :: alloc_size

    Number of elements to allocate
    complex(kind=real64), intent(out), pointer :: ptr(:,:,:)
    integer(kind=int32), intent(in) :: sizes(3)
    integer(kind=int32), intent(in), optional :: lbounds(3)
    integer(kind=int32), intent(out), optional :: error_code

    Optional error code returned to user

procedure, private, pass(self), non_overridable :: mem_free_r32_1d

Frees real32 1d pointer

  • private subroutine mem_free_r32_1d(self, ptr, error_code)

    Frees previously allocated memory specific for this plan

    Arguments

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

    Abstract plan
    real(kind=real32), intent(inout), target :: ptr(:)

    Pointer allocated with mem_alloc
    integer(kind=int32), intent(out), optional :: error_code

    Optional error code returned to user

procedure, private, pass(self), non_overridable :: mem_free_r64_1d

Frees real64 1d pointer

  • private subroutine mem_free_r64_1d(self, ptr, error_code)

    Frees previously allocated memory specific for this plan

    Arguments

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

    Abstract plan
    real(kind=real64), intent(inout), target :: ptr(:)

    Pointer allocated with mem_alloc
    integer(kind=int32), intent(out), optional :: error_code

    Optional error code returned to user

procedure, private, pass(self), non_overridable :: mem_free_r32_2d

Frees real32 2d pointer

  • private subroutine mem_free_r32_2d(self, ptr, error_code)

    Frees previously allocated memory specific for this plan

    Arguments

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

    Abstract plan
    real(kind=real32), intent(inout), target :: ptr(:,:)

    Pointer allocated with mem_alloc
    integer(kind=int32), intent(out), optional :: error_code

    Optional error code returned to user

procedure, private, pass(self), non_overridable :: mem_free_r64_2d

Frees real64 2d pointer

  • private subroutine mem_free_r64_2d(self, ptr, error_code)

    Frees previously allocated memory specific for this plan

    Arguments

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

    Abstract plan
    real(kind=real64), intent(inout), target :: ptr(:,:)

    Pointer allocated with mem_alloc
    integer(kind=int32), intent(out), optional :: error_code

    Optional error code returned to user

procedure, private, pass(self), non_overridable :: mem_free_r32_3d

Frees real32 3d pointer

  • private subroutine mem_free_r32_3d(self, ptr, error_code)

    Frees previously allocated memory specific for this plan

    Arguments

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

    Abstract plan
    real(kind=real32), intent(inout), target :: ptr(:,:,:)

    Pointer allocated with mem_alloc
    integer(kind=int32), intent(out), optional :: error_code

    Optional error code returned to user

procedure, private, pass(self), non_overridable :: mem_free_r64_3d

Frees real64 3d pointer

  • private subroutine mem_free_r64_3d(self, ptr, error_code)

    Frees previously allocated memory specific for this plan

    Arguments

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

    Abstract plan
    real(kind=real64), intent(inout), target :: ptr(:,:,:)

    Pointer allocated with mem_alloc
    integer(kind=int32), intent(out), optional :: error_code

    Optional error code returned to user

procedure, private, pass(self), non_overridable :: mem_free_c32_1d

Frees complex32 1d pointer

  • private subroutine mem_free_c32_1d(self, ptr, error_code)

    Frees previously allocated memory specific for this plan

    Arguments

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

    Abstract plan
    complex(kind=real32), intent(inout), target :: ptr(:)

    Pointer allocated with mem_alloc
    integer(kind=int32), intent(out), optional :: error_code

    Optional error code returned to user

procedure, private, pass(self), non_overridable :: mem_free_c64_1d

Frees complex64 1d pointer

  • private subroutine mem_free_c64_1d(self, ptr, error_code)

    Frees previously allocated memory specific for this plan

    Arguments

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

    Abstract plan
    complex(kind=real64), intent(inout), target :: ptr(:)

    Pointer allocated with mem_alloc
    integer(kind=int32), intent(out), optional :: error_code

    Optional error code returned to user

procedure, private, pass(self), non_overridable :: mem_free_c32_2d

Frees complex32 2d pointer

  • private subroutine mem_free_c32_2d(self, ptr, error_code)

    Frees previously allocated memory specific for this plan

    Arguments

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

    Abstract plan
    complex(kind=real32), intent(inout), target :: ptr(:,:)

    Pointer allocated with mem_alloc
    integer(kind=int32), intent(out), optional :: error_code

    Optional error code returned to user

procedure, private, pass(self), non_overridable :: mem_free_c64_2d

Frees complex64 2d pointer

  • private subroutine mem_free_c64_2d(self, ptr, error_code)

    Frees previously allocated memory specific for this plan

    Arguments

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

    Abstract plan
    complex(kind=real64), intent(inout), target :: ptr(:,:)

    Pointer allocated with mem_alloc
    integer(kind=int32), intent(out), optional :: error_code

    Optional error code returned to user

procedure, private, pass(self), non_overridable :: mem_free_c32_3d

Frees complex32 3d pointer

  • private subroutine mem_free_c32_3d(self, ptr, error_code)

    Frees previously allocated memory specific for this plan

    Arguments

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

    Abstract plan
    complex(kind=real32), intent(inout), target :: ptr(:,:,:)

    Pointer allocated with mem_alloc
    integer(kind=int32), intent(out), optional :: error_code

    Optional error code returned to user

procedure, private, pass(self), non_overridable :: mem_free_c64_3d

Frees complex64 3d pointer

  • private subroutine mem_free_c64_3d(self, ptr, error_code)

    Frees previously allocated memory specific for this plan

    Arguments

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

    Abstract plan
    complex(kind=real64), intent(inout), target :: ptr(:,:,:)

    Pointer allocated with mem_alloc
    integer(kind=int32), intent(out), optional :: error_code

    Optional error code returned to user