From de50d0bfda2afa0512a1ebcca356bb9bd731e91c Mon Sep 17 00:00:00 2001 From: Joe Groff Date: Mon, 12 Apr 2010 17:37:06 -0700 Subject: [PATCH] cuda.ffi binding --- extra/cuda/ffi/ffi.factor | 439 ++++++++++++++++++++++++++++++++++++++ 1 file changed, 439 insertions(+) create mode 100644 extra/cuda/ffi/ffi.factor diff --git a/extra/cuda/ffi/ffi.factor b/extra/cuda/ffi/ffi.factor new file mode 100644 index 0000000000..3b59eb83e5 --- /dev/null +++ b/extra/cuda/ffi/ffi.factor @@ -0,0 +1,439 @@ +! (c)2010 Joe Groff bsd license +USING: alien alien.c-types alien.libraries alien.syntax +classes.struct combinators system ; +IN: cuda.ffi + +<< +"cuda" { + { [ os windows? ] [ "nvcuda.dll" stdcall ] } + { [ os macosx? ] [ "/usr/local/cuda/lib/libcuda.dylib" cdecl ] } + { [ os unix? ] [ "libcuda.so" cdecl ] } +} cond add-library +>> + +TYPEDEF: uint CUdeviceptr +TYPEDEF: int CUdevice +TYPEDEF: void* CUcontext +TYPEDEF: void* CUmodule +TYPEDEF: void* CUfunction +TYPEDEF: void* CUarray +TYPEDEF: void* CUtexref +TYPEDEF: void* CUevent +TYPEDEF: void* CUstream +TYPEDEF: void* CUgraphicsResource + +STRUCT: CUuuid + { bytes char[16] } ; + +C-ENUM: CUctx_flags + { CU_CTX_SCHED_AUTO 0 } + { CU_CTX_SCHED_SPIN 1 } + { CU_CTX_SCHED_YIELD 2 } + { CU_CTX_SCHED_MASK 3 } + { CU_CTX_BLOCKING_SYNC 4 } + { CU_CTX_MAP_HOST 8 } + { CU_CTX_LMEM_RESIZE_TO_MAX 16 } + { CU_CTX_FLAGS_MASK HEX: 1f } ; + +C-ENUM: CUevent_flags + { CU_EVENT_DEFAULT 0 } + { CU_EVENT_BLOCKING_SYNC 1 } ; + +C-ENUM: CUarray_format + { CU_AD_FORMAT_UNSIGNED_INT8 HEX: 01 } + { CU_AD_FORMAT_UNSIGNED_INT16 HEX: 02 } + { CU_AD_FORMAT_UNSIGNED_INT32 HEX: 03 } + { CU_AD_FORMAT_SIGNED_INT8 HEX: 08 } + { CU_AD_FORMAT_SIGNED_INT16 HEX: 09 } + { CU_AD_FORMAT_SIGNED_INT32 HEX: 0a } + { CU_AD_FORMAT_HALF HEX: 10 } + { CU_AD_FORMAT_FLOAT HEX: 20 } ; + +C-ENUM: CUaddress_mode + { CU_TR_ADDRESS_MODE_WRAP 0 } + { CU_TR_ADDRESS_MODE_CLAMP 1 } + { CU_TR_ADDRESS_MODE_MIRROR 2 } ; + +C-ENUM: CUfilter_mode + { CU_TR_FILTER_MODE_POINT 0 } + { CU_TR_FILTER_MODE_LINEAR 1 } ; + +C-ENUM: CUdevice_attribute + { CU_DEVICE_ATTRIBUTE_MAX_THREADS_PER_BLOCK 1 } + { CU_DEVICE_ATTRIBUTE_MAX_BLOCK_DIM_X 2 } + { CU_DEVICE_ATTRIBUTE_MAX_BLOCK_DIM_Y 3 } + { CU_DEVICE_ATTRIBUTE_MAX_BLOCK_DIM_Z 4 } + { CU_DEVICE_ATTRIBUTE_MAX_GRID_DIM_X 5 } + { CU_DEVICE_ATTRIBUTE_MAX_GRID_DIM_Y 6 } + { CU_DEVICE_ATTRIBUTE_MAX_GRID_DIM_Z 7 } + { CU_DEVICE_ATTRIBUTE_MAX_SHARED_MEMORY_PER_BLOCK 8 } + { CU_DEVICE_ATTRIBUTE_SHARED_MEMORY_PER_BLOCK 8 } + { CU_DEVICE_ATTRIBUTE_TOTAL_CONSTANT_MEMORY 9 } + { CU_DEVICE_ATTRIBUTE_WARP_SIZE 10 } + { CU_DEVICE_ATTRIBUTE_MAX_PITCH 11 } + { CU_DEVICE_ATTRIBUTE_MAX_REGISTERS_PER_BLOCK 12 } + { CU_DEVICE_ATTRIBUTE_REGISTERS_PER_BLOCK 12 } + { CU_DEVICE_ATTRIBUTE_CLOCK_RATE 13 } + { CU_DEVICE_ATTRIBUTE_TEXTURE_ALIGNMENT 14 } + + { CU_DEVICE_ATTRIBUTE_GPU_OVERLAP 15 } + { CU_DEVICE_ATTRIBUTE_MULTIPROCESSOR_COUNT 16 } + { CU_DEVICE_ATTRIBUTE_KERNEL_EXEC_TIMEOUT 17 } + { CU_DEVICE_ATTRIBUTE_INTEGRATED 18 } + { CU_DEVICE_ATTRIBUTE_CAN_MAP_HOST_MEMORY 19 } + { CU_DEVICE_ATTRIBUTE_COMPUTE_MODE 20 } + { CU_DEVICE_ATTRIBUTE_MAXIMUM_TEXTURE1D_WIDTH 21 } + { CU_DEVICE_ATTRIBUTE_MAXIMUM_TEXTURE2D_WIDTH 22 } + { CU_DEVICE_ATTRIBUTE_MAXIMUM_TEXTURE2D_HEIGHT 23 } + { CU_DEVICE_ATTRIBUTE_MAXIMUM_TEXTURE3D_WIDTH 24 } + { CU_DEVICE_ATTRIBUTE_MAXIMUM_TEXTURE3D_HEIGHT 25 } + { CU_DEVICE_ATTRIBUTE_MAXIMUM_TEXTURE3D_DEPTH 26 } + { CU_DEVICE_ATTRIBUTE_MAXIMUM_TEXTURE2D_ARRAY_WIDTH 27 } + { CU_DEVICE_ATTRIBUTE_MAXIMUM_TEXTURE2D_ARRAY_HEIGHT 28 } + { CU_DEVICE_ATTRIBUTE_MAXIMUM_TEXTURE2D_ARRAY_NUMSLICES 29 } + { CU_DEVICE_ATTRIBUTE_SURFACE_ALIGNMENT 30 } + { CU_DEVICE_ATTRIBUTE_CONCURRENT_KERNELS 31 } + { CU_DEVICE_ATTRIBUTE_ECC_ENABLED 32 } ; + +STRUCT: CUdevprop + { maxThreadsPerBlock int } + { maxThreadsDim int[3] } + { maxGridSize int[3] } + { sharedMemPerBlock int } + { totalConstantMemory int } + { SIMDWidth int } + { memPitch int } + { regsPerBlock int } + { clockRate int } + { textureAlign int } ; + +C-ENUM: CUfunction_attribute + { CU_FUNC_ATTRIBUTE_MAX_THREADS_PER_BLOCK 0 } + { CU_FUNC_ATTRIBUTE_SHARED_SIZE_BYTES 1 } + { CU_FUNC_ATTRIBUTE_CONST_SIZE_BYTES 2 } + { CU_FUNC_ATTRIBUTE_LOCAL_SIZE_BYTES 3 } + { CU_FUNC_ATTRIBUTE_NUM_REGS 4 } + { CU_FUNC_ATTRIBUTE_PTX_VERSION 5 } + { CU_FUNC_ATTRIBUTE_BINARY_VERSION 6 } + CU_FUNC_ATTRIBUTE_MAX ; + +C-ENUM: CUfunc_cache + { CU_FUNC_CACHE_PREFER_NONE HEX: 00 } + { CU_FUNC_CACHE_PREFER_SHARED HEX: 01 } + { CU_FUNC_CACHE_PREFER_L1 HEX: 02 } ; + +C-ENUM: CUmemorytype + { CU_MEMORYTYPE_HOST HEX: 01 } + { CU_MEMORYTYPE_DEVICE HEX: 02 } + { CU_MEMORYTYPE_ARRAY HEX: 03 } ; + +C-ENUM: CUcomputemode + { CU_COMPUTEMODE_DEFAULT 0 } + { CU_COMPUTEMODE_EXCLUSIVE 1 } + { CU_COMPUTEMODE_PROHIBITED 2 } ; + +C-ENUM: CUjit_option + { CU_JIT_MAX_REGISTERS 0 } + CU_JIT_THREADS_PER_BLOCK + CU_JIT_WALL_TIME + CU_JIT_INFO_LOG_BUFFER + CU_JIT_INFO_LOG_BUFFER_SIZE_BYTES + CU_JIT_ERROR_LOG_BUFFER + CU_JIT_ERROR_LOG_BUFFER_SIZE_BYTES + CU_JIT_OPTIMIZATION_LEVEL + CU_JIT_TARGET_FROM_CUCONTEXT + CU_JIT_TARGET + CU_JIT_FALLBACK_STRATEGY ; + +C-ENUM: CUjit_target + { CU_TARGET_COMPUTE_10 0 } + CU_TARGET_COMPUTE_11 + CU_TARGET_COMPUTE_12 + CU_TARGET_COMPUTE_13 + CU_TARGET_COMPUTE_20 ; + +C-ENUM: CUjit_fallback + { CU_PREFER_PTX 0 } + CU_PREFER_BINARY ; + +C-ENUM: CUgraphicsRegisterFlags + { CU_GRAPHICS_REGISTER_FLAGS_NONE 0 } ; + +C-ENUM: CUgraphicsMapResourceFlags + { CU_GRAPHICS_MAP_RESOURCE_FLAGS_NONE HEX: 00 } + { CU_GRAPHICS_MAP_RESOURCE_FLAGS_READ_ONLY HEX: 01 } + { CU_GRAPHICS_MAP_RESOURCE_FLAGS_WRITE_DISCARD HEX: 02 } ; + +C-ENUM: CUarray_cubemap_face + { CU_CUBEMAP_FACE_POSITIVE_X HEX: 00 } + { CU_CUBEMAP_FACE_NEGATIVE_X HEX: 01 } + { CU_CUBEMAP_FACE_POSITIVE_Y HEX: 02 } + { CU_CUBEMAP_FACE_NEGATIVE_Y HEX: 03 } + { CU_CUBEMAP_FACE_POSITIVE_Z HEX: 04 } + { CU_CUBEMAP_FACE_NEGATIVE_Z HEX: 05 } ; + +C-ENUM: CUresult + { CUDA_SUCCESS 0 } + { CUDA_ERROR_INVALID_VALUE 1 } + { CUDA_ERROR_OUT_OF_MEMORY 2 } + { CUDA_ERROR_NOT_INITIALIZED 3 } + { CUDA_ERROR_DEINITIALIZED 4 } + + { CUDA_ERROR_NO_DEVICE 100 } + { CUDA_ERROR_INVALID_DEVICE 101 } + + { CUDA_ERROR_INVALID_IMAGE 200 } + { CUDA_ERROR_INVALID_CONTEXT 201 } + { CUDA_ERROR_CONTEXT_ALREADY_CURRENT 202 } + { CUDA_ERROR_MAP_FAILED 205 } + { CUDA_ERROR_UNMAP_FAILED 206 } + { CUDA_ERROR_ARRAY_IS_MAPPED 207 } + { CUDA_ERROR_ALREADY_MAPPED 208 } + { CUDA_ERROR_NO_BINARY_FOR_GPU 209 } + { CUDA_ERROR_ALREADY_ACQUIRED 210 } + { CUDA_ERROR_NOT_MAPPED 211 } + { CUDA_ERROR_NOT_MAPPED_AS_ARRAY 212 } + { CUDA_ERROR_NOT_MAPPED_AS_POINTER 213 } + { CUDA_ERROR_ECC_UNCORRECTABLE 214 } + + { CUDA_ERROR_INVALID_SOURCE 300 } + { CUDA_ERROR_FILE_NOT_FOUND 301 } + + { CUDA_ERROR_INVALID_HANDLE 400 } + + { CUDA_ERROR_NOT_FOUND 500 } + + { CUDA_ERROR_NOT_READY 600 } + + { CUDA_ERROR_LAUNCH_FAILED 700 } + { CUDA_ERROR_LAUNCH_OUT_OF_RESOURCES 701 } + { CUDA_ERROR_LAUNCH_TIMEOUT 702 } + { CUDA_ERROR_LAUNCH_INCOMPATIBLE_TEXTURING 703 } + + { CUDA_ERROR_POINTER_IS_64BIT 800 } + { CUDA_ERROR_SIZE_IS_64BIT 801 } + + { CUDA_ERROR_UNKNOWN 999 } ; + +CONSTANT: CU_MEMHOSTALLOC_PORTABLE HEX: 01 +CONSTANT: CU_MEMHOSTALLOC_DEVICEMAP HEX: 02 +CONSTANT: CU_MEMHOSTALLOC_WRITECOMBINED HEX: 04 + +STRUCT: CUDA_MEMCPY2D + { srcXInBytes uint } + { srcY uint } + { srcMemoryType CUmemorytype } + { srcHost void* } + { srcDevice CUdeviceptr } + { srcArray CUarray } + { srcPitch uint } + { dstXInBytes uint } + { dstY uint } + { dstMemoryType CUmemorytype } + { dstHost void* } + { dstDevice CUdeviceptr } + { dstArray CUarray } + { dstPitch uint } + { WidthInBytes uint } + { Height uint } ; + +STRUCT: CUDA_MEMCPY3D + { srcXInBytes uint } + { srcY uint } + { srcZ uint } + { srcLOD uint } + { srcMemoryType CUmemorytype } + { srcHost void* } + { srcDevice CUdeviceptr } + { srcArray CUarray } + { reserved0 void* } + { srcPitch uint } + { srcHeight uint } + { dstXInBytes uint } + { dstY uint } + { dstZ uint } + { dstLOD uint } + { dstMemoryType CUmemorytype } + { dstHost void* } + { dstDevice CUdeviceptr } + { dstArray CUarray } + { reserved1 void* } + { dstPitch uint } + { dstHeight uint } + { WidthInBytes uint } + { Height uint } + { Depth uint } ; + +STRUCT: CUDA_ARRAY_DESCRIPTOR + { Width uint } + { Height uint } + { Format CUarray_format } + { NumChannels uint } ; + +STRUCT: CUDA_ARRAY3D_DESCRIPTOR + { Width uint } + { Height uint } + { Depth uint } + { Format CUarray_format } + { NumChannels uint } + { Flags uint } ; + +CONSTANT: CUDA_ARRAY3D_2DARRAY HEX: 01 +CONSTANT: CU_TRSA_OVERRIDE_FORMAT HEX: 01 +CONSTANT: CU_TRSF_READ_AS_INTEGER HEX: 01 +CONSTANT: CU_TRSF_NORMALIZED_COORDINATES HEX: 02 +CONSTANT: CU_PARAM_TR_DEFAULT -1 + +FUNCTION: CUresult cuInit ( uint Flags ) ; + +FUNCTION: CUresult cuDriverGetVersion ( int* driverVersion ) ; + +FUNCTION: CUresult cuDeviceGet ( CUdevice* device, int ordinal ) ; +FUNCTION: CUresult cuDeviceGetCount ( int* count ) ; +FUNCTION: CUresult cuDeviceGetName ( char* name, int len, CUdevice dev ) ; +FUNCTION: CUresult cuDeviceComputeCapability ( int* major, int* minor, CUdevice dev ) ; +FUNCTION: CUresult cuDeviceTotalMem ( uint* bytes, CUdevice dev ) ; +FUNCTION: CUresult cuDeviceGetProperties ( CUdevprop* prop, CUdevice dev ) ; +FUNCTION: CUresult cuDeviceGetAttribute ( int* pi, CUdevice_attribute attrib, CUdevice dev ) ; + +FUNCTION: CUresult cuCtxCreate ( CUcontext* pctx, uint flags, CUdevice dev ) ; +FUNCTION: CUresult cuCtxDestroy ( CUcontext ctx ) ; +FUNCTION: CUresult cuCtxAttach ( CUcontext* pctx, uint flags ) ; +FUNCTION: CUresult cuCtxDetach ( CUcontext ctx ) ; +FUNCTION: CUresult cuCtxPushCurrent ( CUcontext ctx ) ; +FUNCTION: CUresult cuCtxPopCurrent ( CUcontext* pctx ) ; +FUNCTION: CUresult cuCtxGetDevice ( CUdevice* device ) ; +FUNCTION: CUresult cuCtxSynchronize ( ) ; + +FUNCTION: CUresult cuModuleLoad ( CUmodule* module, char* fname ) ; +FUNCTION: CUresult cuModuleLoadData ( CUmodule* module, void* image ) ; +FUNCTION: CUresult cuModuleLoadDataEx ( CUmodule* module, void* image, uint numOptions, CUjit_option* options, void** optionValues ) ; +FUNCTION: CUresult cuModuleLoadFatBinary ( CUmodule* module, void* fatCubin ) ; +FUNCTION: CUresult cuModuleUnload ( CUmodule hmod ) ; +FUNCTION: CUresult cuModuleGetFunction ( CUfunction* hfunc, CUmodule hmod, char* name ) ; +FUNCTION: CUresult cuModuleGetGlobal ( CUdeviceptr* dptr, uint* bytes, CUmodule hmod, char* name ) ; +FUNCTION: CUresult cuModuleGetTexRef ( CUtexref* pTexRef, CUmodule hmod, char* name ) ; + +FUNCTION: CUresult cuMemGetInfo ( uint* free, uint* total ) ; + +FUNCTION: CUresult cuMemAlloc ( CUdeviceptr* dptr, uint bytesize ) ; +FUNCTION: CUresult cuMemAllocPitch ( CUdeviceptr* dptr, + uint* pPitch, + uint WidthInBytes, + uint Height, + uint ElementSizeBytes + ) ; +FUNCTION: CUresult cuMemFree ( CUdeviceptr dptr ) ; +FUNCTION: CUresult cuMemGetAddressRange ( CUdeviceptr* pbase, uint* psize, CUdeviceptr dptr ) ; + +FUNCTION: CUresult cuMemAllocHost ( void** pp, uint bytesize ) ; +FUNCTION: CUresult cuMemFreeHost ( void* p ) ; + +FUNCTION: CUresult cuMemHostAlloc ( void** pp, size_t bytesize, uint Flags ) ; + +FUNCTION: CUresult cuMemHostGetDevicePointer ( CUdeviceptr* pdptr, void* p, uint Flags ) ; +FUNCTION: CUresult cuMemHostGetFlags ( uint* pFlags, void* p ) ; + +FUNCTION: CUresult cuMemcpyHtoD ( CUdeviceptr dstDevice, void* srcHost, uint ByteCount ) ; +FUNCTION: CUresult cuMemcpyDtoH ( void* dstHost, CUdeviceptr srcDevice, uint ByteCount ) ; + +FUNCTION: CUresult cuMemcpyDtoD ( CUdeviceptr dstDevice, CUdeviceptr srcDevice, uint ByteCount ) ; + +FUNCTION: CUresult cuMemcpyDtoA ( CUarray dstArray, uint dstIndex, CUdeviceptr srcDevice, uint ByteCount ) ; +FUNCTION: CUresult cuMemcpyAtoD ( CUdeviceptr dstDevice, CUarray hSrc, uint SrcIndex, uint ByteCount ) ; + +FUNCTION: CUresult cuMemcpyHtoA ( CUarray dstArray, uint dstIndex, void* pSrc, uint ByteCount ) ; +FUNCTION: CUresult cuMemcpyAtoH ( void* dstHost, CUarray srcArray, uint srcIndex, uint ByteCount ) ; + +FUNCTION: CUresult cuMemcpyAtoA ( CUarray dstArray, uint dstIndex, CUarray srcArray, uint srcIndex, uint ByteCount ) ; + +FUNCTION: CUresult cuMemcpy2D ( CUDA_MEMCPY2D* pCopy ) ; +FUNCTION: CUresult cuMemcpy2DUnaligned ( CUDA_MEMCPY2D* pCopy ) ; + +FUNCTION: CUresult cuMemcpy3D ( CUDA_MEMCPY3D* pCopy ) ; + +FUNCTION: CUresult cuMemcpyHtoDAsync ( CUdeviceptr dstDevice, + void* srcHost, uint ByteCount, CUstream hStream ) ; +FUNCTION: CUresult cuMemcpyDtoHAsync ( void* dstHost, + CUdeviceptr srcDevice, uint ByteCount, CUstream hStream ) ; + +FUNCTION: CUresult cuMemcpyDtoDAsync ( CUdeviceptr dstDevice, + CUdeviceptr srcDevice, uint ByteCount, CUstream hStream ) ; + +FUNCTION: CUresult cuMemcpyHtoAAsync ( CUarray dstArray, uint dstIndex, + void* pSrc, uint ByteCount, CUstream hStream ) ; +FUNCTION: CUresult cuMemcpyAtoHAsync ( void* dstHost, CUarray srcArray, uint srcIndex, + uint ByteCount, CUstream hStream ) ; + +FUNCTION: CUresult cuMemcpy2DAsync ( CUDA_MEMCPY2D* pCopy, CUstream hStream ) ; +FUNCTION: CUresult cuMemcpy3DAsync ( CUDA_MEMCPY3D* pCopy, CUstream hStream ) ; + +FUNCTION: CUresult cuMemsetD8 ( CUdeviceptr dstDevice, uchar uc, uint N ) ; +FUNCTION: CUresult cuMemsetD16 ( CUdeviceptr dstDevice, ushort us, uint N ) ; +FUNCTION: CUresult cuMemsetD32 ( CUdeviceptr dstDevice, uint ui, uint N ) ; + +FUNCTION: CUresult cuMemsetD2D8 ( CUdeviceptr dstDevice, uint dstPitch, uchar uc, uint Width, uint Height ) ; +FUNCTION: CUresult cuMemsetD2D16 ( CUdeviceptr dstDevice, uint dstPitch, ushort us, uint Width, uint Height ) ; +FUNCTION: CUresult cuMemsetD2D32 ( CUdeviceptr dstDevice, uint dstPitch, uint ui, uint Width, uint Height ) ; + +FUNCTION: CUresult cuFuncSetBlockShape ( CUfunction hfunc, int x, int y, int z ) ; +FUNCTION: CUresult cuFuncSetSharedSize ( CUfunction hfunc, uint bytes ) ; +FUNCTION: CUresult cuFuncGetAttribute ( int* pi, CUfunction_attribute attrib, CUfunction hfunc ) ; +FUNCTION: CUresult cuFuncSetCacheConfig ( CUfunction hfunc, CUfunc_cache config ) ; + +FUNCTION: CUresult cuArrayCreate ( CUarray* pHandle, CUDA_ARRAY_DESCRIPTOR* pAllocateArray ) ; +FUNCTION: CUresult cuArrayGetDescriptor ( CUDA_ARRAY_DESCRIPTOR* pArrayDescriptor, CUarray hArray ) ; +FUNCTION: CUresult cuArrayDestroy ( CUarray hArray ) ; + +FUNCTION: CUresult cuArray3DCreate ( CUarray* pHandle, CUDA_ARRAY3D_DESCRIPTOR* pAllocateArray ) ; +FUNCTION: CUresult cuArray3DGetDescriptor ( CUDA_ARRAY3D_DESCRIPTOR* pArrayDescriptor, CUarray hArray ) ; + +FUNCTION: CUresult cuTexRefCreate ( CUtexref* pTexRef ) ; +FUNCTION: CUresult cuTexRefDestroy ( CUtexref hTexRef ) ; + +FUNCTION: CUresult cuTexRefSetArray ( CUtexref hTexRef, CUarray hArray, uint Flags ) ; +FUNCTION: CUresult cuTexRefSetAddress ( uint* ByteOffset, CUtexref hTexRef, CUdeviceptr dptr, uint bytes ) ; +FUNCTION: CUresult cuTexRefSetAddress2D ( CUtexref hTexRef, CUDA_ARRAY_DESCRIPTOR* desc, CUdeviceptr dptr, uint Pitch ) ; +FUNCTION: CUresult cuTexRefSetFormat ( CUtexref hTexRef, CUarray_format fmt, int NumPackedComponents ) ; +FUNCTION: CUresult cuTexRefSetAddressMode ( CUtexref hTexRef, int dim, CUaddress_mode am ) ; +FUNCTION: CUresult cuTexRefSetFilterMode ( CUtexref hTexRef, CUfilter_mode fm ) ; +FUNCTION: CUresult cuTexRefSetFlags ( CUtexref hTexRef, uint Flags ) ; + +FUNCTION: CUresult cuTexRefGetAddress ( CUdeviceptr* pdptr, CUtexref hTexRef ) ; +FUNCTION: CUresult cuTexRefGetArray ( CUarray* phArray, CUtexref hTexRef ) ; +FUNCTION: CUresult cuTexRefGetAddressMode ( CUaddress_mode* pam, CUtexref hTexRef, int dim ) ; +FUNCTION: CUresult cuTexRefGetFilterMode ( CUfilter_mode* pfm, CUtexref hTexRef ) ; +FUNCTION: CUresult cuTexRefGetFormat ( CUarray_format* pFormat, int* pNumChannels, CUtexref hTexRef ) ; +FUNCTION: CUresult cuTexRefGetFlags ( uint* pFlags, CUtexref hTexRef ) ; + +FUNCTION: CUresult cuParamSetSize ( CUfunction hfunc, uint numbytes ) ; +FUNCTION: CUresult cuParamSeti ( CUfunction hfunc, int offset, uint value ) ; +FUNCTION: CUresult cuParamSetf ( CUfunction hfunc, int offset, float value ) ; +FUNCTION: CUresult cuParamSetv ( CUfunction hfunc, int offset, void* ptr, uint numbytes ) ; +FUNCTION: CUresult cuParamSetTexRef ( CUfunction hfunc, int texunit, CUtexref hTexRef ) ; + +FUNCTION: CUresult cuLaunch ( CUfunction f ) ; +FUNCTION: CUresult cuLaunchGrid ( CUfunction f, int grid_width, int grid_height ) ; +FUNCTION: CUresult cuLaunchGridAsync ( CUfunction f, int grid_width, int grid_height, CUstream hStream ) ; + +FUNCTION: CUresult cuEventCreate ( CUevent* phEvent, uint Flags ) ; +FUNCTION: CUresult cuEventRecord ( CUevent hEvent, CUstream hStream ) ; +FUNCTION: CUresult cuEventQuery ( CUevent hEvent ) ; +FUNCTION: CUresult cuEventSynchronize ( CUevent hEvent ) ; +FUNCTION: CUresult cuEventDestroy ( CUevent hEvent ) ; +FUNCTION: CUresult cuEventElapsedTime ( float* pMilliseconds, CUevent hStart, CUevent hEnd ) ; + +FUNCTION: CUresult cuStreamCreate ( CUstream* phStream, uint Flags ) ; +FUNCTION: CUresult cuStreamQuery ( CUstream hStream ) ; +FUNCTION: CUresult cuStreamSynchronize ( CUstream hStream ) ; +FUNCTION: CUresult cuStreamDestroy ( CUstream hStream ) ; + +FUNCTION: CUresult cuGraphicsUnregisterResource ( CUgraphicsResource resource ) ; +FUNCTION: CUresult cuGraphicsSubResourceGetMappedArray ( CUarray* pArray, CUgraphicsResource resource, uint arrayIndex, uint mipLevel ) ; +FUNCTION: CUresult cuGraphicsResourceGetMappedPointer ( CUdeviceptr* pDevPtr, uint* pSize, CUgraphicsResource resource ) ; +FUNCTION: CUresult cuGraphicsResourceSetMapFlags ( CUgraphicsResource resource, uint flags ) ; +FUNCTION: CUresult cuGraphicsMapResources ( uint count, CUgraphicsResource* resources, CUstream hStream ) ; +FUNCTION: CUresult cuGraphicsUnmapResources ( uint count, CUgraphicsResource* resources, CUstream hStream ) ; + +FUNCTION: CUresult cuGetExportTable ( void** ppExportTable, CUuuid* pExportTableId ) ; +