clFFT.h

Go to the documentation of this file.

/* ************************************************************************
 * Copyright 2013-2015 Advanced Micro Devices, Inc.
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 * http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 * ************************************************************************/
 
 
#pragma once
#if !defined( CLFFT_H )
#define CLFFT_H
 
#if defined(__APPLE__) || defined(__MACOSX)
        #include <OpenCL/cl.h>
#else
        #include <CL/cl.h>
#endif
 
#include "clFFT.version.h"
 
#if defined( _WIN32 )
        #if !defined( __cplusplus )
                #define inline __inline
        #endif
 
    #if defined( CLFFT_STATIC )
        #define CLFFTAPI
    #elif defined( CLFFT_EXPORTS )
        #define CLFFTAPI __declspec( dllexport )
    #else
        #define CLFFTAPI __declspec( dllimport )
    #endif
#else
        #define CLFFTAPI
#endif
 
/*      In general, you cannot use namespaces for strict C compliance, so we prefix our public accessible names
 *      with the string clfft
 */
 
/*      All functions return pre-defined error codes, and do NOT throw exceptions to the caller.
 */
 
enum clfftStatus_
{
        CLFFT_INVALID_GLOBAL_WORK_SIZE                  = CL_INVALID_GLOBAL_WORK_SIZE,
        CLFFT_INVALID_MIP_LEVEL                                 = CL_INVALID_MIP_LEVEL,
        CLFFT_INVALID_BUFFER_SIZE                               = CL_INVALID_BUFFER_SIZE,
        CLFFT_INVALID_GL_OBJECT                                 = CL_INVALID_GL_OBJECT,
        CLFFT_INVALID_OPERATION                                 = CL_INVALID_OPERATION,
        CLFFT_INVALID_EVENT                                             = CL_INVALID_EVENT,
        CLFFT_INVALID_EVENT_WAIT_LIST                   = CL_INVALID_EVENT_WAIT_LIST,
        CLFFT_INVALID_GLOBAL_OFFSET                             = CL_INVALID_GLOBAL_OFFSET,
        CLFFT_INVALID_WORK_ITEM_SIZE                    = CL_INVALID_WORK_ITEM_SIZE,
        CLFFT_INVALID_WORK_GROUP_SIZE                   = CL_INVALID_WORK_GROUP_SIZE,
        CLFFT_INVALID_WORK_DIMENSION                    = CL_INVALID_WORK_DIMENSION,
        CLFFT_INVALID_KERNEL_ARGS                               = CL_INVALID_KERNEL_ARGS,
        CLFFT_INVALID_ARG_SIZE                                  = CL_INVALID_ARG_SIZE,
        CLFFT_INVALID_ARG_VALUE                                 = CL_INVALID_ARG_VALUE,
        CLFFT_INVALID_ARG_INDEX                                 = CL_INVALID_ARG_INDEX,
        CLFFT_INVALID_KERNEL                                    = CL_INVALID_KERNEL,
        CLFFT_INVALID_KERNEL_DEFINITION                 = CL_INVALID_KERNEL_DEFINITION,
        CLFFT_INVALID_KERNEL_NAME                               = CL_INVALID_KERNEL_NAME,
        CLFFT_INVALID_PROGRAM_EXECUTABLE                = CL_INVALID_PROGRAM_EXECUTABLE,
        CLFFT_INVALID_PROGRAM                                   = CL_INVALID_PROGRAM,
        CLFFT_INVALID_BUILD_OPTIONS                             = CL_INVALID_BUILD_OPTIONS,
        CLFFT_INVALID_BINARY                                    = CL_INVALID_BINARY,
        CLFFT_INVALID_SAMPLER                                   = CL_INVALID_SAMPLER,
        CLFFT_INVALID_IMAGE_SIZE                                = CL_INVALID_IMAGE_SIZE,
        CLFFT_INVALID_IMAGE_FORMAT_DESCRIPTOR   = CL_INVALID_IMAGE_FORMAT_DESCRIPTOR,
        CLFFT_INVALID_MEM_OBJECT                                = CL_INVALID_MEM_OBJECT,
        CLFFT_INVALID_HOST_PTR                                  = CL_INVALID_HOST_PTR,
        CLFFT_INVALID_COMMAND_QUEUE                             = CL_INVALID_COMMAND_QUEUE,
        CLFFT_INVALID_QUEUE_PROPERTIES                  = CL_INVALID_QUEUE_PROPERTIES,
        CLFFT_INVALID_CONTEXT                                   = CL_INVALID_CONTEXT,
        CLFFT_INVALID_DEVICE                                    = CL_INVALID_DEVICE,
        CLFFT_INVALID_PLATFORM                                  = CL_INVALID_PLATFORM,
        CLFFT_INVALID_DEVICE_TYPE                               = CL_INVALID_DEVICE_TYPE,
        CLFFT_INVALID_VALUE                                             = CL_INVALID_VALUE,
        CLFFT_MAP_FAILURE                                               = CL_MAP_FAILURE,
        CLFFT_BUILD_PROGRAM_FAILURE                             = CL_BUILD_PROGRAM_FAILURE,
        CLFFT_IMAGE_FORMAT_NOT_SUPPORTED                = CL_IMAGE_FORMAT_NOT_SUPPORTED,
        CLFFT_IMAGE_FORMAT_MISMATCH                             = CL_IMAGE_FORMAT_MISMATCH,
        CLFFT_MEM_COPY_OVERLAP                                  = CL_MEM_COPY_OVERLAP,
        CLFFT_PROFILING_INFO_NOT_AVAILABLE              = CL_PROFILING_INFO_NOT_AVAILABLE,
        CLFFT_OUT_OF_HOST_MEMORY                                = CL_OUT_OF_HOST_MEMORY,
        CLFFT_OUT_OF_RESOURCES                                  = CL_OUT_OF_RESOURCES,
        CLFFT_MEM_OBJECT_ALLOCATION_FAILURE             = CL_MEM_OBJECT_ALLOCATION_FAILURE,
        CLFFT_COMPILER_NOT_AVAILABLE                    = CL_COMPILER_NOT_AVAILABLE,
        CLFFT_DEVICE_NOT_AVAILABLE                              = CL_DEVICE_NOT_AVAILABLE,
        CLFFT_DEVICE_NOT_FOUND                                  = CL_DEVICE_NOT_FOUND,
        CLFFT_SUCCESS                                                   = CL_SUCCESS,
        //-------------------------- Extended status codes for clfft ----------------------------------------
        CLFFT_BUGCHECK =  4*1024,       
        CLFFT_NOTIMPLEMENTED,           
        CLFFT_TRANSPOSED_NOTIMPLEMENTED, 
        CLFFT_FILE_NOT_FOUND,           
        CLFFT_FILE_CREATE_FAILURE,      
        CLFFT_VERSION_MISMATCH,         
        CLFFT_INVALID_PLAN,                     
        CLFFT_DEVICE_NO_DOUBLE,         
        CLFFT_DEVICE_MISMATCH,          
        CLFFT_ENDSTATUS                         /* The last value of the enum, and marks the length of clfftStatus. */
};
typedef enum clfftStatus_ clfftStatus;
 
