2.2.1.Free Memory Requirement

The first program call to any cuFFT function causes the initialization of the cuFFT kernels. This can fail if there is not enough free memory on the GPU. It is advisable to initialize cufft first (e.g. by creating a plan) and then allocating memory.

2.2.2.Plan Initialization Time

During plan initialization, cuFFT conducts a series of steps, including heuristics to determine which kernels to be used as well as kernel module loads. Starting from CUDA 12.0, cuFFT delivers a larger portion of kernels using the CUDA Parallel Thread eXecution assembly form (PTX code), instead of the binary form (cubin object). The PTX code of cuFFT kernels are loaded and compiled further to the binary code by the CUDA device driver at runtime when a cuFFT plan is initialized. This is calledjust-in-time (JIT) compilation.

JIT compilation slightly increases cuFFT plan initialization time, depending on the transform size and the speed of the host CPU (seeModule load driver API) . But the JIT overhead occurs only when a binary code is generated for the first time during plan initialization using one of theplan creation functions. The device driver automatically caches a copy of the generated binary code to avoid repeating the compilation in subsequent invocations. If necessary,CUDA_CACHE_PATH orCUDA_CACHE_MAXSIZE can be customized to set the cache folder and max size (see detail inCUDA Environmental Variables), but the default settings are fine in general.

2.3.1.Half-precision cuFFT Transforms

Half-precision transforms have the following limitations:

• Minimum GPU architecture is SM_75

• Sizes are restricted to powers of two only

• Strides on the real part of real-to-complex and complex-to-real transforms are not supported

• More than one GPU is not supported

• Transforms spanning more than 4 billion elements are not supported

Please refer tocufftXtMakePlanMany function for plan creation details.

The CUDA Toolkit provides thecuda_fp16.h header with types and intrinsic functions for handling half-precision arithmetic.

2.3.2.Bfloat16-precision cuFFT Transforms

cuFFT supports bfloat16 precision using thenv_bfloat16 data type. Please note that cuFFT utilizes a combination of single- and bfloat16-precision arithmetic operations when computing the FFT in bfloat16 precision. Bfloat16-precision transforms have similar limitations to half-precision transforms:

• Minimum GPU architecture is SM_80

• Sizes are restricted to powers of two only

• Strides on the real part of real-to-complex and complex-to-real transforms are not supported

• More than one GPU is not supported

• Transforms spanning more than 4 billion elements are not supported

Please refer tocufftXtMakePlanMany function for plan creation details.

The CUDA Toolkit provides thecuda_bf16.h header with types and intrinsic functions for handling bfloat16-precision arithmetic.

2.8.1.Plan Specification and Work Areas

In the single GPU case a plan is created by a call tocufftCreate() followed by a call tocufftMakePlan*(). For multiple GPUs, the GPUs to use for execution are identified by a call tocufftXtSetGPUs() and this must occur after the call tocufftCreate() and prior to the call tocufftMakePlan*().

Note that whencufftMakePlan*() is called for a single GPU, the work area is on that GPU. In a multiple GPU plan, the returned work area has multiple entries; one value per GPU. That isworkSize points to asize_t array, one entry per GPU. Also the strides and batches apply to the entire plan across all GPUs associated with the plan.

Once a plan is locked by a call tocufftMakePlan*(), different descriptors may be specified in calls tocufftXtExecDescriptor*() to execute the plan on different data sets, but the new descriptors must use the same GPUs in the same order.

As in the single GPU case,cufftEstimateSize{Many,1d,2d,3d}() andcufftGetSize{Many,1d,2d,3d}() give estimates of the work area sizes required for a multiple GPU plan and in this caseworkSize points to asize_t array, one entry per GPU.

Similarly the actual work size returned bycufftGetSize() is asize_t array, one entry per GPU in the multiple GPU case.

2.8.2.Helper Functions

Multiple GPU cuFFT execution functions assume a certain data layout in terms of what input data has been copied to which GPUs prior to execution, and what output data resides in which GPUs post execution. cuFFT provides functions to assist users in manipulating data on multiple GPUs. These must be called after the call tocufftMakePlan*().

On a single GPU users may callcudaMalloc() andcudaFree() to allocate and free GPU memory. To provide similar functionality in the multiple GPU case, cuFFT includescufftXtMalloc() andcufftXtFree() functions. The functioncufftXtMalloc() returns a descriptor which specifies the location of these memories.

On a single GPU users may callcudaMemcpy() to transfer data between host and GPU memory. To provide similar functionality in the multiple GPU case, cuFFT includescufftXtMemcpy() which allows users to copy between host and multiple GPU memories or even between the GPU memories.

All single GPU cuFFT FFTs return output the data in natural order, that is the ordering of the result is the same as if a DFT had been performed on the data. Some Fast Fourier Transforms produce intermediate results where the data is left in a permutation of the natural output. When batch is one, data is left in the GPU memory in a permutation of the natural output.

WhencufftXtMemcpy() is used to copy data from GPU memory back to host memory, the results are in natural order regardless of whether the data on the GPUs is in natural order or permuted. UsingCUFFT_COPY_DEVICE_TO_DEVICE allows users to copy data from the permuted data format produced after a single transform to the natural order on GPUs.

2.8.3.Multiple GPU 2D and 3D Transforms on Permuted Input

For single 2D or 3D transforms on multiple GPUs, whencufftXtMemcpy() distributes the data to the GPUs, the array is divided on the X axis. E.G. for two GPUs half of the X dimenson points, for all Y (and Z) values, are copied to each of the GPUs. When the transform is computed, the data are permuted such that they are divided on the Y axis. I.E. half of the Y dimension points, for all X (and Z) values are on each of the GPUs.

When cuFFT creates a 2D or 3D plan for a single transform on multiple GPUs, it actually creates two plans. One plan expects input to be divided on the X axis. The other plan expects data to be divided on the Y axis. This is done because many algorithms compute a forward FFT, then perform some point-wise operation on the result, and then compute the inverse FFT. A memory copy to restore the data to the original order would be expensive. To avoid this,cufftXtMemcpy andcufftXtExecDescriptor() keep track of the data ordering so that the correct operation is used.

The ability of cuFFT to process data in either order makes the following sequence possible.

• cufftCreate() - create an empty plan, as in the single GPU case

• cufftXtSetGPUs() - define which GPUs are to be used

• cufft{Xt}MakePlan{1d,2d,3d,Many}() - create the plan.

• cufftXtMalloc() - allocate descriptor and data on the GPUs

• cufftXtMemcpy() - copy data to the GPUs

• cufftXtExecDescriptorC2C()/cufftXtExecDescriptorZ2Z() - compute the forward FFT

• userFunction() - modify the data in the frequency domain

• cufftXtExecDescriptorC2C()/cufftXtExecDescriptorZ2Z() - compute the inverse FFT

• Note that it was not necessary to copy/permute the data between execute calls

• cufftXtMemcpy() - copy data to the host

• cufftXtFree() - free any memory allocated withcufftXtMalloc()

• cufftDestroy() - free cuFFT plan resources

2.8.4.Supported Functionality

Starting with cuFFT version 7.0, a subset of single GPU functionality is supported for multiple GPU execution.

Requirements and limitations:

• All GPUs must have the same CUDA architecture level and support Unified Virtual Address Space.

• On Windows, the GPU boards must be operating in Tesla Compute Cluster (TCC) mode.

• For an application that uses the CUDA Driver API, running cuFFT on multiple GPUs is only compatible with applications using the primary context on each GPU.

• Strided input and output are not supported.

• Running cuFFT on more than 8 GPUs (16 GPUs is max) is supported on machines with NVLink only.

While transforms with batch count greater than one do not impose additional constraints, those with a single batch have some restrictions. Single-batch FFTs support only in-place mode, and have additional constraints depending on the FFT type. This behavior is summarized in the following table:

General guidelines are:

• ParameterwhichGPUs ofcufftXtSetGPUs() function determines ordering of the GPUs with respect to data decomposition (first data chunk is placed on GPU denoted by first element ofwhichGPUs)

• The data for the entire transform must fit within the memory of the GPUs assigned to it.

• For batch sizem onn GPUs :

  • The firstm%n GPUs execute\(\left\lfloor \frac{m}{n} \right\rfloor+\ 1\) transforms.

  • The remaining GPUs execute\(\left\lfloor \frac{m}{n} \right\rfloor\) transforms.

Batch size output differences:

Single GPU cuFFT results are always returned in natural order. When multiple GPUs are used to perform more than one transform, the results are also returned in natural order. When multiple GPUs are used to perform a single transform the results are returned in a permutation of the normal results to reduce communication time. This behavior is summarized in the following table:

To produce natural order results in GPU memory for multi-GPU runs in the 1D single transform case, requires callingcufftXtMemcpy() withCUFFT_COPY_DEVICE_TO_DEVICE.

2D and 3D multi-GPU transforms support execution of a transform given permuted order results as input. After execution in this case, the output will be in natural order. It is also possible to usecufftXtMemcpy() withCUFFT_COPY_DEVICE_TO_DEVICE to return 2D or 3D data to natural order.

See the cuFFT Code Examples section for single GPU and multiple GPU examples.

2.9.1.Overview of the cuFFT Callback Routine Feature

cuFFT provides a set of APIs that allow the cuFFT user to provide CUDA functions that re-direct or manipulate the data as it is loaded prior to processing the FFT, or stored once the FFT has been done. For the load callback, cuFFT calls the callback routine the address of the input data and the offset to the value to be loaded from device memory, and the callback routine returns the value it wishes cuFFT to use instead. For the store callback, cuFFT calls the callback routine the value it has computed, along with the address of the output data and the offset to the value to be written to device memory, and the callback routine modifies the value and stores the modified result.

In order to provide a callback to cuFFT, a plan is created using the extensible plan APIs. After the call tocufftCreate, the user may associate a load callback routine, or a store callback routine, or both, with the plan, by:

• CallingcufftXtSetJITCallback beforecufftMakePlan, for LTO callbacks

• CallingcufftXtSetCallback aftercufftMakePlan, for legacy callbacks

