extra/cuda/ffi/ffi.factor

   1 ! Copyright (C) 2010 Joe Groff.
   2 ! See http://factorcode.org/license.txt for BSD license.
   3 USING: accessors alien alien.c-types alien.libraries alien.syntax
   4 classes.struct combinators kernel system ;
   5 IN: cuda.ffi
   6
   7 LIBRARY-UNIX: cuda cdecl "libcuda.so"
   8 LIBRARY-MACOSX: cuda cdecl "/usr/local/cuda/lib/libcuda.dylib"
   9 LIBRARY-WINDOWS: cuda stdcall "nvcuda.dll"
  10
  11 LIBRARY: cuda
  12
  13 TYPEDEF: uint CUdeviceptr
  14 TYPEDEF: int CUdevice
  15 TYPEDEF: void* CUcontext
  16 TYPEDEF: void* CUmodule
  17 TYPEDEF: void* CUfunction
  18 TYPEDEF: void* CUarray
  19 TYPEDEF: void* CUtexref
  20 TYPEDEF: void* CUevent
  21 TYPEDEF: void* CUstream
  22 TYPEDEF: void* CUgraphicsResource
  23
  24 ! versions of double and longlong that always 8-byte align
  25
  26 SYMBOLS: CUdouble CUlonglong CUulonglong ;
  27
  28 <<
  29 : always-8-byte-align ( c-type -- c-type )
  30     8 >>align 8 >>align-first ;
  31
  32 longlong  lookup-c-type clone always-8-byte-align \ CUlonglong  typedef
  33 ulonglong lookup-c-type clone always-8-byte-align \ CUulonglong typedef
  34 double    lookup-c-type clone always-8-byte-align \ CUdouble    typedef
  35 >>
  36
  37 STRUCT: CUuuid
  38     { bytes char[16] } ;
  39
  40 ENUM: CUctx_flags
  41     { CU_CTX_SCHED_AUTO  0 }
  42     { CU_CTX_SCHED_SPIN  1 }
  43     { CU_CTX_SCHED_YIELD 2 }
  44     { CU_CTX_SCHED_MASK  3 }
  45     { CU_CTX_BLOCKING_SYNC 4 }
  46     { CU_CTX_MAP_HOST      8 }
  47     { CU_CTX_LMEM_RESIZE_TO_MAX 16 }
  48     { CU_CTX_FLAGS_MASK  0x1f } ;
  49
  50 ENUM: CUevent_flags
  51     { CU_EVENT_DEFAULT       0 }
  52     { CU_EVENT_BLOCKING_SYNC 1 } ;
  53
  54 ENUM: CUarray_format
  55     { CU_AD_FORMAT_UNSIGNED_INT8  0x01 }
  56     { CU_AD_FORMAT_UNSIGNED_INT16 0x02 }
  57     { CU_AD_FORMAT_UNSIGNED_INT32 0x03 }
  58     { CU_AD_FORMAT_SIGNED_INT8    0x08 }
  59     { CU_AD_FORMAT_SIGNED_INT16   0x09 }
  60     { CU_AD_FORMAT_SIGNED_INT32   0x0a }
  61     { CU_AD_FORMAT_HALF           0x10 }
  62     { CU_AD_FORMAT_FLOAT          0x20 } ;
  63
  64 ENUM: CUaddress_mode
  65     { CU_TR_ADDRESS_MODE_WRAP   0 }
  66     { CU_TR_ADDRESS_MODE_CLAMP  1 }
  67     { CU_TR_ADDRESS_MODE_MIRROR 2 } ;
  68
  69 ENUM: CUfilter_mode
  70     { CU_TR_FILTER_MODE_POINT  0 }
  71     { CU_TR_FILTER_MODE_LINEAR 1 } ;
  72
  73 ENUM: CUdevice_attribute
  74     { CU_DEVICE_ATTRIBUTE_MAX_THREADS_PER_BLOCK 1 }
  75     { CU_DEVICE_ATTRIBUTE_MAX_BLOCK_DIM_X 2 }
  76     { CU_DEVICE_ATTRIBUTE_MAX_BLOCK_DIM_Y 3 }
  77     { CU_DEVICE_ATTRIBUTE_MAX_BLOCK_DIM_Z 4 }
  78     { CU_DEVICE_ATTRIBUTE_MAX_GRID_DIM_X 5 }
  79     { CU_DEVICE_ATTRIBUTE_MAX_GRID_DIM_Y 6 }
  80     { CU_DEVICE_ATTRIBUTE_MAX_GRID_DIM_Z 7 }
  81     { CU_DEVICE_ATTRIBUTE_MAX_SHARED_MEMORY_PER_BLOCK 8 }
  82     { CU_DEVICE_ATTRIBUTE_SHARED_MEMORY_PER_BLOCK 8 }
  83     { CU_DEVICE_ATTRIBUTE_TOTAL_CONSTANT_MEMORY 9 }
  84     { CU_DEVICE_ATTRIBUTE_WARP_SIZE 10 }
  85     { CU_DEVICE_ATTRIBUTE_MAX_PITCH 11 }
  86     { CU_DEVICE_ATTRIBUTE_MAX_REGISTERS_PER_BLOCK 12 }
  87     { CU_DEVICE_ATTRIBUTE_REGISTERS_PER_BLOCK 12 }
  88     { CU_DEVICE_ATTRIBUTE_CLOCK_RATE 13 }
  89     { CU_DEVICE_ATTRIBUTE_TEXTURE_ALIGNMENT 14 }
  90
  91     { CU_DEVICE_ATTRIBUTE_GPU_OVERLAP 15 }
  92     { CU_DEVICE_ATTRIBUTE_MULTIPROCESSOR_COUNT 16 }
  93     { CU_DEVICE_ATTRIBUTE_KERNEL_EXEC_TIMEOUT 17 }
  94     { CU_DEVICE_ATTRIBUTE_INTEGRATED 18 }
  95     { CU_DEVICE_ATTRIBUTE_CAN_MAP_HOST_MEMORY 19 }
  96     { CU_DEVICE_ATTRIBUTE_COMPUTE_MODE 20 }
  97     { CU_DEVICE_ATTRIBUTE_MAXIMUM_TEXTURE1D_WIDTH 21 }
  98     { CU_DEVICE_ATTRIBUTE_MAXIMUM_TEXTURE2D_WIDTH 22 }
  99     { CU_DEVICE_ATTRIBUTE_MAXIMUM_TEXTURE2D_HEIGHT 23 }
 100     { CU_DEVICE_ATTRIBUTE_MAXIMUM_TEXTURE3D_WIDTH 24 }
 101     { CU_DEVICE_ATTRIBUTE_MAXIMUM_TEXTURE3D_HEIGHT 25 }
 102     { CU_DEVICE_ATTRIBUTE_MAXIMUM_TEXTURE3D_DEPTH 26 }
 103     { CU_DEVICE_ATTRIBUTE_MAXIMUM_TEXTURE2D_ARRAY_WIDTH 27 }
 104     { CU_DEVICE_ATTRIBUTE_MAXIMUM_TEXTURE2D_ARRAY_HEIGHT 28 }
 105     { CU_DEVICE_ATTRIBUTE_MAXIMUM_TEXTURE2D_ARRAY_NUMSLICES 29 }
 106     { CU_DEVICE_ATTRIBUTE_SURFACE_ALIGNMENT 30 }
 107     { CU_DEVICE_ATTRIBUTE_CONCURRENT_KERNELS 31 }
 108     { CU_DEVICE_ATTRIBUTE_ECC_ENABLED 32 } ;
 109
 110 STRUCT: CUdevprop
 111     { maxThreadsPerBlock int }
 112     { maxThreadsDim int[3] }
 113     { maxGridSize int[3] }
 114     { sharedMemPerBlock int }
 115     { totalConstantMemory int }
 116     { SIMDWidth int }
 117     { memPitch int }
 118     { regsPerBlock int }
 119     { clockRate int }
 120     { textureAlign int } ;
 121
 122 ENUM: CUfunction_attribute
 123     { CU_FUNC_ATTRIBUTE_MAX_THREADS_PER_BLOCK 0 }
 124     { CU_FUNC_ATTRIBUTE_SHARED_SIZE_BYTES 1     }
 125     { CU_FUNC_ATTRIBUTE_CONST_SIZE_BYTES 2      }
 126     { CU_FUNC_ATTRIBUTE_LOCAL_SIZE_BYTES 3      }
 127     { CU_FUNC_ATTRIBUTE_NUM_REGS 4              }
 128     { CU_FUNC_ATTRIBUTE_PTX_VERSION 5           }
 129     { CU_FUNC_ATTRIBUTE_BINARY_VERSION 6        }
 130     CU_FUNC_ATTRIBUTE_MAX ;
 131
 132 ENUM: CUfunc_cache
 133     { CU_FUNC_CACHE_PREFER_NONE   0x00 }
 134     { CU_FUNC_CACHE_PREFER_SHARED 0x01 }
 135     { CU_FUNC_CACHE_PREFER_L1     0x02 } ;
 136
 137 ENUM: CUmemorytype
 138     { CU_MEMORYTYPE_HOST   0x01 }
 139     { CU_MEMORYTYPE_DEVICE 0x02 }
 140     { CU_MEMORYTYPE_ARRAY  0x03 } ;
 141
 142 ENUM: CUcomputemode
 143     { CU_COMPUTEMODE_DEFAULT    0 }
 144     { CU_COMPUTEMODE_EXCLUSIVE  1 }
 145     { CU_COMPUTEMODE_PROHIBITED 2 } ;
 146
 147 ENUM: CUjit_option
 148     { CU_JIT_MAX_REGISTERS 0 }
 149     CU_JIT_THREADS_PER_BLOCK
 150     CU_JIT_WALL_TIME
 151     CU_JIT_INFO_LOG_BUFFER
 152     CU_JIT_INFO_LOG_BUFFER_SIZE_BYTES
 153     CU_JIT_ERROR_LOG_BUFFER
 154     CU_JIT_ERROR_LOG_BUFFER_SIZE_BYTES
 155     CU_JIT_OPTIMIZATION_LEVEL
 156     CU_JIT_TARGET_FROM_CUCONTEXT
 157     CU_JIT_TARGET
 158     CU_JIT_FALLBACK_STRATEGY ;
 159
 160 ENUM: CUjit_target
 161     { CU_TARGET_COMPUTE_10 0 }
 162     CU_TARGET_COMPUTE_11
 163     CU_TARGET_COMPUTE_12
 164     CU_TARGET_COMPUTE_13
 165     CU_TARGET_COMPUTE_20 ;
 166
 167 ENUM: CUjit_fallback
 168     { CU_PREFER_PTX 0 }
 169     CU_PREFER_BINARY ;
 170
 171 ENUM: CUgraphicsRegisterFlags
 172     { CU_GRAPHICS_REGISTER_FLAGS_NONE 0 } ;
 173
 174 ENUM: CUgraphicsMapResourceFlags
 175     { CU_GRAPHICS_MAP_RESOURCE_FLAGS_NONE          0x00 }
 176     { CU_GRAPHICS_MAP_RESOURCE_FLAGS_READ_ONLY     0x01 }
 177     { CU_GRAPHICS_MAP_RESOURCE_FLAGS_WRITE_DISCARD 0x02 } ;
 178
 179 ENUM: CUarray_cubemap_face
 180     { CU_CUBEMAP_FACE_POSITIVE_X  0x00 }
 181     { CU_CUBEMAP_FACE_NEGATIVE_X  0x01 }
 182     { CU_CUBEMAP_FACE_POSITIVE_Y  0x02 }
 183     { CU_CUBEMAP_FACE_NEGATIVE_Y  0x03 }
 184     { CU_CUBEMAP_FACE_POSITIVE_Z  0x04 }
 185     { CU_CUBEMAP_FACE_NEGATIVE_Z  0x05 } ;
 186
 187 ENUM: CUresult
 188     { CUDA_SUCCESS                    0 }
 189     { CUDA_ERROR_INVALID_VALUE        1 }
 190     { CUDA_ERROR_OUT_OF_MEMORY        2 }
 191     { CUDA_ERROR_NOT_INITIALIZED      3 }
 192     { CUDA_ERROR_DEINITIALIZED        4 }
 193
 194     { CUDA_ERROR_NO_DEVICE            100 }
 195     { CUDA_ERROR_INVALID_DEVICE       101 }
 196
 197     { CUDA_ERROR_INVALID_IMAGE        200 }
 198     { CUDA_ERROR_INVALID_CONTEXT      201 }
 199     { CUDA_ERROR_CONTEXT_ALREADY_CURRENT 202 }
 200     { CUDA_ERROR_MAP_FAILED           205 }
 201     { CUDA_ERROR_UNMAP_FAILED         206 }
 202     { CUDA_ERROR_ARRAY_IS_MAPPED      207 }
 203     { CUDA_ERROR_ALREADY_MAPPED       208 }
 204     { CUDA_ERROR_NO_BINARY_FOR_GPU    209 }
 205     { CUDA_ERROR_ALREADY_ACQUIRED     210 }
 206     { CUDA_ERROR_NOT_MAPPED           211 }
 207     { CUDA_ERROR_NOT_MAPPED_AS_ARRAY  212 }
 208     { CUDA_ERROR_NOT_MAPPED_AS_POINTER 213 }
 209     { CUDA_ERROR_ECC_UNCORRECTABLE    214 }
 210
 211     { CUDA_ERROR_INVALID_SOURCE       300 }
 212     { CUDA_ERROR_FILE_NOT_FOUND       301 }
 213
 214     { CUDA_ERROR_INVALID_HANDLE       400 }
 215
 216     { CUDA_ERROR_NOT_FOUND            500 }
 217
 218     { CUDA_ERROR_NOT_READY            600 }
 219
 220     { CUDA_ERROR_LAUNCH_FAILED        700 }
 221     { CUDA_ERROR_LAUNCH_OUT_OF_RESOURCES 701 }
 222     { CUDA_ERROR_LAUNCH_TIMEOUT       702 }
 223     { CUDA_ERROR_LAUNCH_INCOMPATIBLE_TEXTURING 703 }
 224
 225     { CUDA_ERROR_POINTER_IS_64BIT     800 }
 226     { CUDA_ERROR_SIZE_IS_64BIT        801 }
 227
 228     { CUDA_ERROR_UNKNOWN              999 } ;
 229
 230 CONSTANT: CU_MEMHOSTALLOC_PORTABLE        0x01
 231 CONSTANT: CU_MEMHOSTALLOC_DEVICEMAP       0x02
 232 CONSTANT: CU_MEMHOSTALLOC_WRITECOMBINED   0x04
 233
 234 STRUCT: CUDA_MEMCPY2D
 235     { srcXInBytes uint }
 236     { srcY        uint }
 237     { srcMemoryType CUmemorytype }
 238     { srcHost void* }
 239     { srcDevice CUdeviceptr }
 240     { srcArray CUarray }
 241     { srcPitch uint }
 242     { dstXInBytes uint }
 243     { dstY uint }
 244     { dstMemoryType CUmemorytype }
 245     { dstHost void* }
 246     { dstDevice CUdeviceptr }
 247     { dstArray CUarray }
 248     { dstPitch uint }
 249     { WidthInBytes uint }
 250     { Height uint } ;
 251
 252 STRUCT: CUDA_MEMCPY3D
 253     { srcXInBytes uint }
 254     { srcY        uint }
 255     { srcZ        uint }
 256     { srcLOD      uint }
 257     { srcMemoryType CUmemorytype }
 258     { srcHost void* }
 259     { srcDevice CUdeviceptr }
 260     { srcArray CUarray }
 261     { reserved0 void* }
 262     { srcPitch uint }
 263     { srcHeight uint }
 264     { dstXInBytes uint }
 265     { dstY uint }
 266     { dstZ uint }
 267     { dstLOD uint }
 268     { dstMemoryType CUmemorytype }
 269     { dstHost void* }
 270     { dstDevice CUdeviceptr }
 271     { dstArray CUarray }
 272     { reserved1 void* }
 273     { dstPitch uint }
 274     { dstHeight uint }
 275     { WidthInBytes uint }
 276     { Height uint }
 277     { Depth uint } ;
 278
 279 STRUCT: CUDA_ARRAY_DESCRIPTOR
 280     { Width uint }
 281     { Height uint }
 282     { Format CUarray_format }
 283     { NumChannels uint } ;
 284
 285 STRUCT: CUDA_ARRAY3D_DESCRIPTOR
 286     { Width uint }
 287     { Height uint }
 288     { Depth uint }
 289     { Format CUarray_format }
 290     { NumChannels uint }
 291     { Flags uint } ;
 292
 293 CONSTANT: CUDA_ARRAY3D_2DARRAY    0x01
 294 CONSTANT: CU_TRSA_OVERRIDE_FORMAT 0x01
 295 CONSTANT: CU_TRSF_READ_AS_INTEGER         0x01
 296 CONSTANT: CU_TRSF_NORMALIZED_COORDINATES  0x02
 297 CONSTANT: CU_PARAM_TR_DEFAULT -1
 298
 299 FUNCTION: CUresult cuInit ( uint Flags )
 300
 301 FUNCTION: CUresult cuDriverGetVersion ( int* driverVersion )
 302
 303 FUNCTION: CUresult cuDeviceGet ( CUdevice* device, int ordinal )
 304 FUNCTION: CUresult cuDeviceGetCount ( int* count )
 305 FUNCTION: CUresult cuDeviceGetName ( char* name, int len, CUdevice dev )
 306 FUNCTION: CUresult cuDeviceComputeCapability ( int* major, int* minor, CUdevice dev )
 307 FUNCTION: CUresult cuDeviceTotalMem ( uint* bytes, CUdevice dev )
 308 FUNCTION: CUresult cuDeviceTotalMem_v2 ( ulonglong* bytes, CUdevice dev )
 309 FUNCTION: CUresult cuDeviceGetProperties ( CUdevprop* prop, CUdevice dev )
 310 FUNCTION: CUresult cuDeviceGetAttribute ( int* pi, CUdevice_attribute attrib, CUdevice dev )
 311
 312 FUNCTION: CUresult cuCtxCreate ( CUcontext* pctx, uint flags, CUdevice dev )
 313 FUNCTION: CUresult cuCtxDestroy ( CUcontext ctx )
 314 FUNCTION: CUresult cuCtxAttach ( CUcontext* pctx, uint flags )
 315 FUNCTION: CUresult cuCtxDetach ( CUcontext ctx )
 316 FUNCTION: CUresult cuCtxPushCurrent ( CUcontext ctx )
 317 FUNCTION: CUresult cuCtxPopCurrent ( CUcontext* pctx )
 318 FUNCTION: CUresult cuCtxGetDevice ( CUdevice* device )
 319 FUNCTION: CUresult cuCtxSynchronize ( )
 320
 321 FUNCTION: CUresult cuModuleLoad ( CUmodule* module, c-string fname )
 322 FUNCTION: CUresult cuModuleLoadData ( CUmodule* module, void* image )
 323 FUNCTION: CUresult cuModuleLoadDataEx ( CUmodule* module, void* image, uint numOptions, CUjit_option* options, void** optionValues )
 324 FUNCTION: CUresult cuModuleLoadFatBinary ( CUmodule* module, void* fatCubin )
 325 FUNCTION: CUresult cuModuleUnload ( CUmodule hmod )
 326 FUNCTION: CUresult cuModuleGetFunction ( CUfunction* hfunc, CUmodule hmod, c-string name )
 327 FUNCTION: CUresult cuModuleGetGlobal ( CUdeviceptr* dptr, uint* bytes, CUmodule hmod, char* name )
 328 FUNCTION: CUresult cuModuleGetTexRef ( CUtexref* pTexRef, CUmodule hmod, char* name )
 329
 330 FUNCTION: CUresult cuMemGetInfo ( uint* free, uint* total )
 331
 332 FUNCTION: CUresult cuMemAlloc ( CUdeviceptr* dptr, uint bytesize )
 333 FUNCTION: CUresult cuMemAllocPitch ( CUdeviceptr* dptr,
 334                                       uint* pPitch,
 335                                       uint WidthInBytes,
 336                                       uint Height,
 337                                       uint ElementSizeBytes
 338                                      )
 339 FUNCTION: CUresult cuMemFree ( CUdeviceptr dptr )
 340 FUNCTION: CUresult cuMemGetAddressRange ( CUdeviceptr* pbase, uint* psize, CUdeviceptr dptr )
 341
 342 FUNCTION: CUresult cuMemAllocHost ( void** pp, uint bytesize )
 343 FUNCTION: CUresult cuMemFreeHost ( void* p )
 344
 345 FUNCTION: CUresult cuMemHostAlloc ( void** pp, size_t bytesize, uint Flags )
 346
 347 FUNCTION: CUresult cuMemHostGetDevicePointer ( CUdeviceptr* pdptr, void* p, uint Flags )
 348 FUNCTION: CUresult cuMemHostGetFlags ( uint* pFlags, void* p )
 349
 350 FUNCTION: CUresult  cuMemcpyHtoD ( CUdeviceptr dstDevice, void* srcHost, uint ByteCount )
 351 FUNCTION: CUresult  cuMemcpyDtoH ( void* dstHost, CUdeviceptr srcDevice, uint ByteCount )
 352
 353 FUNCTION: CUresult  cuMemcpyDtoD ( CUdeviceptr dstDevice, CUdeviceptr srcDevice, uint ByteCount )
 354
 355 FUNCTION: CUresult  cuMemcpyDtoA ( CUarray dstArray, uint dstIndex, CUdeviceptr srcDevice, uint ByteCount )
 356 FUNCTION: CUresult  cuMemcpyAtoD ( CUdeviceptr dstDevice, CUarray hSrc, uint SrcIndex, uint ByteCount )
 357
 358 FUNCTION: CUresult  cuMemcpyHtoA ( CUarray dstArray, uint dstIndex, void* pSrc, uint ByteCount )
 359 FUNCTION: CUresult  cuMemcpyAtoH ( void* dstHost, CUarray srcArray, uint srcIndex, uint ByteCount )
 360
 361 FUNCTION: CUresult  cuMemcpyAtoA ( CUarray dstArray, uint dstIndex, CUarray srcArray, uint srcIndex, uint ByteCount )
 362
 363 FUNCTION: CUresult  cuMemcpy2D ( CUDA_MEMCPY2D* pCopy )
 364 FUNCTION: CUresult  cuMemcpy2DUnaligned ( CUDA_MEMCPY2D* pCopy )
 365
 366 FUNCTION: CUresult  cuMemcpy3D ( CUDA_MEMCPY3D* pCopy )
 367
 368 FUNCTION: CUresult  cuMemcpyHtoDAsync ( CUdeviceptr dstDevice,
 369             void* srcHost, uint ByteCount, CUstream hStream )
 370 FUNCTION: CUresult  cuMemcpyDtoHAsync ( void* dstHost,
 371             CUdeviceptr srcDevice, uint ByteCount, CUstream hStream )
 372
 373 FUNCTION: CUresult cuMemcpyDtoDAsync ( CUdeviceptr dstDevice,
 374             CUdeviceptr srcDevice, uint ByteCount, CUstream hStream )
 375
 376 FUNCTION: CUresult  cuMemcpyHtoAAsync ( CUarray dstArray, uint dstIndex,
 377             void* pSrc, uint ByteCount, CUstream hStream )
 378 FUNCTION: CUresult  cuMemcpyAtoHAsync ( void* dstHost, CUarray srcArray, uint srcIndex,
 379             uint ByteCount, CUstream hStream )
 380
 381 FUNCTION: CUresult  cuMemcpy2DAsync ( CUDA_MEMCPY2D* pCopy, CUstream hStream )
 382 FUNCTION: CUresult  cuMemcpy3DAsync ( CUDA_MEMCPY3D* pCopy, CUstream hStream )
 383
 384 FUNCTION: CUresult  cuMemsetD8 ( CUdeviceptr dstDevice, uchar uc, uint N )
 385 FUNCTION: CUresult  cuMemsetD16 ( CUdeviceptr dstDevice, ushort us, uint N )
 386 FUNCTION: CUresult  cuMemsetD32 ( CUdeviceptr dstDevice, uint ui, uint N )
 387
 388 FUNCTION: CUresult  cuMemsetD2D8 ( CUdeviceptr dstDevice, uint dstPitch, uchar uc, uint Width, uint Height )
 389 FUNCTION: CUresult  cuMemsetD2D16 ( CUdeviceptr dstDevice, uint dstPitch, ushort us, uint Width, uint Height )
 390 FUNCTION: CUresult  cuMemsetD2D32 ( CUdeviceptr dstDevice, uint dstPitch, uint ui, uint Width, uint Height )
 391
 392 FUNCTION: CUresult cuFuncSetBlockShape ( CUfunction hfunc, int x, int y, int z )
 393 FUNCTION: CUresult cuFuncSetSharedSize ( CUfunction hfunc, uint bytes )
 394 FUNCTION: CUresult cuFuncGetAttribute ( int* pi, CUfunction_attribute attrib, CUfunction hfunc )
 395 FUNCTION: CUresult cuFuncSetCacheConfig ( CUfunction hfunc, CUfunc_cache config )
 396
 397 FUNCTION: CUresult  cuArrayCreate ( CUarray* pHandle, CUDA_ARRAY_DESCRIPTOR* pAllocateArray )
 398 FUNCTION: CUresult  cuArrayGetDescriptor ( CUDA_ARRAY_DESCRIPTOR* pArrayDescriptor, CUarray hArray )
 399 FUNCTION: CUresult  cuArrayDestroy ( CUarray hArray )
 400
 401 FUNCTION: CUresult  cuArray3DCreate ( CUarray* pHandle, CUDA_ARRAY3D_DESCRIPTOR* pAllocateArray )
 402 FUNCTION: CUresult  cuArray3DGetDescriptor ( CUDA_ARRAY3D_DESCRIPTOR* pArrayDescriptor, CUarray hArray )
 403
 404 FUNCTION: CUresult  cuTexRefCreate ( CUtexref* pTexRef )
 405 FUNCTION: CUresult  cuTexRefDestroy ( CUtexref hTexRef )
 406
 407 FUNCTION: CUresult  cuTexRefSetArray ( CUtexref hTexRef, CUarray hArray, uint Flags )
 408 FUNCTION: CUresult  cuTexRefSetAddress ( uint* ByteOffset, CUtexref hTexRef, CUdeviceptr dptr, uint bytes )
 409 FUNCTION: CUresult  cuTexRefSetAddress2D ( CUtexref hTexRef, CUDA_ARRAY_DESCRIPTOR* desc, CUdeviceptr dptr, uint Pitch )
 410 FUNCTION: CUresult  cuTexRefSetFormat ( CUtexref hTexRef, CUarray_format fmt, int NumPackedComponents )
 411 FUNCTION: CUresult  cuTexRefSetAddressMode ( CUtexref hTexRef, int dim, CUaddress_mode am )
 412 FUNCTION: CUresult  cuTexRefSetFilterMode ( CUtexref hTexRef, CUfilter_mode fm )
 413 FUNCTION: CUresult  cuTexRefSetFlags ( CUtexref hTexRef, uint Flags )
 414
 415 FUNCTION: CUresult  cuTexRefGetAddress ( CUdeviceptr* pdptr, CUtexref hTexRef )
 416 FUNCTION: CUresult  cuTexRefGetArray ( CUarray* phArray, CUtexref hTexRef )
 417 FUNCTION: CUresult  cuTexRefGetAddressMode ( CUaddress_mode* pam, CUtexref hTexRef, int dim )
 418 FUNCTION: CUresult  cuTexRefGetFilterMode ( CUfilter_mode* pfm, CUtexref hTexRef )
 419 FUNCTION: CUresult  cuTexRefGetFormat ( CUarray_format* pFormat, int* pNumChannels, CUtexref hTexRef )
 420 FUNCTION: CUresult  cuTexRefGetFlags ( uint* pFlags, CUtexref hTexRef )
 421
 422 FUNCTION: CUresult  cuParamSetSize ( CUfunction hfunc, uint numbytes )
 423 FUNCTION: CUresult  cuParamSeti    ( CUfunction hfunc, int offset, uint value )
 424 FUNCTION: CUresult  cuParamSetf    ( CUfunction hfunc, int offset, float value )
 425 FUNCTION: CUresult  cuParamSetv    ( CUfunction hfunc, int offset, void* ptr, uint numbytes )
 426 FUNCTION: CUresult  cuParamSetTexRef ( CUfunction hfunc, int texunit, CUtexref hTexRef )
 427
 428 FUNCTION: CUresult cuLaunch ( CUfunction f )
 429 FUNCTION: CUresult cuLaunchGrid ( CUfunction f, int grid_width, int grid_height )
 430 FUNCTION: CUresult cuLaunchGridAsync ( CUfunction f, int grid_width, int grid_height, CUstream hStream )
 431
 432 FUNCTION: CUresult cuEventCreate ( CUevent* phEvent, uint Flags )
 433 FUNCTION: CUresult cuEventRecord ( CUevent hEvent, CUstream hStream )
 434 FUNCTION: CUresult cuEventQuery ( CUevent hEvent )
 435 FUNCTION: CUresult cuEventSynchronize ( CUevent hEvent )
 436 FUNCTION: CUresult cuEventDestroy ( CUevent hEvent )
 437 FUNCTION: CUresult cuEventElapsedTime ( float* pMilliseconds, CUevent hStart, CUevent hEnd )
 438
 439 FUNCTION: CUresult  cuStreamCreate ( CUstream* phStream, uint Flags )
 440 FUNCTION: CUresult  cuStreamQuery ( CUstream hStream )
 441 FUNCTION: CUresult  cuStreamSynchronize ( CUstream hStream )
 442 FUNCTION: CUresult  cuStreamDestroy ( CUstream hStream )
 443
 444 FUNCTION: CUresult cuGraphicsUnregisterResource ( CUgraphicsResource resource )
 445 FUNCTION: CUresult cuGraphicsSubResourceGetMappedArray ( CUarray* pArray, CUgraphicsResource resource, uint arrayIndex, uint mipLevel )
 446 FUNCTION: CUresult cuGraphicsResourceGetMappedPointer ( CUdeviceptr* pDevPtr, uint* pSize, CUgraphicsResource resource )
 447 FUNCTION: CUresult cuGraphicsResourceSetMapFlags ( CUgraphicsResource resource, uint flags )
 448 FUNCTION: CUresult cuGraphicsMapResources ( uint count, CUgraphicsResource* resources, CUstream hStream )
 449 FUNCTION: CUresult cuGraphicsUnmapResources ( uint count, CUgraphicsResource* resources, CUstream hStream )
 450
 451 FUNCTION: CUresult cuGetExportTable ( void** ppExportTable, CUuuid* pExportTableId )