typedef enum clfftDim_
{
        CLFFT_1D                = 1,            
        CLFFT_2D,                                       
        CLFFT_3D,                                       
        ENDDIMENSION                    
} clfftDim;
 
typedef enum clfftLayout_
{
        CLFFT_COMPLEX_INTERLEAVED       = 1,    
        CLFFT_COMPLEX_PLANAR,                           
        CLFFT_HERMITIAN_INTERLEAVED,            
        CLFFT_HERMITIAN_PLANAR,                         
        CLFFT_REAL,                                                     
        ENDLAYOUT                       
} clfftLayout;
 
typedef enum clfftPrecision_
{
        CLFFT_SINGLE    = 1,    
        CLFFT_DOUBLE,                   
        CLFFT_SINGLE_FAST,              
        CLFFT_DOUBLE_FAST,              
        ENDPRECISION    
} clfftPrecision;
 
typedef enum clfftDirection_
{
        CLFFT_FORWARD   = -1,           
        CLFFT_BACKWARD  = 1,            
        CLFFT_MINUS             = -1,           
        CLFFT_PLUS              = 1,            
        ENDDIRECTION                    
} clfftDirection;
 
typedef enum clfftResultLocation_
{
        CLFFT_INPLACE           = 1,            
        CLFFT_OUTOFPLACE,                               
        ENDPLACE                                
} clfftResultLocation;
 
typedef enum clfftResultTransposed_ {
        CLFFT_NOTRANSPOSE = 1,          
        CLFFT_TRANSPOSED,                       
        ENDTRANSPOSED                   
} clfftResultTransposed;
 
#define CLFFT_DUMP_PROGRAMS 0x1
 
struct clfftSetupData_
{
        cl_uint major;          
        cl_uint minor;          
        cl_uint patch;          
        cl_ulong debugFlags;  
};
typedef struct clfftSetupData_ clfftSetupData;
 
typedef enum clfftCallbackType_
{
        PRECALLBACK,    
        POSTCALLBACK    
}clfftCallbackType;
 
typedef size_t clfftPlanHandle;
 