The caller also has the option to specify a device pointer to an opaque structure they wish to associate with the plan. This pointer will be passed to the callback routine by the cuFFT library. The caller may use this structure to remember plan dimensions and strides, or have a pointer to auxiliary data, etc.

With some restrictions, the callback routine is allowed to request shared memory for its own use. If the requested amount of shared memory is available, cufft will pass a pointer to it when it calls the callback routine.

CUFFT allows for 8 types of callback routines, one for each possible combination of: load or store, real or complex, single precision or double:

• For LTO callbacks, the user must provide an LTO routine that matches the function prototype for the type of routine specified. Otherwise, the planning functioncufftMakePlanwill fail.

• For legacy callbacks, it is the caller’s responsibility to provide a routine that matches the function prototype for the type of routine specified.

If there is already a callback of the specified type associated with the plan handle, the set callback functions will replace it with the new one.

The callback routine extensions to cuFFT are built on the extensible cuFFT API. The general steps in defining and executing a transform with callbacks are:

• cufftCreate() - create an empty plan, as in the single GPU case.

• (ForLTO callbacks)cufftXtSetJITCallback() - set a load and/or store LTO callback for this plan.

• cufft{Xt}MakePlan{1d,2d,3d,Many}() - create the plan. These are the same functions used in the single GPU case.

• (Forlegacy callbacks)cufftXtSetCallback() - set a load and/or store legacy callback for this plan.

• cufftExecC2C()etc. - execute the plan.

• cufftDestroy() - free cuFFT plan resources.

Callback functions are not supported on transforms with a dimension size that does not factor into primes smaller than 127. Callback functions on plans whose dimensions’ prime factors are limited to 2, 3, 5, and 7 can safely call__syncthreads(). On other plans, results are not defined.

2.9.2.LTO Load and Store Callback Routines

LTO callbacks in cuFFT for a given toolkit version require using thenvJitLink library from the same toolkit or greater, but within the same toolkit major.

Additionally, in order to specify custom names for the LTO callback routines, cuFFT requires using theNVRTC library. cuFFT uses NVRTC to compile a minimal wrapper around the user callback with custom symbol name. The custom symbol name provided to the cuFFT API must be a valid, null-terminated C-string containing the unmangled name; currently, keywords that alter the scope of the symbol name (such asnamespace) or the mangling (such asextern"C") are not supported.

The NVRTC library used must be from a toolkit that is either the same version or older than the nvJitLink library, and both must be from the same toolkit major.

For example, in toolkit version 12.6 cuFFT requires nvJitLink to be from toolkit version 12.X, whereX>=6, and NVRTC to be from toolkit version 12.Y, where0<=Y<=X.

Both the nvJitLink and the NVRTC libraries are loaded dynamically, and should be present in the system’s dynamic linking path (e.g.LD_LIBRARY_PATH on Unix systems, orPATH on Windows systems).

Code samples for LTO callbacks are available in the publicCUDA Library Samples github repository.

