Intel® Software Network

The DFT routines in the Intel MKL provide one-dimensional, two-dimensional, and multi-dimensional (up to seven dimensions) FFT routines with support for mixed radix. The routines are optimized to make effective use of caches and processor architectures.

For one-dimensional and two-dimensional FFTs, the library provides complex-to-complex, real-to-complex, and complex-to-real transforms. As of version 7.2, the DFTI only supports complex-to-complex transforms for >2 dimensional FFTs. All of these transforms may be ‘in-place’ or ‘not in place’ FFTs.

The forward one-dimensional FFT is computed according to the following mathematical equation:


(Eq. 1)

The backward FFT is computed according to the following equation:


(Eq. 2)

where:



i being the square root of -1

These equations can easily be expanded to two-dimensional and multi-dimensional DFTs. Looking at these two equations gives us the basis on which various DFT interfaces are defined.

Let us look at various aspects of performing a DFT as shown by the mathematical formulation on page two. First, there are two transforms, one called forward transform, defined by Eq (1) in DFTI, and the backward transform, defined by Eq (2). The forward transform is determined by the negative sign of j in the factor and the backward transform defined by the positive sign in the same factor in Equation 2 over a sample of size n. However, DFTI provides a flexible interface to define the sign for forward and backward transforms through a set of configuration interfaces known as descriptor manipulation routines.

Another important computational aspect is the normalization factor of the transforms. As seen from Equation 2, the backward transform has a multiplier  that is needed to normalize the magnitudes of the FFT outputs as it goes through a forward followed by a backward FFT. DFTI provides a way to set the scaling (normalization) factor through the descriptor manipulation routine for both the forward and backward FFT. In order to perform the transforms, one needs to define the forward domain of the input set over which the transform is performed. This forward domain may be of type real, complex or conjugate event. This is defined during the creation of the descriptor in DFTI. One should also be able to set the precision of the input numbers to be double or single and is set as part of the descriptor. One final aspect to keep in mind when programming with DFTI is the storage format that is used for providing input and output data to the DFTI.

The DFTI APIs provide an elegant and unified set of APIs to perform FFTs with all the parameters described above and more. Note that in this article we shall not discuss the detailed syntax of the interfaces, but you may consult the Intel MKL API reference document for details on how to use these routines in your code.

Using the Interfaces

The DFT APIs are designed so that they provide a uniform interface for all forms of FFTs, ranging from one-dimension up to multi-dimensional over mixed radix and various complex-to-complex and real-to-complex forward and backward transformations.

DFTI defines three categories of APIs:

1. Descriptor Management Routines: The various attributes that affect the computation of FFTs (like sign and scaling factors) are defined through the descriptor management routines. The object used to manage these attributes is named descriptors.
2. Computing Routines: These have four combinations—two due to forward and backward computation with overloaded parameter types (complex and real included). The other two are for ‘in place’ and ‘not in place’ computations with regard to forward and backward transforms.
3. Status Check Routines: As with other standard APIs, status checking routines let the programmer know whether a particular API call was successful or not.

To utilize the DFT routines we can use the Intel MKL_DFTI module in FORTRAN by referencing the modules defined in file mkl_dfti.f90. For C/C++, we can use the include file mkl_dfti.h. Both of these files are found in the Include directory of the installed version of the Intel MKL library.

Various configuration parameters related to a DFT, such as length and input domain, are contained in a descriptor object in DFTI API. It is possible to create multiple descriptors and relate them to multiple DFT computations. A descriptor is created by the following API call DftiCreateDescriptor.

Once a descriptor is created, it contains default configuration settings such as in-place transform and sign as -1. Please refer to the Intel MKL Reference Manual for a list of configuration parameters and their default values. These values can be queried and modified using the two other routines called DftiSetValue and DftiGetValue.

Once created, the descriptor has to be committed through a call to DftiCommitDescriptor. Trying to use an uncommitted descriptor in a call to an FFT routine will result in an error. Whenever we change any parameter tied to a descriptor, the descriptor needs to be re-committed. The committal of the descriptor performs all initialization needed to perform optimal DFT computation which may involve exploring various factorizations of the input length for efficient computation.

A copy of the descriptor can be made for a computation that needs changes to some parameters. This is done through a call to DftiCopyDescriptor.

A committed descriptor is used for an FFT computation. There are two main interfaces for doing FFT computations: DftiComputeForward and DftiComputeBackward. However, these routines are overloaded for in-place and out-of-place FFT computation and various types of input/output parameters for FORTRAN interfaces. These routines also take a variable list of void pointer types for the C interfaces.

Another configuration parameter that affects the FFT computation is the storage type. Setting the storage type to proper values expected out of the computation may help improving the performance of the FFT code. In order to compute the FFT properly, make sure you have the correct size and data type storage passed into these routines.

Once done with a descriptor, the memory taken up by the descriptor needs to be freed by calling DftiFreeDescriptor.

The routines described above return status as an integer value. The successful execution of a routine is denoted by DFTI_NO_ERROR. Otherwise, an error condition occurs, which may be checked against a predefined error class through the DftiErrorClass routine. This feature is included for future expandability to provide various error classifications. If the error is of a known class, the string describing the error is available through a DftiErrorMessage routine call. This routine returns a string of max length DFTI_MAX_MESSAGE_LENGTH and can be used to output human readable messages. Although the messages are very primitive at this time, improvements are expected in the future.

Note: The table above does not list FORTRAN interfaces and Equivalent ‘C’ interfaces.

FFTW Interfaces Unsupported in DFTI

Following are the interfaces that are unsupported in DFTI:

void fftw_export_wisdom(void (*emitter)(char c, void *), void *data);
void fftw_export_wisdom_to_file(FILE *output_file);
char *fftw_export_wisdom_to_string(void);
fftw_status fftw_import_wisdom(int (*get_input)(void *), void *data);
fftw_status fftw_import_wisdom_from_file(FILE *input_file);
fftw_status fftw_import_wisdom_from_string(const char *input_string);
void fftw_forget_wisdom(void);
Memory allocations
void *(*fftw_malloc_hook) (size_t n);
void (*fftw_free_hook) (void *p);

Example Code

The following example shows how to port a 1-D complex-to-complex FFT in-place transform to DFTI interface. The lines in bold show the FFTW code, the italicized lines show the corresponding DFTI code, and the common code is shown in black.

! Fortran example.

! 1D complex to complex transform

#include “fftw_f77.i”
!Use MKL_DFTI


Complex :: X(32)

Complex :: Scratch(32)


Integer :: plan
!Integer :: Status

!type(DFTI_DESCRIPTOR), POINTER :: My_Desc1_Handle


...put input data into X(1),...,X(32)


! Perform a complex to complex transform
call fftw_f77_create_plan(plan,32,FFTW_FORWARD,FFTW_IN_PLACE+FFTW_ESTIMATE)
!Status = DftiCreateDescriptor( My_Desc1_Handle, DFTI_SINGLE, &
!                                       DFTI_COMPLEX, 1, 32 )

!Status = DftiCommitDescriptor( My_Desc1_Handle )
call fftw_f77_one(plan,X,Scratch)

!Status = DftiComputeForward( My_Desc1_Handle, X )

! result is given by {X(1),X(2),...,X(32)}

call fftw_f77_destroy_plan(plan)
!Status = DftiFreeDescriptor(My_Desc1_Handle)