#ifdef __cplusplus
extern "C" {
#endif
        __inline clfftStatus clfftInitSetupData( clfftSetupData* setupData )
        {
                setupData->major        = clfftVersionMajor;
                setupData->minor        = clfftVersionMinor;
                setupData->patch        = clfftVersionPatch;
                setupData->debugFlags   = 0;
 
                return  CLFFT_SUCCESS;
        }
 
        CLFFTAPI clfftStatus    clfftSetup( const clfftSetupData* setupData );
 
        CLFFTAPI clfftStatus    clfftTeardown( );
 
        CLFFTAPI clfftStatus    clfftGetVersion( cl_uint* major, cl_uint* minor, cl_uint* patch );
 
        CLFFTAPI clfftStatus    clfftCreateDefaultPlan( clfftPlanHandle* plHandle, cl_context context, const clfftDim dim,
                                                                const size_t* clLengths );
 
        CLFFTAPI clfftStatus    clfftCopyPlan( clfftPlanHandle* out_plHandle, cl_context new_context, clfftPlanHandle in_plHandle );
 
        CLFFTAPI clfftStatus    clfftBakePlan( clfftPlanHandle plHandle, cl_uint numQueues, cl_command_queue* commQueueFFT,
                                                        void (CL_CALLBACK *pfn_notify)(clfftPlanHandle plHandle, void *user_data), void* user_data );
 
        CLFFTAPI clfftStatus    clfftDestroyPlan( clfftPlanHandle* plHandle );
 
        CLFFTAPI clfftStatus    clfftGetPlanContext( const clfftPlanHandle plHandle, cl_context* context );
 
        CLFFTAPI clfftStatus    clfftGetPlanPrecision( const clfftPlanHandle plHandle, clfftPrecision* precision );
 
        CLFFTAPI clfftStatus    clfftSetPlanPrecision( clfftPlanHandle plHandle, clfftPrecision precision );
 
        CLFFTAPI clfftStatus    clfftGetPlanScale( const clfftPlanHandle plHandle, clfftDirection dir, cl_float* scale );
 
        CLFFTAPI clfftStatus    clfftSetPlanScale( clfftPlanHandle plHandle, clfftDirection dir, cl_float scale );
 
        CLFFTAPI clfftStatus    clfftGetPlanBatchSize( const clfftPlanHandle plHandle, size_t* batchSize );
 
        CLFFTAPI clfftStatus    clfftSetPlanBatchSize( clfftPlanHandle plHandle, size_t batchSize );
 
        CLFFTAPI clfftStatus    clfftGetPlanDim( const clfftPlanHandle plHandle, clfftDim* dim, cl_uint* size );
 
        CLFFTAPI clfftStatus    clfftSetPlanDim( clfftPlanHandle plHandle, const clfftDim dim );
 
        CLFFTAPI clfftStatus    clfftGetPlanLength( const clfftPlanHandle plHandle, const clfftDim dim, size_t* clLengths );
 
        CLFFTAPI clfftStatus    clfftSetPlanLength( clfftPlanHandle plHandle, const clfftDim dim, const size_t* clLengths );
 
        CLFFTAPI clfftStatus    clfftGetPlanInStride( const clfftPlanHandle plHandle, const clfftDim dim, size_t* clStrides );
 
        CLFFTAPI clfftStatus    clfftSetPlanInStride( clfftPlanHandle plHandle, const clfftDim dim, size_t* clStrides );
 
        CLFFTAPI clfftStatus    clfftGetPlanOutStride( const clfftPlanHandle plHandle, const clfftDim dim, size_t* clStrides );
 
        CLFFTAPI clfftStatus    clfftSetPlanOutStride( clfftPlanHandle plHandle, const clfftDim dim, size_t* clStrides );
 
        CLFFTAPI clfftStatus    clfftGetPlanDistance( const clfftPlanHandle plHandle, size_t* iDist, size_t* oDist );
 
        CLFFTAPI clfftStatus    clfftSetPlanDistance( clfftPlanHandle plHandle, size_t iDist, size_t oDist );
 
        CLFFTAPI clfftStatus    clfftGetLayout( const clfftPlanHandle plHandle, clfftLayout* iLayout, clfftLayout* oLayout );
 
        CLFFTAPI clfftStatus    clfftSetLayout( clfftPlanHandle plHandle, clfftLayout iLayout, clfftLayout oLayout );
 
        CLFFTAPI clfftStatus    clfftGetResultLocation( const clfftPlanHandle plHandle, clfftResultLocation* placeness );
 
        CLFFTAPI clfftStatus    clfftSetResultLocation( clfftPlanHandle plHandle, clfftResultLocation placeness );
 
        CLFFTAPI clfftStatus    clfftGetPlanTransposeResult( const clfftPlanHandle plHandle, clfftResultTransposed * transposed );
 
        CLFFTAPI clfftStatus    clfftSetPlanTransposeResult( clfftPlanHandle plHandle, clfftResultTransposed transposed );
 
 
        CLFFTAPI clfftStatus clfftGetTmpBufSize( const clfftPlanHandle plHandle, size_t* buffersize );
 
        CLFFTAPI clfftStatus clfftSetPlanCallback(clfftPlanHandle plHandle, const char* funcName, const char* funcString,
                                                                                int localMemSize, clfftCallbackType callbackType, cl_mem *userdata, int numUserdataBuffers);
 
 
        CLFFTAPI clfftStatus    clfftEnqueueTransform(
                                                                                                clfftPlanHandle plHandle,
                                                                                                clfftDirection dir,
                                                                                                cl_uint numQueuesAndEvents,
                                                                                                cl_command_queue* commQueues,
                                                                                                cl_uint numWaitEvents,
                                                                                                const cl_event* waitEvents,
                                                                                                cl_event* outEvents,
                                                                                                cl_mem* inputBuffers,
                                                                                                cl_mem* outputBuffers,
                                                                                                cl_mem tmpBuffer
                                                                                                );
 
#ifdef __cplusplus
}
#endif
 
#endif