__device__cufftRealmyOwnLTOCallback(void*dataIn,unsignedlonglongoffset,void*callerInfo,void*sharedPtr){cufftRealret;// use offset, dataIn, and optionally callerInfo to// compute the return valuereturnret;}

# Compile the code to SM70 LTO-IR into a fatbin filenvcc-gencode=arch=compute_75,code=lto_75-dc-fatbincallback.cu-ocallback.fatbin#Turn the fatbin data into a C array inside a header, for easy inclusion in host codebin2c--namemy_lto_callback_fatbin--typelonglongcallback.fatbin>callback_fatbin.h

#include<cufftXt.h>#include"callback_fatbin.h"intmain(){cufftResultstatus;cufftHandlefft_plan;...status=cufftCreate(&fft_plan);// NOTE: LTO callbacks must be set before plan creation and cannot be unset (yet)size_tlto_callback_fatbin_size=sizeof(my_lto_callback_fatbin);status=cufftXtSetJITCallback(fft_plan,"myOwnLTOCallback",(void*)my_lto_callback_fatbin,lto_callback_fatbin_size,CUFFT_CB_LD_REAL,(void**)&device_params));status=cufftMakePlan1d(fft_plan,signal_size,CUFFT_C2R,batches,&work_size);...}

typedefcufftComplex(*cufftJITCallbackLoadC)(void*dataIn,unsignedlonglongoffset,void*callerInfo,void*sharedPointer);typedefcufftDoubleComplex(*cufftJITCallbackLoadZ)(void*dataIn,unsignedlonglongoffset,void*callerInfo,void*sharedPointer);typedefcufftReal(*cufftJITCallbackLoadR)(void*dataIn,unsignedlonglongoffset,void*callerInfo,void*sharedPointer);typedefcufftDoubleReal(*cufftJITCallbackLoadD)(void*dataIn,unsignedlonglongoffset,void*callerInfo,void*sharedPointer);

typedefvoid(*cufftJITCallbackStoreC)(void*dataOut,unsignedlonglongoffset,cufftComplexelement,void*callerInfo,void*sharedPointer);typedefvoid(*cufftJITCallbackStoreZ)(void*dataOut,unsignedlonglongoffset,cufftDoubleComplexelement,void*callerInfo,void*sharedPointer);typedefvoid(*cufftJITCallbackStoreR)(void*dataOut,unsignedlonglongoffset,cufftRealelement,void*callerInfo,void*sharedPointer);typedefvoid(*cufftJITCallbackStoreD)(void*dataOut,unsignedlonglongoffset,cufftDoubleRealelement,void*callerInfo,void*sharedPointer);

2.9.3.Legacy Load and Store Callback Routines

__device__cufftRealmyOwnCallback(void*dataIn,size_toffset,void*callerInfo,void*sharedPtr){cufftRealret;// use offset, dataIn, and optionally callerInfo to// compute the return valuereturnret;}__device__cufftCallbackLoadRmyOwnCallbackPtr=myOwnCallback;

cufftCallbackLoadRhostCopyOfCallbackPtr;cudaMemcpyFromSymbol(&hostCopyOfCallbackPtr,myOwnCallbackPtr,sizeof(hostCopyOfCallbackPtr));

typedefcufftComplex(*cufftCallbackLoadC)(void*dataIn,size_toffset,void*callerInfo,void*sharedPointer);typedefcufftDoubleComplex(*cufftCallbackLoadZ)(void*dataIn,size_toffset,void*callerInfo,void*sharedPointer);typedefcufftReal(*cufftCallbackLoadR)(void*dataIn,size_toffset,void*callerInfo,void*sharedPointer);typedefcufftDoubleReal(*cufftCallbackLoadD)(void*dataIn,size_toffset,void*callerInfo,void*sharedPointer);

typedefvoid(*cufftCallbackStoreC)(void*dataOut,size_toffset,cufftComplexelement,void*callerInfo,void*sharedPointer);typedefvoid(*cufftCallbackStoreZ)(void*dataOut,size_toffset,cufftDoubleComplexelement,void*callerInfo,void*sharedPointer);typedefvoid(*cufftCallbackStoreR)(void*dataOut,size_toffset,cufftRealelement,void*callerInfo,void*sharedPointer);typedefvoid(*cufftCallbackStoreD)(void*dataOut,size_toffset,cufftDoubleRealelement,void*callerInfo,void*sharedPointer);

2.9.4.Coding Considerations for the cuFFT Callback Routine Feature

cuFFT supports callbacks on all types of transforms, dimension, batch, or stride between elements. Callbacks are supported for transforms of single and double precision.

cuFFT supports a wide range of parameters, and based on those for a given plan, it attempts to optimize performance. The number of kernels launched, and for each of those, the number of blocks launched and the number of threads per block, will vary depending on how cuFFT decomposes the transform. For some configurations, cuFFT will load or store (and process) multiple inputs or outputs per thread. For some configurations, threads may load or store inputs or outputs in any order, and cuFFT does not guarantee that the inputs or outputs handled by a given thread will be contiguous. These characteristics may vary with transform size, transform type (e.g. C2C vs C2R), number of dimensions, and GPU architecture. These variations may also change from one library version to the next.

When more than one kernel are used to implement a transform, the thread and block structure of the first kernel (the one that does the load) is often different from the thread and block structure of the last kernel (the one that does the store).

One common use of callbacks is to reduce the amount of data read or written to memory, either by selective filtering or via type conversions. When more than one kernel are used to implement a transform, cuFFT alternates using the workspace and the output buffer to write intermediate results. This means that the output buffer must always be large enough to accommodate the entire transform.

For transforms whose dimensions can be factored into powers of 2, 3, 5, or 7, cuFFT guarantees that it will call the load and store callback routines from points in the kernel where it is safe to call the__syncthreads function from within the callback routine. The caller is responsible for guaranteeing that the callback routine is at a point where the callback code has converged, to avoid deadlock. For plans whose dimensions are factored into higher primes, results of a callback routine calling__syncthreads are not defined.

Note that there are no guarantees on the relative order of execution of blocks within a grid. As such, callbacks should not rely on any particular ordering within a kernel. For instance, reordering data (such as an FFT-shift) could rely on the order of execution of the blocks. Results in this case would be undefined.

3.2.1.cufftPlan1d()

cufftResultcufftPlan1d(cufftHandle*plan,intnx,cufftTypetype,intbatch);

Creates a 1D FFT plan configuration for a specified signal size and data type. Thebatch input parameter tells cuFFT how many 1D transforms to configure.

This call can only be used once for a given handle. It will fail and returnCUFFT_INVALID_PLAN if the plan is locked, i.e. the handle was previously used with a differentcufftPlan orcufftMakePlan call.

Parameters

• plan[In] – Pointer to an uninitializedcufftHandle object.

• nx[In] – The transform size (e.g. 256 for a 256-point FFT).

• type[In] – The transform data type (e.g.,CUFFT_C2C for single precision complex to complex).

• batch[In] – Number of transforms of sizenx. Please consider usingcufftPlanMany for multiple transforms.

• plan[Out] – Contains a cuFFT 1D plan handle value.

Return values

• CUFFT_SUCCESS – cuFFT successfully created the FFT plan.

• CUFFT_INVALID_PLAN – Theplan parameter is not a valid handle. Handle is not valid when the plan is locked.

• CUFFT_ALLOC_FAILED – The allocation of GPU resources for the plan failed.

• CUFFT_INVALID_VALUE – One or more invalid parameters were passed to the API.

• CUFFT_INTERNAL_ERROR – An internal driver error was detected.

• CUFFT_SETUP_FAILED – The cuFFT library failed to initialize.

• CUFFT_INVALID_SIZE – Thenx orbatch parameter is not a supported size.

• CUFFT_MISSING_DEPENDENCY – The cuFFT library was unable to find a dependency either because it is missing or the version found is incompatible

• CUFFT_NVRTC_FAILURE – NVRTC encountered an error during planning

• CUFFT_NVJITLINK_FAILURE – nvJitLink encountered an error during planning

3.2.2.cufftPlan2d()

cufftResultcufftPlan2d(cufftHandle*plan,intnx,intny,cufftTypetype);

Creates a 2D FFT plan configuration according to specified signal sizes and data type.

This call can only be used once for a given handle. It will fail and returnCUFFT_INVALID_PLAN if the plan is locked, i.e. the handle was previously used with a differentcufftPlan orcufftMakePlan call.

Parameters

• plan[In] – Pointer to an uninitializedcufftHandle object.

• nx[In] – The transform size in thex dimension This is slowest changing dimension of a transform (strided in memory).

• ny[In] – The transform size in they dimension. This is fastest changing dimension of a transform (contiguous in memory).

• type[In] – The transform data type (e.g.,CUFFT_C2R for single precision complex to real).

• plan[Out] – Contains a cuFFT 2D plan handle value.

Return values

• CUFFT_SUCCESS – cuFFT successfully created the FFT plan.

• CUFFT_INVALID_PLAN – Theplan parameter is not a valid handle. Handle is not valid when the plan is locked.

• CUFFT_ALLOC_FAILED – The allocation of GPU resources for the plan failed.

• CUFFT_INVALID_VALUE – One or more invalid parameters were passed to the API.

• CUFFT_INTERNAL_ERROR – An internal driver error was detected.

• CUFFT_SETUP_FAILED – The cuFFT library failed to initialize.

• CUFFT_INVALID_SIZE – Either or both of thenx orny parameters is not a supported size.

• CUFFT_MISSING_DEPENDENCY – The cuFFT library was unable to find a dependency either because it is missing or the version found is incompatible

• CUFFT_NVRTC_FAILURE – NVRTC encountered an error during planning

• CUFFT_NVJITLINK_FAILURE – nvJitLink encountered an error during planning

3.2.3.cufftPlan3d()

cufftResultcufftPlan3d(cufftHandle*plan,intnx,intny,intnz,cufftTypetype);

Creates a 3D FFT plan configuration according to specified signal sizes and data type. This function is the same ascufftPlan2d() except that it takes a third size parameternz.

This call can only be used once for a given handle. It will fail and returnCUFFT_INVALID_PLAN if the plan is locked, i.e. the handle was previously used with a differentcufftPlan orcufftMakePlan call.

Parameters

• plan[In] – Pointer to an uninitializedcufftHandle object.

• nx[In] – The transform size in thex dimension. This is slowest changing dimension of a transform (strided in memory).

• ny[In] – The transform size in they dimension.

• nz[In] – The transform size in thez dimension. This is fastest changing dimension of a transform (contiguous in memory).

• type[In] – The transform data type (e.g.,CUFFT_R2C for single precision real to complex).

• plan[Out] – Contains a cuFFT 3D plan handle value.

Return values

• CUFFT_SUCCESS – cuFFT successfully created the FFT plan.

• CUFFT_INVALID_PLAN – Theplan parameter is not a valid handle. Handle is not valid when the plan is locked.

• CUFFT_ALLOC_FAILED – The allocation of GPU resources for the plan failed.

• CUFFT_INVALID_VALUE – One or more invalid parameters were passed to the API.

• CUFFT_INTERNAL_ERROR – An internal driver error was detected.

• CUFFT_SETUP_FAILED – The cuFFT library failed to initialize.

• CUFFT_INVALID_SIZE – One or more of thenx,ny, ornz parameters is not a supported size.

• CUFFT_MISSING_DEPENDENCY – The cuFFT library was unable to find a dependency either because it is missing or the version found is incompatible

• CUFFT_NVRTC_FAILURE – NVRTC encountered an error during planning

• CUFFT_NVJITLINK_FAILURE – nvJitLink encountered an error during planning

3.2.4.cufftPlanMany()

cufftResultcufftPlanMany(cufftHandle*plan,intrank,int*n,int*inembed,intistride,intidist,int*onembed,intostride,intodist,cufftTypetype,intbatch);

Creates a FFT plan configuration of dimensionrank, with sizes specified in the arrayn. Thebatch input parameter tells cuFFT how many transforms to configure. With this function, batched plans of 1, 2, or 3 dimensions may be created.

ThecufftPlanMany() API supports more complicated input and output data layouts via the advanced data layout parameters:inembed,istride,idist,onembed,ostride, andodist.

Ifinembed andonembed are set toNULL, all other stride information is ignored, and default strides are used. The default assumes contiguous data arrays.

All arrays are assumed to be in CPU memory.

Please note that behavior ofcufftPlanMany function wheninembed andonembed isNULL is different than corresponding function in FFTW libraryfftw_plan_many_dft.

This call can only be used once for a given handle. It will fail and returnCUFFT_INVALID_PLAN if the plan is locked, i.e. the handle was previously used with a differentcufftPlan orcufftMakePlan call.

Parameters

• plan[In] – Pointer to an uninitializedcufftHandle object.

• rank[In] – Dimensionality of the transform (1, 2, or 3).

• n[In] – Array of sizerank, describing the size of each dimension,n[0] being the size of the outermost andn[rank-1] innermost (contiguous) dimension of a transform.

• inembed[In] – Pointer of sizerank that indicates the storage dimensions of the input data in memory. If set to NULL all other advanced data layout parameters are ignored.

• istride[In] – Indicates the distance between two successive input elements in the least significant (i.e., innermost) dimension.

• idist[In] – Indicates the distance between the first element of two consecutive signals in a batch of the input data.

• onembed[In] – Pointer of sizerank that indicates the storage dimensions of the output data in memory. If set to NULL all other advanced data layout parameters are ignored.

• ostride[In] – Indicates the distance between two successive output elements in the output array in the least significant (i.e., innermost) dimension.

• odist[In] – Indicates the distance between the first element of two consecutive signals in a batch of the output data.

• type[In] – The transform data type (e.g.,CUFFT_R2C for single precision real to complex).

• batch[In] – Batch size for this transform.

• plan[Out] – Contains a cuFFT plan handle.

Return values

• CUFFT_SUCCESS – cuFFT successfully created the FFT plan.

• CUFFT_INVALID_PLAN – Theplan parameter is not a valid handle. Handle is not valid when the plan is locked.

• CUFFT_ALLOC_FAILED – The allocation of GPU resources for the plan failed.

• CUFFT_INVALID_VALUE – One or more invalid parameters were passed to the API.

• CUFFT_INTERNAL_ERROR – An internal driver error was detected.

• CUFFT_SETUP_FAILED – The cuFFT library failed to initialize.

• CUFFT_INVALID_SIZE – One or more of the parameters is not a supported size.

• CUFFT_MISSING_DEPENDENCY – The cuFFT library was unable to find a dependency either because it is missing or the version found is incompatible

• CUFFT_NVRTC_FAILURE – NVRTC encountered an error during planning

• CUFFT_NVJITLINK_FAILURE – nvJitLink encountered an error during planning

3.3.1.cufftCreate()

cufftResultcufftCreate(cufftHandle*plan)

Creates only an opaque handle, and allocates small data structures on the host. ThecufftMakePlan*() calls actually do the plan generation.

Parameters

• plan[In] – Pointer to acufftHandle object.

• plan[Out] – Contains a cuFFT plan handle value.

Return values

• CUFFT_SUCCESS – cuFFT successfully created the FFT plan.

• CUFFT_ALLOC_FAILED – The allocation of resources for the plan failed.

• CUFFT_INVALID_VALUE – One or more invalid parameters were passed to the API.

• CUFFT_INTERNAL_ERROR – An internal driver error was detected.

• CUFFT_SETUP_FAILED – The cuFFT library failed to initialize.

3.3.2.cufftDestroy()

cufftResultcufftDestroy(cufftHandleplan)

Frees all GPU resources associated with a cuFFT plan and destroys the internal plan data structure. This function should be called once a plan is no longer needed, to avoid wasting GPU memory.In the case of multi-GPU plans, the plan created first should be destroyed last.

Parameters

• plan[In] – ThecufftHandle object of the plan to be destroyed.

Return values

• CUFFT_SUCCESS – cuFFT successfully destroyed the FFT plan.

• CUFFT_INVALID_PLAN – Theplan parameter is not a valid handle.

3.3.3.cufftMakePlan1d()

cufftResultcufftMakePlan1d(cufftHandleplan,intnx,cufftTypetype,intbatch,size_t*workSize);

Following a call tocufftCreate() makes a 1D FFT plan configuration for a specified signal size and data type. Thebatch input parameter tells cuFFT how many 1D transforms to configure.

This call can only be used once for a given handle. It will fail and returnCUFFT_INVALID_PLAN if the plan is locked, i.e. the handle was previously used with a differentcufftPlan orcufftMakePlan call.

IfcufftXtSetGPUs() was called prior to this call with multiple GPUs, thenworkSize will contain multiple sizes. See sections on multiple GPUs for more details.

Parameters

• plan[In] –cufftHandle returned bycufftCreate.

• nx[In] – The transform size (e.g. 256 for a 256-point FFT). For multiple GPUs, this must be a power of 2.

• type[In] – The transform data type (e.g.,CUFFT_C2C for single precision complex to complex). For multiple GPUs this must be a complex to complex transform.

• batch[In] – Number of transforms of sizenx. Please consider usingcufftMakePlanMany for multiple transforms.

• *workSize[In] – Pointer to the size(s), in bytes, of the work areas. For example for two GPUs worksize must be declared to have two elements.

• *workSize[Out] – Pointer to the size(s) of the work areas.

Return values

• CUFFT_SUCCESS – cuFFT successfully created the FFT plan.

• CUFFT_INVALID_PLAN – Theplan parameter is not a valid handle. Handle is not valid when the plan is locked or multi-GPU restrictions are not met.

• CUFFT_ALLOC_FAILED – The allocation of GPU resources for the plan failed.

• CUFFT_INVALID_VALUE – One or more invalid parameters were passed to the API.

• CUFFT_INTERNAL_ERROR – An internal driver error was detected.

• CUFFT_SETUP_FAILED` – The cuFFT library failed to initialize.

• CUFFT_INVALID_SIZE – Thenx orbatch parameter is not a supported size.

• CUFFT_MISSING_DEPENDENCY – The cuFFT library was unable to find a dependency either because it is missing or the version found is incompatible

• CUFFT_NVRTC_FAILURE – NVRTC encountered an error during planning

• CUFFT_NVJITLINK_FAILURE – nvJitLink encountered an error during planning

3.3.4.cufftMakePlan2d()

cufftResultcufftMakePlan2d(cufftHandleplan,intnx,intny,cufftTypetype,size_t*workSize);

Following a call tocufftCreate() makes a 2D FFT plan configuration according to specified signal sizes and data type.

This call can only be used once for a given handle. It will fail and returnCUFFT_INVALID_PLAN if the plan is locked, i.e. the handle was previously used with a differentcufftPlan orcufftMakePlan call.

IfcufftXtSetGPUs() was called prior to this call with multiple GPUs, thenworkSize will contain multiple sizes. See sections on multiple GPUs for more details.

Parameters

• plan[In] –cufftHandle returned bycufftCreate.

• nx[In] – The transform size in thex dimension. This is slowest changing dimension of a transform (strided in memory). For multiple GPUs, this must be factorable into primes less than or equal to 127.

• ny[In] – The transform size in they dimension. This is fastest changing dimension of a transform (contiguous in memory). For 2 GPUs, this must be factorable into primes less than or equal to 127.

• type[In] – The transform data type (e.g.,CUFFT_C2R for single precision complex to real).

• workSize[In] – Pointer to the size(s), in bytes, of the work areas. For example for two GPUs worksize must be declared to have two elements.

• *workSize[Out] – Pointer to the size(s) of the work areas.

Return values

• CUFFT_SUCCESS – cuFFT successfully created the FFT plan.

• CUFFT_INVALID_PLAN – Theplan parameter is not a valid handle.

• CUFFT_ALLOC_FAILED – The allocation of GPU resources for the plan failed.

• CUFFT_INVALID_VALUE – One or more invalid parameters were passed to the API.

• CUFFT_INTERNAL_ERROR – An internal driver error was detected.

• CUFFT_SETUP_FAILED – The cuFFT library failed to initialize.

• CUFFT_INVALID_SIZE – Either or both of thenx orny parameters is not a supported size.

• CUFFT_MISSING_DEPENDENCY – The cuFFT library was unable to find a dependency either because it is missing or the version found is incompatible

• CUFFT_NVRTC_FAILURE – NVRTC encountered an error during planning

• CUFFT_NVJITLINK_FAILURE – nvJitLink encountered an error during planning

3.3.5.cufftMakePlan3d()

cufftResultcufftMakePlan3d(cufftHandleplan,intnx,intny,intnz,cufftTypetype,size_t*workSize);

Following a call tocufftCreate() makes a 3D FFT plan configuration according to specified signal sizes and data type. This function is the same ascufftPlan2d() except that it takes a third size parameternz.

This call can only be used once for a given handle. It will fail and returnCUFFT_INVALID_PLAN if the plan is locked, i.e. the handle was previously used with a differentcufftPlan orcufftMakePlan call.

IfcufftXtSetGPUs() was called prior to this call with multiple GPUs, thenworkSize will contain multiple sizes. See sections on multiple GPUs for more details.

Parameters

• plan[In] –cufftHandle returned bycufftCreate.

• nx[In] – The transform size in thex dimension. This is slowest changing dimension of a transform (strided in memory). For multiple GPUs, this must be factorable into primes less than or equal to 127.

• ny[In] – The transform size in they dimension. For multiple GPUs, this must be factorable into primes less than or equal to 127.

• nz[In] – The transform size in thez dimension. This is fastest changing dimension of a transform (contiguous in memory). For multiple GPUs, this must be factorable into primes less than or equal to 127.

• type[In] – The transform data type (e.g.,CUFFT_R2C for single precision real to complex).

• workSize[In] – Pointer to the size(s), in bytes, of the work areas. For example for two GPUs worksize must be declared to have two elements.

• *workSize[Out] – Pointer to the size(s) of the work area(s).

Return values

• CUFFT_SUCCESS – cuFFT successfully created the FFT plan.

• CUFFT_INVALID_PLAN – Theplan parameter is not a valid handle.

• CUFFT_ALLOC_FAILED – The allocation of GPU resources for the plan failed.

• CUFFT_INVALID_VALUE – One or more invalid parameters were passed to the API.

• CUFFT_INTERNAL_ERROR – An internal driver error was detected.

• CUFFT_SETUP_FAILED – The cuFFT library failed to initialize.

• CUFFT_INVALID_SIZE – One or more of thenx,ny, ornz parameters is not a supported size.

• CUFFT_MISSING_DEPENDENCY – The cuFFT library was unable to find a dependency either because it is missing or the version found is incompatible

• CUFFT_NVRTC_FAILURE – NVRTC encountered an error during planning

• CUFFT_NVJITLINK_FAILURE – nvJitLink encountered an error during planning

3.3.6.cufftMakePlanMany()

cufftResultcufftMakePlanMany(cufftHandleplan,intrank,int*n,int*inembed,intistride,intidist,int*onembed,intostride,intodist,cufftTypetype,intbatch,size_t*workSize);

Following a call tocufftCreate() makes a FFT plan configuration of dimensionrank, with sizes specified in the arrayn. Thebatch input parameter tells cuFFT how many transforms to configure. With this function, batched plans of 1, 2, or 3 dimensions may be created.

ThecufftPlanMany() API supports more complicated input and output data layouts via the advanced data layout parameters:inembed,istride,idist,onembed,ostride, andodist.

Ifinembed andonembed are set toNULL, all other stride information is ignored, and default strides are used. The default assumes contiguous data arrays.

This call can only be used once for a given handle. It will fail and returnCUFFT_INVALID_PLAN if the plan is locked, i.e. the handle was previously used with a differentcufftPlan orcufftMakePlan call.

IfcufftXtSetGPUs() was called prior to this call with multiple GPUs, thenworkSize will contain multiple sizes. See sections on multiple GPUs for more details.

All arrays are assumed to be in CPU memory.

Parameters

• plan[In] –cufftHandle returned bycufftCreate.

• rank[In] – Dimensionality of the transform (1, 2, or 3)

• n[In] – Array of sizerank, describing the size of each dimension,n[0] being the size of the outermost andn[rank-1] innermost (contiguous) dimension of a transform. For multiple GPUs and rank equal to 1, the sizes must be a power of 2. For multiple GPUs and rank equal to 2 or 3, the sizes must be factorable into primes less than or equal to 127.

• inembed[In] – Pointer of sizerank that indicates the storage dimensions of the input data in memory,inembed[0] being the storage dimension of the outermost dimension. If set to NULL all other advanced data layout parameters are ignored.

• istride[In] – Indicates the distance between two successive input elements in the least significant (i.e., innermost) dimension

• idist[In] – Indicates the distance between the first element of two consecutive signals in a batch of the input data

• onembed[In] – Pointer of sizerank that indicates the storage dimensions of the output data in memory,onembed[0] being the storage dimension of the outermost dimension. If set to NULL all other advanced data layout parameters are ignored.

• ostride[In] – Indicates the distance between two successive output elements in the output array in the least significant (i.e., innermost) dimension

• odist[In] – Indicates the distance between the first element of two consecutive signals in a batch of the output data

• type[In] – The transform data type (e.g.,CUFFT_R2C for single precision real to complex). For 2 GPUs this must be a complex to complex transform.

• batch[In] – Batch size for this transform.

• *workSize[In] – Pointer to the size(s), in bytes, of the work areas. For example for two GPUs worksize must be declared to have two elements.

• *workSize[Out] – Pointer to the size(s) of the work areas.

Return values

• CUFFT_SUCCESS – cuFFT successfully created the FFT plan.

• CUFFT_INVALID_PLAN – Theplan parameter is not a valid handle. Handle is not valid when the plan is locked or multi-GPU restrictions are not met.

• CUFFT_ALLOC_FAILED – The allocation of GPU resources for the plan failed.

• CUFFT_INVALID_VALUE – One or more invalid parameters were passed to the API.

• CUFFT_INTERNAL_ERROR – An internal driver error was detected.

• CUFFT_SETUP_FAILED – The cuFFT library failed to initialize.

• CUFFT_INVALID_SIZE – One or more of the parameters is not a supported size.

• CUFFT_MISSING_DEPENDENCY – The cuFFT library was unable to find a dependency either because it is missing or the version found is incompatible

• CUFFT_NVRTC_FAILURE – NVRTC encountered an error during planning

• CUFFT_NVJITLINK_FAILURE – nvJitLink encountered an error during planning

3.3.7.cufftMakePlanMany64()

cufftResultcufftMakePlanMany64(cufftHandleplan,intrank,longlongint*n,longlongint*inembed,longlongintistride,longlongintidist,longlongint*onembed,longlongintostride,longlongintodist,cufftTypetype,longlongintbatch,size_t*workSize);

Following a call tocufftCreate() makes a FFT plan configuration of dimensionrank, with sizes specified in the arrayn. Thebatch input parameter tells cuFFT how many transforms to configure. With this function, batched plans of 1, 2, or 3 dimensions may be created.

This API is identical tocufftMakePlanMany except that the arguments specifying sizes and strides are 64 bit integers. This API makes very large transforms possible. cuFFT includes kernels that use 32 bit indexes, and kernels that use 64 bit indexes. cuFFT planning selects 32 bit kernels whenever possible to avoid any overhead due to 64 bit arithmetic.

All sizes and types of transform are supported by this interface, with two exceptions. For transforms whose size exceeds 4G elements, the dimensions specified in the arrayn must be factorable into primes that are less than or equal to 127. For real to complex and complex to real transforms whose size exceeds 4G elements, the fastest changing dimension must be even.

ThecufftPlanMany64() API supports more complicated input and output data layouts via the advanced data layout parameters:inembed,istride,idist,onembed,ostride, andodist.

Ifinembed andonembed are set toNULL, all other stride information is ignored, and default strides are used. The default assumes contiguous data arrays.

This call can only be used once for a given handle. It will fail and returnCUFFT_INVALID_PLAN if the plan is locked, i.e. the handle was previously used with a differentcufftPlan orcufftMakePlan call.

IfcufftXtSetGPUs() was called prior to this call with multiple GPUs, thenworkSize will contain multiple sizes. See sections on multiple GPUs for more details.

All arrays are assumed to be in CPU memory.

Parameters

• plan[In] –cufftHandle returned bycufftCreate.

• rank[In] – Dimensionality of the transform (1, 2, or 3).

• n[In] – Array of sizerank, describing the size of each dimension. For multiple GPUs and rank equal to 1, the sizes must be a power of 2. For multiple GPUs and rank equal to 2 or 3, the sizes must be factorable into primes less than or equal to 127.

• inembed[In] – Pointer of sizerank that indicates the storage dimensions of the input data in memory. If set to NULL all other advanced data layout parameters are ignored.

• istride[In] – Indicates the distance between two successive input elements in the least significant (i.e., innermost) dimension.

• idist[In] – Indicates the distance between the first element of two consecutive signals in a batch of the input data.

• onembed[In] – Pointer of sizerank that indicates the storage dimensions of the output data in memory. If set to NULL all other advanced data layout parameters are ignored.

• ostride[In] – Indicates the distance between two successive output elements in the output array in the least significant (i.e., innermost) dimension.

• odist[In] – Indicates the distance between the first element of two consecutive signals in a batch of the output data.

• type[In] – The transform data type (e.g.,CUFFT_R2C for single precision real to complex). For 2 GPUs this must be a complex to complex transform.

• batch[In] – Batch size for this transform.

• *workSize[In] – Pointer to the size(s), in bytes, of the work areas. For example for two GPUs worksize must be declared to have two elements.

• *workSize[Out] – Pointer to the size(s) of the work areas.

Return values

• CUFFT_SUCCESS – cuFFT successfully created the FFT plan.

• CUFFT_INVALID_PLAN – Theplan parameter is not a valid handle. Handle is not valid when the plan is locked or multi-GPU restrictions are not met.

• CUFFT_ALLOC_FAILED – The allocation of GPU resources for the plan failed.

• CUFFT_INVALID_VALUE – One or more invalid parameters were passed to the API.

• CUFFT_INTERNAL_ERROR – An internal driver error was detected.

• CUFFT_SETUP_FAILED – The cuFFT library failed to initialize.

• CUFFT_INVALID_SIZE – One or more of the parameters is not a supported size.

• CUFFT_MISSING_DEPENDENCY – The cuFFT library was unable to find a dependency either because it is missing or the version found is incompatible

• CUFFT_NVRTC_FAILURE – NVRTC encountered an error during planning

• CUFFT_NVJITLINK_FAILURE – nvJitLink encountered an error during planning

3.3.8.cufftXtMakePlanMany()

cufftResultcufftXtMakePlanMany(cufftHandleplan,intrank,longlongint*n,longlongint*inembed,longlongintistride,longlongintidist,cudaDataTypeinputtype,longlongint*onembed,longlongintostride,longlongintodist,cudaDataTypeoutputtype,longlongintbatch,size_t*workSize,cudaDataTypeexecutiontype);

Following a call tocufftCreate() makes an FFT plan configuration of dimensionrank, with sizes specified in the arrayn. Thebatch input parameter tells cuFFT how many transforms to configure. With this function, batched plans of 1, 2, or 3 dimensions may be created.

Type specifiersinputtype,outputtype andexecutiontype dictate type and precision of transform to be performed. Not all combinations of parameters are supported. Currently all three parameters need to match precision. Parametersinputtype andoutputtype need to match transform type complex-to-complex, real-to-complex or complex-to-real. Parameterexecutiontype needs to match precision and be of a complex type. Example: for a half-precision real-to-complex transform, parametersinputtype,outputtype andexecutiontype would have values ofCUDA_R_16F,CUDA_C_16F andCUDA_C_16F respectively. Similarly, a bfloat16 complex-to-real transform would useCUDA_C_16BF forinputtype andexecutiontype, andCUDA_R_16BF foroutputtype.

ThecufftXtMakePlanMany() API supports more complicated input and output data layouts via the advanced data layout parameters:inembed,istride,idist,onembed,ostride, andodist.

Ifinembed andonembed are set toNULL, all other stride information is ignored, and default strides are used. The default assumes contiguous data arrays.

IfcufftXtSetGPUs() was called prior to this call with multiple GPUs, thenworkSize will contain multiple sizes. See sections on multiple GPUs for more details.

All arrays are assumed to be in CPU memory.

Parameters

• plan[In] –cufftHandle returned bycufftCreate.

• rank[In] – Dimensionality of the transform (1, 2, or 3).

• n[In] – Array of sizerank, describing the size of each dimension,n[0] being the size of the outermost andn[rank-1] innermost (contiguous) dimension of a transform. For multiple GPUs and rank equal to 1, the sizes must be a power of 2. For multiple GPUs and rank equal to 2 or 3, the sizes must be factorable into primes less than or equal to 127.

• inembed[In] – Pointer of sizerank that indicates the storage dimensions of the input data in memory,inembed[0] being the storage dimension of the outermost dimension. If set to NULL all other advanced data layout parameters are ignored.

• istride[In] – Indicates the distance between two successive input elements in the least significant (i.e., innermost) dimension.

• idist[In] – Indicates the distance between the first element of two consecutive signals in a batch of the input data.

• inputtype[In] – Type of input data.

• onembed[In] – Pointer of sizerank that indicates the storage dimensions of the output data in memory,onembed[0] being the storage dimension of the outermost dimension. If set to NULL all other advanced data layout parameters are ignored.

• ostride[In] – Indicates the distance between two successive output elements in the output array in the least significant (i.e., innermost) dimension.

• odist[In] – Indicates the distance between the first element of two consecutive signals in a batch of the output data.

• outputtype[In] – Type of output data.

• batch[In] – Batch size for this transform.

• *workSize[In] – Pointer to the size(s), in bytes, of the work areas. For example for two GPUs worksize must be declared to have two elements.

• executiontype[In] – Type of data to be used for computations.

• *workSize[Out] – Pointer to the size(s) of the work areas.

Return values

• CUFFT_SUCCESS – cuFFT successfully created the FFT plan.

• CUFFT_INVALID_PLAN – Theplan parameter is not a valid handle. Handle is not valid when multi-GPU restrictions are not met.

• CUFFT_ALLOC_FAILED – The allocation of GPU resources for the plan failed.

• CUFFT_INVALID_VALUE – One or more invalid parameters were passed to the API.

• CUFFT_INTERNAL_ERROR – An internal driver error was detected.

• CUFFT_SETUP_FAILED – The cuFFT library failed to initialize.

• CUFFT_INVALID_SIZE – One or more of the parameters is not a supported size.

• CUFFT_MISSING_DEPENDENCY – The cuFFT library was unable to find a dependency either because it is missing or the version found is incompatible

• CUFFT_NVRTC_FAILURE – NVRTC encountered an error during planning

• CUFFT_NVJITLINK_FAILURE – nvJitLink encountered an error during planning

3.4.1.cufftSetPlanPropertyInt64()

cufftResultcufftSetPlanPropertyInt64(cufftHandleplan,cufftPropertyproperty,constlonglongintpropertyValueInt64);

Associates a cuFFT plan with a property identified by the keyproperty. The value for the property is given by valuepropertyValueInt64, which is a signed long long integer.

Parameters

• plan[In] –cufftHandle returned bycufftCreate.

• property[In] – The property identifier, of typecufftPlanProperty.

• propertyValueInt64[In] – Value to set for the property, a long long signed integer.

Return values

• CUFFT_SUCCESS – cuFFT successfully set the property.

• CUFFT_INVALID_PLAN – Theplan parameter is not a valid handle.

• CUFFT_NOT_SUPPORTED – The property is not supported, or it cannot be set at the time (e.g. some properties cannot be set after calling a planning routine for the plan, seecuFFT Plan Properties).

• CUFFT_INVALID_VALUE – Invalid property or value with which to set the property

3.4.2.cufftGetPlanPropertyInt64()

cufftResultcufftGetPlanPropertyInt64(cufftHandleplan,cufftPropertyproperty,longlongint*propertyValueInt64);

Retrieves the property value identified by the keyproperty associated with the cuFFT planplan. The value for the property, which is a signed long long integer, is set in the address space pointed bypropertyValueInt64.

Parameters

• plan[In] –cufftHandle returned bycufftCreate.

• property[In] – The property identifier, of typecufftPlanProperty.

• propertyValueInt64[In] – Pointer to the value to be set with the value of the property.

Return values

• CUFFT_SUCCESS – cuFFT successfully retrieved the property value.

• CUFFT_INVALID_PLAN – Theplan parameter is not a valid handle.

• CUFFT_NOT_SUPPORTED – The property is not supported.

• CUFFT_INVALID_VALUE – Invalid property, or pointerpropertyValueInt64 is null

3.4.3.cufftResetPlanProperty()

cufftResultcufftResetPlanProperty(cufftHandleplan,cufftPropertyproperty);

Resets the value of the property identified by the keyproperty, associated with the cuFFT planplan, to its default value.

Parameters

• plan[In] –cufftHandle returned bycufftCreate.

• property[In] – The property identifier, of typecufftPlanProperty.

Return values

• CUFFT_SUCCESS – cuFFT successfully reset the property value.

• CUFFT_INVALID_PLAN – Theplan parameter is not a valid handle.

• CUFFT_NOT_SUPPORTED – The property is not supported forplan, or cannot be reset at present time (see Behavior column oncuFFT Plan Properties).

• CUFFT_INVALID_VALUE – Invalid property

3.5.1.cufftEstimate1d()

cufftResultcufftEstimate1d(intnx,cufftTypetype,intbatch,size_t*workSize);

During plan execution, cuFFT requires a work area for temporary storage of intermediate results. This call returns an estimate for the size of the work area required, given the specified parameters, and assuming default plan settings.

Parameters

• nx[In] – The transform size (e.g. 256 for a 256-point FFT).

• type[In] – The transform data type (e.g.,CUFFT_C2C for single precision complex to complex).

• batch[In] – Number of transforms of sizenx. Please consider usingcufftEstimateMany for multiple transforms.

• *workSize[In] – Pointer to the size, in bytes, of the work space.

• *workSize[Out] – Pointer to the size of the work space.

Return values

• CUFFT_SUCCESS – cuFFT successfully returned the size of the work space.

• CUFFT_ALLOC_FAILED – The allocation of GPU resources for the plan failed.

• CUFFT_INVALID_VALUE – One or more invalid parameters were passed to the API.

• CUFFT_INTERNAL_ERROR – An internal driver error was detected.

• CUFFT_SETUP_FAILED – The cuFFT library failed to initialize.

• CUFFT_INVALID_SIZE – Thenx parameter is not a supported size.

• CUFFT_MISSING_DEPENDENCY – The cuFFT library was unable to find a dependency either because it is missing or the version found is incompatible

• CUFFT_NVRTC_FAILURE – NVRTC encountered an error during planning

• CUFFT_NVJITLINK_FAILURE – nvJitLink encountered an error during planning

3.5.2.cufftEstimate2d()

cufftResultcufftEstimate2d(intnx,intny,cufftTypetype,size_t*workSize);

During plan execution, cuFFT requires a work area for temporary storage of intermediate results. This call returns an estimate for the size of the work area required, given the specified parameters, and assuming default plan settings. If a work area size of 0 is returned it means no temporary storage is needed for evaluation.

Parameters

• nx[In] – The transform size in thex dimension (number of rows).

• ny[In] – The transform size in they dimension (number of columns).

• type[In] – The transform data type (e.g.,CUFFT_C2R for single precision complex to real).

• *workSize[In] – Pointer to the size, in bytes, of the work space.

• *workSize[Out] – Pointer to the size of the work space.

Return values

• CUFFT_SUCCESS – cuFFT successfully returned the size of the work space.

• CUFFT_ALLOC_FAILED – The allocation of GPU resources for the plan failed.

• CUFFT_INVALID_VALUE – One or more invalid parameters were passed to the API.

• CUFFT_INTERNAL_ERROR – An internal driver error was detected.

• CUFFT_SETUP_FAILED – The cuFFT library failed to initialize.

• CUFFT_INVALID_SIZE – Either or both of thenx orny parameters is not a supported size.

• CUFFT_MISSING_DEPENDENCY – The cuFFT library was unable to find a dependency either because it is missing or the version found is incompatible

• CUFFT_NVRTC_FAILURE – NVRTC encountered an error during planning

• CUFFT_NVJITLINK_FAILURE – nvJitLink encountered an error during planning

3.5.3.cufftEstimate3d()

cufftResultcufftEstimate3d(intnx,intny,intnz,cufftTypetype,size_t*workSize);

During plan execution, cuFFT requires a work area for temporary storage of intermediate results. This call returns an estimate for the size of the work area required, given the specified parameters, and assuming default plan settings. If a work area size of 0 is returned it means no temporary storage is needed for evaluation.

Parameters

• nx[In] – The transform size in thex dimension.

• ny[In] – The transform size in they dimension.

• nz[In] – The transform size in thez dimension.

• type[In] – The transform data type (e.g.,CUFFT_R2C for single precision real to complex).

• *workSize[In] – Pointer to the size, in bytes, of the work space.

• *workSize[Out] – Pointer to the size of the work space.

Return values

• CUFFT_SUCCESS – cuFFT successfully returned the size of the work space.

• CUFFT_ALLOC_FAILED – The allocation of GPU resources for the plan failed.

• CUFFT_INVALID_VALUE – One or more invalid parameters were passed to the API.

• CUFFT_INTERNAL_ERROR – An internal driver error was detected.

• CUFFT_SETUP_FAILED – The cuFFT library failed to initialize.

• CUFFT_INVALID_SIZE – One or more of thenx,ny, ornz parameters is not a supported size.

• CUFFT_MISSING_DEPENDENCY – The cuFFT library was unable to find a dependency either because it is missing or the version found is incompatible

• CUFFT_NVRTC_FAILURE – NVRTC encountered an error during planning

• CUFFT_NVJITLINK_FAILURE – nvJitLink encountered an error during planning

3.5.4.cufftEstimateMany()

cufftResultcufftEstimateMany(intrank,int*n,int*inembed,intistride,intidist,int*onembed,intostride,intodist,cufftTypetype,intbatch,size_t*workSize);

During plan execution, cuFFT requires a work area for temporary storage of intermediate results. This call returns an estimate for the size of the work area required, given the specified parameters, and assuming default plan settings. If a work area size of 0 is returned it means no temporary storage is needed for evaluation.

ThecufftEstimateMany() API supports more complicated input and output data layouts via the advanced data layout parameters:inembed,istride,idist,onembed,ostride, andodist.

All arrays are assumed to be in CPU memory.

Parameters

• rank[In] – Dimensionality of the transform (1, 2, or 3).

• n[In] – Array of sizerank, describing the size of each dimension.

• inembed[In] – Pointer of sizerank that indicates the storage dimensions of the input data in memory. If set to NULL all other advanced data layout parameters are ignored.

• istride[In] – Indicates the distance between two successive input elements in the least significant (i.e., innermost) dimension.

• idist[In] – Indicates the distance between the first element of two consecutive signals in a batch of the input data.

• onembed[In] – Pointer of sizerank that indicates the storage dimensions of the output data in memory. If set to NULL all other advanced data layout parameters are ignored.

• ostride[In] – Indicates the distance between two successive output elements in the output array in the least significant (i.e., innermost) dimension.

• odist[In] – Indicates the distance between the first element of two consecutive signals in a batch of the output data.

• type[In] – The transform data type (e.g.,CUFFT_R2C for single precision real to complex).

• batch[In] – Batch size for this transform.

• *workSize[In] – Pointer to the size, in bytes, of the work space.

• *workSize[Out] – Pointer to the size of the work space

Return values

• CUFFT_SUCCESS – cuFFT successfully returned the size of the work space.

• CUFFT_ALLOC_FAILED – The allocation of GPU resources for the plan failed.

• CUFFT_INVALID_VALUE – One or more invalid parameters were passed to the API.

• CUFFT_INTERNAL_ERROR – An internal driver error was detected.

• CUFFT_SETUP_FAILED – The cuFFT library failed to initialize.

• CUFFT_INVALID_SIZE – One or more of the parameters is not a supported size.

• CUFFT_MISSING_DEPENDENCY – The cuFFT library was unable to find a dependency either because it is missing or the version found is incompatible

• CUFFT_NVRTC_FAILURE – NVRTC encountered an error during planning

• CUFFT_NVJITLINK_FAILURE – nvJitLink encountered an error during planning

3.6.1.cufftGetSize1d()

cufftResultcufftGetSize1d(cufftHandleplan,intnx,cufftTypetype,intbatch,size_t*workSize);

This call gives a more accurate estimate of the work area size required for a plan thancufftEstimate1d(), given the specified parameters, and taking into account any plan settings that may have been made. If a work area size of 0 is returned it means no temporary storage is needed for evaluation.

Parameters

• plan[In] –cufftHandle returned bycufftCreate.

• nx[In] – The transform size (e.g. 256 for a 256-point FFT).

• type[In] – The transform data type (e.g.,CUFFT_C2C for single precision complex to complex).

• batch[In] – Number of transforms of sizenx. Please consider usingcufftGetSizeMany for multiple transforms.

• *workSize[In] – Pointer to the size(s), in bytes, of the work areas. For example for two GPUs worksize must be declared to have two elements.

• *workSize[Out] – Pointer to the size of the work space.

Return values

• CUFFT_SUCCESS – cuFFT successfully returned the size of the work space.

• CUFFT_INVALID_PLAN – Theplan parameter is not a valid handle.

• CUFFT_ALLOC_FAILED – The allocation of GPU resources for the plan failed.

• CUFFT_INVALID_VALUE – One or more invalid parameters were passed to the API.

• CUFFT_INTERNAL_ERROR – An internal driver error was detected.

• CUFFT_SETUP_FAILED – The cuFFT library failed to initialize.

• CUFFT_INVALID_SIZE – Thenx parameter is not a supported size.

3.6.2.cufftGetSize2d()

cufftResultcufftGetSize2d(cufftHandleplan,intnx,intny,cufftTypetype,size_t*workSize);

This call gives a more accurate estimate of the work area size required for a plan thancufftEstimate2d(), given the specified parameters, and taking into account any plan settings that may have been made. If a work area size of 0 is returned it means no temporary storage is needed for evaluation.

Parameters

• plan[In] –cufftHandle returned bycufftCreate.

• nx[In] – The transform size in thex dimension (number of rows).

• ny[In] – The transform size in they dimension (number of columns).

• type[In] – The transform data type (e.g.,CUFFT_C2R for single precision complex to real).

• *workSize[In] – Pointer to the size(s), in bytes, of the work areas. For example for two GPUs worksize must be declared to have two elements.

• *workSize[Out] – Pointer to the size of the work space.

Return values

• CUFFT_SUCCESS – cuFFT successfully returned the size of the work space.

• CUFFT_INVALID_PLAN – Theplan parameter is not a valid handle.

• CUFFT_ALLOC_FAILED – The allocation of GPU resources for the plan failed.

• CUFFT_INVALID_VALUE – One or more invalid parameters were passed to the API.

• CUFFT_INTERNAL_ERROR – An internal driver error was detected.

• CUFFT_SETUP_FAILED – The cuFFT library failed to initialize.

• CUFFT_INVALID_SIZE – Either or both of thenx orny parameters is not a supported size.

3.6.3.cufftGetSize3d()

cufftResultcufftGetSize3d(cufftHandleplan,intnx,intny,intnz,cufftTypetype,size_t*workSize);

This call gives a more accurate estimate of the work area size required for a plan thancufftEstimate3d(), given the specified parameters, and taking into account any plan settings that may have been made. If a work area size of 0 is returned it means no temporary storage is needed for evaluation.

Parameters

• plan[In] –cufftHandle returned bycufftCreate.

• nx[In] – The transform size in thex dimension.

• ny[In] – The transform size in they dimension.

• nz[In] – The transform size in thez dimension.

• type[In] – The transform data type (e.g.,CUFFT_R2C for single precision real to complex).

• *workSize[In] – Pointer to the size(s), in bytes, of the work areas. For example for two GPUs worksize must be declared to have two elements.

• *workSize[Out] – Pointer to the size of the work space.

Return values

• CUFFT_SUCCESS – cuFFT successfully returned the size of the work space.

• CUFFT_INVALID_PLAN – Theplan parameter is not a valid handle.

• CUFFT_ALLOC_FAILED – The allocation of GPU resources for the plan failed.

• CUFFT_INVALID_VALUE – One or more invalid parameters were passed to the API.

• CUFFT_INTERNAL_ERROR – An internal driver error was detected.

• CUFFT_SETUP_FAILED – The cuFFT library failed to initialize.

• CUFFT_INVALID_SIZE – One or more of thenx,ny, ornz parameters is not a supported size.

3.6.4.cufftGetSizeMany()

cufftResultcufftGetSizeMany(cufftHandleplan,intrank,int*n,int*inembed,intistride,intidist,int*onembed,intostride,intodist,cufftTypetype,intbatch,size_t*workSize);

This call gives a more accurate estimate of the work area size required for a plan thancufftEstimateSizeMany(), given the specified parameters, and taking into account any plan settings that may have been made. If a work area size of 0 is returned it means no temporary storage is needed for evaluation.

Parameters

• plan[In] –cufftHandle returned bycufftCreate.

• rank[In] – Dimensionality of the transform (1, 2, or 3).

• n[In] – Array of sizerank, describing the size of each dimension.

• inembed[In] – Pointer of sizerank that indicates the storage dimensions of the input data in memory. If set to NULL all other advanced data layout parameters are ignored.

• istride[In] – Indicates the distance between two successive input elements in the least significant (i.e., innermost) dimension.

• idist[In] – Indicates the distance between the first element of two consecutive signals in a batch of the input data.

• onembed[In] – Pointer of sizerank that indicates the storage dimensions of the output data in memory. If set to NULL all other advanced data layout parameters are ignored.

• ostride[In] – Indicates the distance between two successive output elements in the output array in the least significant (i.e., innermost) dimension.

• odist[In] – Indicates the distance between the first element of two consecutive signals in a batch of the output data.

• type[In] – The transform data type (e.g.,CUFFT_R2C for single precision real to complex).

• batch[In] – Batch size for this transform.

• *workSize[In] – Pointer to the size(s), in bytes, of the work areas. For example for two GPUs worksize must be declared to have two elements.

• *workSize[Out] – Pointer to the size of the work area.

Return values

• CUFFT_SUCCESS – cuFFT successfully returned the size of the work space.

• CUFFT_INVALID_PLAN – Theplan parameter is not a valid handle.

• CUFFT_ALLOC_FAILED – The allocation of GPU resources for the plan failed.

• CUFFT_INVALID_VALUE – One or more invalid parameters were passed to the API.

• CUFFT_INTERNAL_ERROR – An internal driver error was detected.

• CUFFT_SETUP_FAILED – The cuFFT library failed to initialize.

• CUFFT_INVALID_SIZE – One or more of the parameters is not a supported size.

3.6.5.cufftGetSizeMany64()

cufftResultcufftGetSizeMany64(cufftHandleplan,intrank,longlongint*n,longlongint*inembed,longlongintistride,longlongintidist,longlongint*onembed,longlongintostride,longlongintodist,cufftTypetype,longlongintbatch,size_t*workSize);

This call gives a more accurate estimate of the work area size required for a plan thancufftEstimateSizeMany(), given the specified parameters, and taking into account any plan settings that may have been made. If a work area size of 0 is returned it means no temporary storage is needed for evaluation.

This API is identical tocufftMakePlanMany except that the arguments specifying sizes and strides are 64 bit integers. This API makes very large transforms possible. cuFFT includes kernels that use 32 bit indexes, and kernels that use 64 bit indexes. cuFFT planning selects 32 bit kernels whenever possible to avoid any overhead due to 64 bit arithmetic.

All sizes and types of transform are supported by this interface, with two exceptions. For transforms whose total size exceeds 4G elements, the dimensions specified in the arrayn must be factorable into primes that are less than or equal to 127. For real to complex and complex to real transforms whose total size exceeds 4G elements, the fastest changing dimension must be even.

Parameters

• plan[In] –cufftHandle returned bycufftCreate.

• rank[In] – Dimensionality of the transform (1, 2, or 3).

• n[In] – Array of sizerank, describing the size of each dimension.

• inembed[In] – Pointer of sizerank that indicates the storage dimensions of the input data in memory. If set to NULL all other advanced data layout parameters are ignored.

• istride[In] – Indicates the distance between two successive input elements in the least significant (i.e., innermost) dimension.

• idist[In] – Indicates the distance between the first element of two consecutive signals in a batch of the input data.

• onembed[In] – Pointer of sizerank that indicates the storage dimensions of the output data in memory. If set to NULL all other advanced data layout parameters are ignored.

• ostride[In] – Indicates the distance between two successive output elements in the output array in the least significant (i.e., innermost) dimension.

• odist[In] – Indicates the distance between the first element of two consecutive signals in a batch of the output data.

• type[In] – The transform data type (e.g.,CUFFT_R2C for single precision real to complex).

• batch[In] – Batch size for this transform.

• *workSize[In] – Pointer to the size(s), in bytes, of the work areas. For example for two GPUs worksize must be declared to have two elements.

• *workSize[Out] – Pointer to the size of the work area.

Return values

• CUFFT_SUCCESS – cuFFT successfully returned the size of the work space.

• CUFFT_INVALID_PLAN – Theplan parameter is not a valid handle.

• CUFFT_ALLOC_FAILED – The allocation of GPU resources for the plan failed.

• CUFFT_INVALID_VALUE – One or more invalid parameters were passed to the API.

• CUFFT_INTERNAL_ERROR – An internal driver error was detected.

• CUFFT_SETUP_FAILED – The cuFFT library failed to initialize.

• CUFFT_INVALID_SIZE – One or more of the parameters is not a supported size.

3.6.6.cufftXtGetSizeMany()

cufftResultcufftXtGetSizeMany(cufftHandleplan,intrank,longlongint*n,longlongint*inembed,longlongintistride,longlongintidist,cudaDataTypeinputtype,longlongint*onembed,longlongintostride,longlongintodist,cudaDataTypeoutputtype,longlongintbatch,size_t*workSize,cudaDataTypeexecutiontype);

This call gives a more accurate estimate of the work area size required for a plan thancufftEstimateSizeMany(), given the specified parameters that match signature ofcufftXtMakePlanMany function, and taking into account any plan settings that may have been made. If a work area size of 0 is returned it means no temporary storage is needed for evaluation.

For more information about valid combinations ofinputtype,outputtype andexecutiontype parameters please refer to documentation ofcufftXtMakePlanMany function.

Parameters

• plan[In] –cufftHandle returned bycufftCreate.

• rank[In] – Dimensionality of the transform (1, 2, or 3).

• n[In] – Array of sizerank, describing the size of each dimension.

• inembed[In] – Pointer of sizerank that indicates the storage dimensions of the input data in memory. If set to NULL all other advanced data layout parameters are ignored.

• istride[In] – Indicates the distance between two successive input elements in the least significant (i.e., innermost) dimension.

• idist[In] – Indicates the distance between the first element of two consecutive signals in a batch of the input data.

• inputtype[In] (cudaDataType) – Type of input data.

• onembed[In] – Pointer of sizerank that indicates the storage dimensions of the output data in memory. If set to NULL all other advanced data layout parameters are ignored.

• ostride[In] – Indicates the distance between two successive output elements in the output array in the least significant (i.e., innermost) dimension.

• odist[In] – Indicates the distance between the first element of two consecutive signals in a batch of the output data.

• outputtype[In] (cudaDataType) – Type of output data.

• batch[In] – Batch size for this transform.

• *workSize[In] – Pointer to the size(s), in bytes, of the work areas. For example for two GPUs worksize must be declared to have two elements.

• executiontype[In] (cudaDataType) – Type of data to be used for computations.

• *workSize[Out] – Pointer to the size of the work area.

Return values

• CUFFT_SUCCESS – cuFFT successfully returned the size of the work space.

• CUFFT_INVALID_PLAN – Theplan parameter is not a valid handle.

• CUFFT_ALLOC_FAILED – The allocation of GPU resources for the plan failed.

• CUFFT_INVALID_VALUE – One or more invalid parameters were passed to the API.

• CUFFT_INTERNAL_ERROR – An internal driver error was detected.

• CUFFT_SETUP_FAILED – The cuFFT library failed to initialize.

• CUFFT_INVALID_SIZE – One or more of the parameters is not a supported size.

3.8.1.cufftSetAutoAllocation()

cufftResultcufftSetAutoAllocation(cufftHandleplan,intautoAllocate);

cufftSetAutoAllocation() indicates that the caller intends to allocate and manage work areas for plans that have been generated. cuFFT default behavior is to allocate the work area at plan generation time. IfcufftSetAutoAllocation() has been called with autoAllocate set to 0 (“false”) prior to one of thecufftMakePlan*() calls, cuFFT does not allocate the work area. This is the preferred sequence for callers wishing to manage work area allocation.

Parameters

• plan[In] –cufftHandle returned bycufftCreate.

• autoAllocate[In] – Indicates whether to allocate work area.

Return values

• CUFFT_SUCCESS – cuFFT successfully returned the size of the work space.

• CUFFT_INVALID_PLAN – Theplan parameter is not a valid handle.

• CUFFT_INTERNAL_ERROR – An internal driver error was detected.

3.8.2.cufftSetWorkArea()

cufftResultcufftSetWorkArea(cufftHandleplan,void*workArea);

cufftSetWorkArea() overrides the work area pointer associated with a plan. If the work area was auto-allocated, cuFFT frees the auto-allocated space. ThecufftExec*() calls assume that the work area pointer is valid and that it points to a contiguous region in device memory that does not overlap with any other work area. If this is not the case, results are indeterminate.

Parameters

• plan[In] –cufftHandle returned bycufftCreate.

• *workArea[In] – Pointer toworkArea. For multiple GPUs, multiple work area pointers must be given.

Return values

• CUFFT_SUCCESS – cuFFT successfully returned the size of the work space.

• CUFFT_INVALID_PLAN – Theplan parameter is not a valid handle.

• CUFFT_INTERNAL_ERROR – An internal driver error was detected.

• CUFFT_SETUP_FAILED – The cuFFT library failed to initialize.

3.8.3.cufftXtSetWorkAreaPolicy()

cufftResultcufftXtSetWorkAreaPolicy(cufftHandleplan,cufftXtWorkAreaPolicypolicy,size_t*workSize);

cufftXtSetWorkAreaPolicy() indicates that the caller intends to change work area size for a given plan handle. cuFFT’s default behavior is to allocate the work area at plan generation time with a default size that depends on the plan type and other parameters. IfcufftXtSetWorkAreaPolicy() has been called with thepolicy parameter set toCUFFT_WORKAREA_MINIMAL, cuFFT will attempt to re-plan the handle to use zero bytes of work area memory. If thecufftXtSetWorkAreaPolicy() call is successful the auto-allocated work area memory is released.

Currently the policiesCUFFT_WORKAREA_PERFORMANCE,CUFFT_WORKAREA_USER and theworkSize parameter are not supported and reserved for use in future cuFFT releases.

This function can be called once per lifetime of a plan handle.

Parameters

• plan[In] –cufftHandle returned bycufftCreate.

• policy[In] – Type of work area policy to apply.

• *workSize[In] – Reserved for future use.

Return values

• CUFFT_SUCCESS – cuFFT successfully returned the size of the work space.

• CUFFT_INVALID_PLAN – Theplan parameter is not a valid handle.

• CUFFT_INVALID_SIZE – FFT size does not allow use of the selected policy.

• CUFFT_INTERNAL_ERROR – An internal driver error was detected.

• CUFFT_SETUP_FAILED – The cuFFT library failed to initialize.

3.9.1.cufftExecC2C() and cufftExecZ2Z()

cufftResultcufftExecC2C(cufftHandleplan,cufftComplex*idata,cufftComplex*odata,intdirection);

cufftResultcufftExecZ2Z(cufftHandleplan,cufftDoubleComplex*idata,cufftDoubleComplex*odata,intdirection);

cufftExecC2C() (cufftExecZ2Z()) executes a single-precision (double-precision) complex-to-complex transform plan in the transform direction as specified bydirection parameter. cuFFT uses the GPU memory pointed to by theidata parameter as input data. This function stores the Fourier coefficients in theodata array. Ifidata andodata are the same, this method does an in-place transform.

Parameters

• plan[In] –cufftHandle returned bycufftCreate.

• idata[In] – Pointer to the complex input data (in GPU memory) to transform.

• odata[In] – Pointer to the complex output data (in GPU memory).

• direction[In] – The transform direction:CUFFT_FORWARD orCUFFT_INVERSE.

• odata[Out] – ontains the complex Fourier coefficients.

Return values

• CUFFT_SUCCESS – cuFFT successfully returned the size of the work space.

• CUFFT_INVALID_PLAN – Theplan parameter is not a valid handle.

• CUFFT_INVALID_VALUE – At least one of the parametersidata,odata, anddirection is not valid.

• CUFFT_INTERNAL_ERROR – An internal driver error was detected.

• CUFFT_EXEC_FAILED – cuFFT failed to execute the transform on the GPU.

• CUFFT_SETUP_FAILED – The cuFFT library failed to initialize.

3.9.2.cufftExecR2C() and cufftExecD2Z()

cufftResultcufftExecR2C(cufftHandleplan,cufftReal*idata,cufftComplex*odata);

cufftResultcufftExecD2Z(cufftHandleplan,cufftDoubleReal*idata,cufftDoubleComplex*odata);

cufftExecR2C() (cufftExecD2Z()) executes a single-precision (double-precision) real-to-complex, implicitly forward, cuFFT transform plan. cuFFT uses as input data the GPU memory pointed to by theidata parameter. This function stores the nonredundant Fourier coefficients in theodata array. Pointers toidata andodata are both required to be aligned tocufftComplex data type in single-precision transforms andcufftDoubleComplex data type in double-precision transforms. Ifidata andodata are the same, this method does an in-place transform. Note the data layout differences between in-place and out-of-place transforms as described inParameter cufftType.

Parameters

• plan[In] –cufftHandle returned bycufftCreate.

• idata[In] – Pointer to the real input data (in GPU memory) to transform.

• odata[In] – Pointer to the complex output data (in GPU memory).

• odata[Out] – Contains the complex Fourier coefficients.

Return values

• CUFFT_SUCCESS – cuFFT successfully returned the size of the work space.

• CUFFT_INVALID_PLAN – Theplan parameter is not a valid handle.

• CUFFT_INVALID_VALUE – At least one of the parametersidata andodata is not valid.

• CUFFT_INTERNAL_ERROR – An internal driver error was detected.

• CUFFT_EXEC_FAILED – cuFFT failed to execute the transform on the GPU.

• CUFFT_SETUP_FAILED – The cuFFT library failed to initialize.

3.9.3.cufftExecC2R() and cufftExecZ2D()

cufftResultcufftExecC2R(cufftHandleplan,cufftComplex*idata,cufftReal*odata);

cufftResultcufftExecZ2D(cufftHandleplan,cufftDoubleComplex*idata,cufftDoubleReal*odata);

cufftExecC2R() (cufftExecZ2D()) executes a single-precision (double-precision) complex-to-real, implicitly inverse, cuFFT transform plan. cuFFT uses as input data the GPU memory pointed to by theidata parameter. The input array holds only the nonredundant complex Fourier coefficients. This function stores the real output values in theodata array. and pointers are both required to be aligned tocufftComplex data type in single-precision transforms andcufftDoubleComplex type in double-precision transforms. Ifidata andodata are the same, this method does an in-place transform.

Parameters

• plan[In] –cufftHandle returned bycufftCreate.

• idata[In] – Pointer to the complex input data (in GPU memory) to transform.

• odata[In] – Pointer to the real output data (in GPU memory).

• odata[Out] – Contains the real output data.

Return values

• CUFFT_SUCCESS – cuFFT successfully executed the FFT plan.

• CUFFT_INVALID_PLAN – Theplan parameter is not a valid handle.

• CUFFT_INVALID_VALUE – At least one of the parametersidata andodata is not valid.

• CUFFT_INTERNAL_ERROR – An internal driver error was detected.

• CUFFT_EXEC_FAILED – cuFFT failed to execute the transform on the GPU.

• CUFFT_SETUP_FAILED – The cuFFT library failed to initialize.

3.9.4.cufftXtExec()

cufftResultcufftXtExec(cufftHandleplan,void*input,void*output,intdirection);

FunctioncufftXtExec executes any cuFFT transform regardless of precision and type. In case of complex-to-real and real-to-complex transformsdirection parameter is ignored. cuFFT uses the GPU memory pointed to by theinput parameter as input data. This function stores the Fourier coefficients in theoutput array. Ifinput andoutput are the same, this method does an in-place transform.

Parameters

• plan[In] –cufftHandle returned bycufftCreate.

• input[In] – Pointer to the input data (in GPU memory) to transform.

• output[In] – Pointer to the output data (in GPU memory).

• direction[In] – The transform direction:CUFFT_FORWARD orCUFFT_INVERSE. Ignored for complex-to-real and real-to-complex transforms.

• output[Out] – Contains the complex Fourier coefficients.

Return values

• CUFFT_SUCCESS – cuFFT successfully executed the FFT plan.

• CUFFT_INVALID_PLAN – Theplan parameter is not a valid handle.

• CUFFT_INVALID_VALUE – At least one of the parametersidata,odata, anddirection is not valid.

• CUFFT_INTERNAL_ERROR – An internal driver error was detected.

• CUFFT_EXEC_FAILED – cuFFT failed to execute the transform on the GPU.

• CUFFT_SETUP_FAILED – The cuFFT library failed to initialize.

3.9.5.cufftXtExecDescriptor()

cufftResultcufftXtExecDescriptor(cufftHandleplan,cudaLibXtDesc*input,cudaLibXtDesc*output,intdirection);

FunctioncufftXtExecDescriptor() executes any cuFFT transform regardless of precision and type. In case of complex-to-real and real-to-complex transformsdirection parameter is ignored. cuFFT uses the GPU memory pointed to bycudaLibXtDesc*input descriptor as input data andcudaLibXtDesc*output as output data.

Parameters

• plan[In] –cufftHandle returned bycufftCreate.

• input[In] – Pointer to the complex input data (in GPU memory) to transform.

• output[In] – Pointer to the complex output data (in GPU memory).

• direction[In] – The transform direction:CUFFT_FORWARD orCUFFT_INVERSE. Ignored for complex-to-real and real-to-complex transforms.

• idata[Out] – Contains the complex Fourier coefficients.

Return values

• CUFFT_SUCCESS – cuFFT successfully executed the FFT plan.

• CUFFT_INVALID_PLAN – Theplan parameter is not a valid handle.

• CUFFT_INVALID_VALUE – At least one of the parametersidata anddirection is not valid.

• CUFFT_INTERNAL_ERROR – An internal driver error was detected.

• CUFFT_EXEC_FAILED – cuFFT failed to execute the transform on the GPU.

• CUFFT_SETUP_FAILED – The cuFFT library failed to initialize.

• CUFFT_INVALID_DEVICE – An invalid GPU index was specified in a descriptor.