java.lang.Object
- org.bytedeco.cuda.presets.cudart
- - org.bytedeco.cuda.global.cudart

All Implemented Interfaces:

InfoMapper
```
public class cudart
extends cudart
```

Field Summary

Fields
Modifier and Type	Field	Description
`static int`	`__CUDA_API_VERSION`	CUDA API versioning support
`static int`	`CU_AD_FORMAT_FLOAT`	enum CUarray_format
`static int`	`CU_AD_FORMAT_HALF`	enum CUarray_format
`static int`	`CU_AD_FORMAT_SIGNED_INT16`	enum CUarray_format
`static int`	`CU_AD_FORMAT_SIGNED_INT32`	enum CUarray_format
`static int`	`CU_AD_FORMAT_SIGNED_INT8`	enum CUarray_format
`static int`	`CU_AD_FORMAT_UNSIGNED_INT16`	enum CUarray_format
`static int`	`CU_AD_FORMAT_UNSIGNED_INT32`	enum CUarray_format
`static int`	`CU_AD_FORMAT_UNSIGNED_INT8`	enum CUarray_format
`static int`	`CU_COMPUTEMODE_DEFAULT`	enum CUcomputemode
`static int`	`CU_COMPUTEMODE_EXCLUSIVE_PROCESS`	enum CUcomputemode
`static int`	`CU_COMPUTEMODE_PROHIBITED`	enum CUcomputemode
`static int`	`CU_CTX_BLOCKING_SYNC`	enum CUctx_flags
`static int`	`CU_CTX_FLAGS_MASK`	enum CUctx_flags
`static int`	`CU_CTX_LMEM_RESIZE_TO_MAX`	enum CUctx_flags
`static int`	`CU_CTX_MAP_HOST`	enum CUctx_flags
`static int`	`CU_CTX_SCHED_AUTO`	enum CUctx_flags
`static int`	`CU_CTX_SCHED_BLOCKING_SYNC`	enum CUctx_flags
`static int`	`CU_CTX_SCHED_MASK`	enum CUctx_flags
`static int`	`CU_CTX_SCHED_SPIN`	enum CUctx_flags
`static int`	`CU_CTX_SCHED_YIELD`	enum CUctx_flags
`static int`	`CU_CUBEMAP_FACE_NEGATIVE_X`	enum CUarray_cubemap_face
`static int`	`CU_CUBEMAP_FACE_NEGATIVE_Y`	enum CUarray_cubemap_face
`static int`	`CU_CUBEMAP_FACE_NEGATIVE_Z`	enum CUarray_cubemap_face
`static int`	`CU_CUBEMAP_FACE_POSITIVE_X`	enum CUarray_cubemap_face
`static int`	`CU_CUBEMAP_FACE_POSITIVE_Y`	enum CUarray_cubemap_face
`static int`	`CU_CUBEMAP_FACE_POSITIVE_Z`	enum CUarray_cubemap_face
`static int`	`CU_DEVICE_ATTRIBUTE_ASYNC_ENGINE_COUNT`	enum CUdevice_attribute
`static int`	`CU_DEVICE_ATTRIBUTE_CAN_FLUSH_REMOTE_WRITES`	enum CUdevice_attribute
`static int`	`CU_DEVICE_ATTRIBUTE_CAN_MAP_HOST_MEMORY`	enum CUdevice_attribute
`static int`	`CU_DEVICE_ATTRIBUTE_CAN_TEX2D_GATHER`	enum CUdevice_attribute
`static int`	`CU_DEVICE_ATTRIBUTE_CAN_USE_64_BIT_STREAM_MEM_OPS`	enum CUdevice_attribute
`static int`	`CU_DEVICE_ATTRIBUTE_CAN_USE_HOST_POINTER_FOR_REGISTERED_MEM`	enum CUdevice_attribute
`static int`	`CU_DEVICE_ATTRIBUTE_CAN_USE_STREAM_MEM_OPS`	enum CUdevice_attribute
`static int`	`CU_DEVICE_ATTRIBUTE_CAN_USE_STREAM_WAIT_VALUE_NOR`	enum CUdevice_attribute
`static int`	`CU_DEVICE_ATTRIBUTE_CLOCK_RATE`	enum CUdevice_attribute
`static int`	`CU_DEVICE_ATTRIBUTE_COMPUTE_CAPABILITY_MAJOR`	enum CUdevice_attribute
`static int`	`CU_DEVICE_ATTRIBUTE_COMPUTE_CAPABILITY_MINOR`	enum CUdevice_attribute
`static int`	`CU_DEVICE_ATTRIBUTE_COMPUTE_MODE`	enum CUdevice_attribute
`static int`	`CU_DEVICE_ATTRIBUTE_COMPUTE_PREEMPTION_SUPPORTED`	enum CUdevice_attribute
`static int`	`CU_DEVICE_ATTRIBUTE_CONCURRENT_KERNELS`	enum CUdevice_attribute
`static int`	`CU_DEVICE_ATTRIBUTE_CONCURRENT_MANAGED_ACCESS`	enum CUdevice_attribute
`static int`	`CU_DEVICE_ATTRIBUTE_COOPERATIVE_LAUNCH`	enum CUdevice_attribute
`static int`	`CU_DEVICE_ATTRIBUTE_COOPERATIVE_MULTI_DEVICE_LAUNCH`	enum CUdevice_attribute
`static int`	`CU_DEVICE_ATTRIBUTE_DIRECT_MANAGED_MEM_ACCESS_FROM_HOST`	enum CUdevice_attribute
`static int`	`CU_DEVICE_ATTRIBUTE_ECC_ENABLED`	enum CUdevice_attribute
`static int`	`CU_DEVICE_ATTRIBUTE_GLOBAL_L1_CACHE_SUPPORTED`	enum CUdevice_attribute
`static int`	`CU_DEVICE_ATTRIBUTE_GLOBAL_MEMORY_BUS_WIDTH`	enum CUdevice_attribute
`static int`	`CU_DEVICE_ATTRIBUTE_GPU_OVERLAP`	enum CUdevice_attribute
`static int`	`CU_DEVICE_ATTRIBUTE_HANDLE_TYPE_POSIX_FILE_DESCRIPTOR_SUPPORTED`	enum CUdevice_attribute
`static int`	`CU_DEVICE_ATTRIBUTE_HANDLE_TYPE_WIN32_HANDLE_SUPPORTED`	enum CUdevice_attribute
`static int`	`CU_DEVICE_ATTRIBUTE_HANDLE_TYPE_WIN32_KMT_HANDLE_SUPPORTED`	enum CUdevice_attribute
`static int`	`CU_DEVICE_ATTRIBUTE_HOST_NATIVE_ATOMIC_SUPPORTED`	enum CUdevice_attribute
`static int`	`CU_DEVICE_ATTRIBUTE_HOST_REGISTER_SUPPORTED`	enum CUdevice_attribute
`static int`	`CU_DEVICE_ATTRIBUTE_INTEGRATED`	enum CUdevice_attribute
`static int`	`CU_DEVICE_ATTRIBUTE_KERNEL_EXEC_TIMEOUT`	enum CUdevice_attribute
`static int`	`CU_DEVICE_ATTRIBUTE_L2_CACHE_SIZE`	enum CUdevice_attribute
`static int`	`CU_DEVICE_ATTRIBUTE_LOCAL_L1_CACHE_SUPPORTED`	enum CUdevice_attribute
`static int`	`CU_DEVICE_ATTRIBUTE_MANAGED_MEMORY`	enum CUdevice_attribute
`static int`	`CU_DEVICE_ATTRIBUTE_MAX`	enum CUdevice_attribute
`static int`	`CU_DEVICE_ATTRIBUTE_MAX_BLOCK_DIM_X`	enum CUdevice_attribute
`static int`	`CU_DEVICE_ATTRIBUTE_MAX_BLOCK_DIM_Y`	enum CUdevice_attribute
`static int`	`CU_DEVICE_ATTRIBUTE_MAX_BLOCK_DIM_Z`	enum CUdevice_attribute
`static int`	`CU_DEVICE_ATTRIBUTE_MAX_GRID_DIM_X`	enum CUdevice_attribute
`static int`	`CU_DEVICE_ATTRIBUTE_MAX_GRID_DIM_Y`	enum CUdevice_attribute
`static int`	`CU_DEVICE_ATTRIBUTE_MAX_GRID_DIM_Z`	enum CUdevice_attribute
`static int`	`CU_DEVICE_ATTRIBUTE_MAX_PITCH`	enum CUdevice_attribute
`static int`	`CU_DEVICE_ATTRIBUTE_MAX_REGISTERS_PER_BLOCK`	enum CUdevice_attribute
`static int`	`CU_DEVICE_ATTRIBUTE_MAX_REGISTERS_PER_MULTIPROCESSOR`	enum CUdevice_attribute
`static int`	`CU_DEVICE_ATTRIBUTE_MAX_SHARED_MEMORY_PER_BLOCK`	enum CUdevice_attribute
`static int`	`CU_DEVICE_ATTRIBUTE_MAX_SHARED_MEMORY_PER_BLOCK_OPTIN`	enum CUdevice_attribute
`static int`	`CU_DEVICE_ATTRIBUTE_MAX_SHARED_MEMORY_PER_MULTIPROCESSOR`	enum CUdevice_attribute
`static int`	`CU_DEVICE_ATTRIBUTE_MAX_THREADS_PER_BLOCK`	enum CUdevice_attribute
`static int`	`CU_DEVICE_ATTRIBUTE_MAX_THREADS_PER_MULTIPROCESSOR`	enum CUdevice_attribute
`static int`	`CU_DEVICE_ATTRIBUTE_MAXIMUM_SURFACE1D_LAYERED_LAYERS`	enum CUdevice_attribute
`static int`	`CU_DEVICE_ATTRIBUTE_MAXIMUM_SURFACE1D_LAYERED_WIDTH`	enum CUdevice_attribute
`static int`	`CU_DEVICE_ATTRIBUTE_MAXIMUM_SURFACE1D_WIDTH`	enum CUdevice_attribute
`static int`	`CU_DEVICE_ATTRIBUTE_MAXIMUM_SURFACE2D_HEIGHT`	enum CUdevice_attribute
`static int`	`CU_DEVICE_ATTRIBUTE_MAXIMUM_SURFACE2D_LAYERED_HEIGHT`	enum CUdevice_attribute
`static int`	`CU_DEVICE_ATTRIBUTE_MAXIMUM_SURFACE2D_LAYERED_LAYERS`	enum CUdevice_attribute
`static int`	`CU_DEVICE_ATTRIBUTE_MAXIMUM_SURFACE2D_LAYERED_WIDTH`	enum CUdevice_attribute
`static int`	`CU_DEVICE_ATTRIBUTE_MAXIMUM_SURFACE2D_WIDTH`	enum CUdevice_attribute
`static int`	`CU_DEVICE_ATTRIBUTE_MAXIMUM_SURFACE3D_DEPTH`	enum CUdevice_attribute
`static int`	`CU_DEVICE_ATTRIBUTE_MAXIMUM_SURFACE3D_HEIGHT`	enum CUdevice_attribute
`static int`	`CU_DEVICE_ATTRIBUTE_MAXIMUM_SURFACE3D_WIDTH`	enum CUdevice_attribute
`static int`	`CU_DEVICE_ATTRIBUTE_MAXIMUM_SURFACECUBEMAP_LAYERED_LAYERS`	enum CUdevice_attribute
`static int`	`CU_DEVICE_ATTRIBUTE_MAXIMUM_SURFACECUBEMAP_LAYERED_WIDTH`	enum CUdevice_attribute
`static int`	`CU_DEVICE_ATTRIBUTE_MAXIMUM_SURFACECUBEMAP_WIDTH`	enum CUdevice_attribute
`static int`	`CU_DEVICE_ATTRIBUTE_MAXIMUM_TEXTURE1D_LAYERED_LAYERS`	enum CUdevice_attribute
`static int`	`CU_DEVICE_ATTRIBUTE_MAXIMUM_TEXTURE1D_LAYERED_WIDTH`	enum CUdevice_attribute
`static int`	`CU_DEVICE_ATTRIBUTE_MAXIMUM_TEXTURE1D_LINEAR_WIDTH`	enum CUdevice_attribute
`static int`	`CU_DEVICE_ATTRIBUTE_MAXIMUM_TEXTURE1D_MIPMAPPED_WIDTH`	enum CUdevice_attribute
`static int`	`CU_DEVICE_ATTRIBUTE_MAXIMUM_TEXTURE1D_WIDTH`	enum CUdevice_attribute
`static int`	`CU_DEVICE_ATTRIBUTE_MAXIMUM_TEXTURE2D_ARRAY_HEIGHT`	enum CUdevice_attribute
`static int`	`CU_DEVICE_ATTRIBUTE_MAXIMUM_TEXTURE2D_ARRAY_NUMSLICES`	enum CUdevice_attribute
`static int`	`CU_DEVICE_ATTRIBUTE_MAXIMUM_TEXTURE2D_ARRAY_WIDTH`	enum CUdevice_attribute
`static int`	`CU_DEVICE_ATTRIBUTE_MAXIMUM_TEXTURE2D_GATHER_HEIGHT`	enum CUdevice_attribute
`static int`	`CU_DEVICE_ATTRIBUTE_MAXIMUM_TEXTURE2D_GATHER_WIDTH`	enum CUdevice_attribute
`static int`	`CU_DEVICE_ATTRIBUTE_MAXIMUM_TEXTURE2D_HEIGHT`	enum CUdevice_attribute
`static int`	`CU_DEVICE_ATTRIBUTE_MAXIMUM_TEXTURE2D_LAYERED_HEIGHT`	enum CUdevice_attribute
`static int`	`CU_DEVICE_ATTRIBUTE_MAXIMUM_TEXTURE2D_LAYERED_LAYERS`	enum CUdevice_attribute
`static int`	`CU_DEVICE_ATTRIBUTE_MAXIMUM_TEXTURE2D_LAYERED_WIDTH`	enum CUdevice_attribute
`static int`	`CU_DEVICE_ATTRIBUTE_MAXIMUM_TEXTURE2D_LINEAR_HEIGHT`	enum CUdevice_attribute
`static int`	`CU_DEVICE_ATTRIBUTE_MAXIMUM_TEXTURE2D_LINEAR_PITCH`	enum CUdevice_attribute
`static int`	`CU_DEVICE_ATTRIBUTE_MAXIMUM_TEXTURE2D_LINEAR_WIDTH`	enum CUdevice_attribute
`static int`	`CU_DEVICE_ATTRIBUTE_MAXIMUM_TEXTURE2D_MIPMAPPED_HEIGHT`	enum CUdevice_attribute
`static int`	`CU_DEVICE_ATTRIBUTE_MAXIMUM_TEXTURE2D_MIPMAPPED_WIDTH`	enum CUdevice_attribute
`static int`	`CU_DEVICE_ATTRIBUTE_MAXIMUM_TEXTURE2D_WIDTH`	enum CUdevice_attribute
`static int`	`CU_DEVICE_ATTRIBUTE_MAXIMUM_TEXTURE3D_DEPTH`	enum CUdevice_attribute
`static int`	`CU_DEVICE_ATTRIBUTE_MAXIMUM_TEXTURE3D_DEPTH_ALTERNATE`	enum CUdevice_attribute
`static int`	`CU_DEVICE_ATTRIBUTE_MAXIMUM_TEXTURE3D_HEIGHT`	enum CUdevice_attribute
`static int`	`CU_DEVICE_ATTRIBUTE_MAXIMUM_TEXTURE3D_HEIGHT_ALTERNATE`	enum CUdevice_attribute
`static int`	`CU_DEVICE_ATTRIBUTE_MAXIMUM_TEXTURE3D_WIDTH`	enum CUdevice_attribute
`static int`	`CU_DEVICE_ATTRIBUTE_MAXIMUM_TEXTURE3D_WIDTH_ALTERNATE`	enum CUdevice_attribute
`static int`	`CU_DEVICE_ATTRIBUTE_MAXIMUM_TEXTURECUBEMAP_LAYERED_LAYERS`	enum CUdevice_attribute
`static int`	`CU_DEVICE_ATTRIBUTE_MAXIMUM_TEXTURECUBEMAP_LAYERED_WIDTH`	enum CUdevice_attribute
`static int`	`CU_DEVICE_ATTRIBUTE_MAXIMUM_TEXTURECUBEMAP_WIDTH`	enum CUdevice_attribute
`static int`	`CU_DEVICE_ATTRIBUTE_MEMORY_CLOCK_RATE`	enum CUdevice_attribute
`static int`	`CU_DEVICE_ATTRIBUTE_MULTI_GPU_BOARD`	enum CUdevice_attribute
`static int`	`CU_DEVICE_ATTRIBUTE_MULTI_GPU_BOARD_GROUP_ID`	enum CUdevice_attribute
`static int`	`CU_DEVICE_ATTRIBUTE_MULTIPROCESSOR_COUNT`	enum CUdevice_attribute
`static int`	`CU_DEVICE_ATTRIBUTE_PAGEABLE_MEMORY_ACCESS`	enum CUdevice_attribute
`static int`	`CU_DEVICE_ATTRIBUTE_PAGEABLE_MEMORY_ACCESS_USES_HOST_PAGE_TABLES`	enum CUdevice_attribute
`static int`	`CU_DEVICE_ATTRIBUTE_PCI_BUS_ID`	enum CUdevice_attribute
`static int`	`CU_DEVICE_ATTRIBUTE_PCI_DEVICE_ID`	enum CUdevice_attribute
`static int`	`CU_DEVICE_ATTRIBUTE_PCI_DOMAIN_ID`	enum CUdevice_attribute
`static int`	`CU_DEVICE_ATTRIBUTE_REGISTERS_PER_BLOCK`	enum CUdevice_attribute
`static int`	`CU_DEVICE_ATTRIBUTE_SHARED_MEMORY_PER_BLOCK`	enum CUdevice_attribute
`static int`	`CU_DEVICE_ATTRIBUTE_SINGLE_TO_DOUBLE_PRECISION_PERF_RATIO`	enum CUdevice_attribute
`static int`	`CU_DEVICE_ATTRIBUTE_STREAM_PRIORITIES_SUPPORTED`	enum CUdevice_attribute
`static int`	`CU_DEVICE_ATTRIBUTE_SURFACE_ALIGNMENT`	enum CUdevice_attribute
`static int`	`CU_DEVICE_ATTRIBUTE_TCC_DRIVER`	enum CUdevice_attribute
`static int`	`CU_DEVICE_ATTRIBUTE_TEXTURE_ALIGNMENT`	enum CUdevice_attribute
`static int`	`CU_DEVICE_ATTRIBUTE_TEXTURE_PITCH_ALIGNMENT`	enum CUdevice_attribute
`static int`	`CU_DEVICE_ATTRIBUTE_TOTAL_CONSTANT_MEMORY`	enum CUdevice_attribute
`static int`	`CU_DEVICE_ATTRIBUTE_UNIFIED_ADDRESSING`	enum CUdevice_attribute
`static int`	`CU_DEVICE_ATTRIBUTE_VIRTUAL_ADDRESS_MANAGEMENT_SUPPORTED`	enum CUdevice_attribute
`static int`	`CU_DEVICE_ATTRIBUTE_WARP_SIZE`	enum CUdevice_attribute
`static int`	`CU_DEVICE_CPU`
`static int`	`CU_DEVICE_INVALID`
`static int`	`CU_DEVICE_P2P_ATTRIBUTE_ACCESS_ACCESS_SUPPORTED`	enum CUdevice_P2PAttribute
`static int`	`CU_DEVICE_P2P_ATTRIBUTE_ACCESS_SUPPORTED`	enum CUdevice_P2PAttribute
`static int`	`CU_DEVICE_P2P_ATTRIBUTE_CUDA_ARRAY_ACCESS_SUPPORTED`	enum CUdevice_P2PAttribute
`static int`	`CU_DEVICE_P2P_ATTRIBUTE_NATIVE_ATOMIC_SUPPORTED`	enum CUdevice_P2PAttribute
`static int`	`CU_DEVICE_P2P_ATTRIBUTE_PERFORMANCE_RANK`	enum CUdevice_P2PAttribute
`static int`	`CU_EVENT_BLOCKING_SYNC`	enum CUevent_flags
`static int`	`CU_EVENT_DEFAULT`	enum CUevent_flags
`static int`	`CU_EVENT_DISABLE_TIMING`	enum CUevent_flags
`static int`	`CU_EVENT_INTERPROCESS`	enum CUevent_flags
`static int`	`CU_EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_RESOURCE`	enum CUexternalMemoryHandleType
`static int`	`CU_EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_RESOURCE_KMT`	enum CUexternalMemoryHandleType
`static int`	`CU_EXTERNAL_MEMORY_HANDLE_TYPE_D3D12_HEAP`	enum CUexternalMemoryHandleType
`static int`	`CU_EXTERNAL_MEMORY_HANDLE_TYPE_D3D12_RESOURCE`	enum CUexternalMemoryHandleType
`static int`	`CU_EXTERNAL_MEMORY_HANDLE_TYPE_NVSCIBUF`	enum CUexternalMemoryHandleType
`static int`	`CU_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_FD`	enum CUexternalMemoryHandleType
`static int`	`CU_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32`	enum CUexternalMemoryHandleType
`static int`	`CU_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_KMT`	enum CUexternalMemoryHandleType
`static int`	`CU_EXTERNAL_SEMAPHORE_HANDLE_TYPE_D3D11_FENCE`	enum CUexternalSemaphoreHandleType
`static int`	`CU_EXTERNAL_SEMAPHORE_HANDLE_TYPE_D3D11_KEYED_MUTEX`	enum CUexternalSemaphoreHandleType
`static int`	`CU_EXTERNAL_SEMAPHORE_HANDLE_TYPE_D3D11_KEYED_MUTEX_KMT`	enum CUexternalSemaphoreHandleType
`static int`	`CU_EXTERNAL_SEMAPHORE_HANDLE_TYPE_D3D12_FENCE`	enum CUexternalSemaphoreHandleType
`static int`	`CU_EXTERNAL_SEMAPHORE_HANDLE_TYPE_NVSCISYNC`	enum CUexternalSemaphoreHandleType
`static int`	`CU_EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_FD`	enum CUexternalSemaphoreHandleType
`static int`	`CU_EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_WIN32`	enum CUexternalSemaphoreHandleType
`static int`	`CU_EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_WIN32_KMT`	enum CUexternalSemaphoreHandleType
`static int`	`CU_FUNC_ATTRIBUTE_BINARY_VERSION`	enum CUfunction_attribute
`static int`	`CU_FUNC_ATTRIBUTE_CACHE_MODE_CA`	enum CUfunction_attribute
`static int`	`CU_FUNC_ATTRIBUTE_CONST_SIZE_BYTES`	enum CUfunction_attribute
`static int`	`CU_FUNC_ATTRIBUTE_LOCAL_SIZE_BYTES`	enum CUfunction_attribute
`static int`	`CU_FUNC_ATTRIBUTE_MAX`	enum CUfunction_attribute
`static int`	`CU_FUNC_ATTRIBUTE_MAX_DYNAMIC_SHARED_SIZE_BYTES`	enum CUfunction_attribute
`static int`	`CU_FUNC_ATTRIBUTE_MAX_THREADS_PER_BLOCK`	enum CUfunction_attribute
`static int`	`CU_FUNC_ATTRIBUTE_NUM_REGS`	enum CUfunction_attribute
`static int`	`CU_FUNC_ATTRIBUTE_PREFERRED_SHARED_MEMORY_CARVEOUT`	enum CUfunction_attribute
`static int`	`CU_FUNC_ATTRIBUTE_PTX_VERSION`	enum CUfunction_attribute
`static int`	`CU_FUNC_ATTRIBUTE_SHARED_SIZE_BYTES`	enum CUfunction_attribute
`static int`	`CU_FUNC_CACHE_PREFER_EQUAL`	enum CUfunc_cache
`static int`	`CU_FUNC_CACHE_PREFER_L1`	enum CUfunc_cache
`static int`	`CU_FUNC_CACHE_PREFER_NONE`	enum CUfunc_cache
`static int`	`CU_FUNC_CACHE_PREFER_SHARED`	enum CUfunc_cache
`static int`	`CU_GRAPH_EXEC_UPDATE_ERROR`	enum CUgraphExecUpdateResult
`static int`	`CU_GRAPH_EXEC_UPDATE_ERROR_FUNCTION_CHANGED`	enum CUgraphExecUpdateResult
`static int`	`CU_GRAPH_EXEC_UPDATE_ERROR_NODE_TYPE_CHANGED`	enum CUgraphExecUpdateResult
`static int`	`CU_GRAPH_EXEC_UPDATE_ERROR_NOT_SUPPORTED`	enum CUgraphExecUpdateResult
`static int`	`CU_GRAPH_EXEC_UPDATE_ERROR_PARAMETERS_CHANGED`	enum CUgraphExecUpdateResult
`static int`	`CU_GRAPH_EXEC_UPDATE_ERROR_TOPOLOGY_CHANGED`	enum CUgraphExecUpdateResult
`static int`	`CU_GRAPH_EXEC_UPDATE_SUCCESS`	enum CUgraphExecUpdateResult
`static int`	`CU_GRAPH_NODE_TYPE_COUNT`	enum CUgraphNodeType
`static int`	`CU_GRAPH_NODE_TYPE_EMPTY`	enum CUgraphNodeType
`static int`	`CU_GRAPH_NODE_TYPE_GRAPH`	enum CUgraphNodeType
`static int`	`CU_GRAPH_NODE_TYPE_HOST`	enum CUgraphNodeType
`static int`	`CU_GRAPH_NODE_TYPE_KERNEL`	enum CUgraphNodeType
`static int`	`CU_GRAPH_NODE_TYPE_MEMCPY`	enum CUgraphNodeType
`static int`	`CU_GRAPH_NODE_TYPE_MEMSET`	enum CUgraphNodeType
`static int`	`CU_GRAPHICS_MAP_RESOURCE_FLAGS_NONE`	enum CUgraphicsMapResourceFlags
`static int`	`CU_GRAPHICS_MAP_RESOURCE_FLAGS_READ_ONLY`	enum CUgraphicsMapResourceFlags
`static int`	`CU_GRAPHICS_MAP_RESOURCE_FLAGS_WRITE_DISCARD`	enum CUgraphicsMapResourceFlags
`static int`	`CU_GRAPHICS_REGISTER_FLAGS_NONE`	enum CUgraphicsRegisterFlags
`static int`	`CU_GRAPHICS_REGISTER_FLAGS_READ_ONLY`	enum CUgraphicsRegisterFlags
`static int`	`CU_GRAPHICS_REGISTER_FLAGS_SURFACE_LDST`	enum CUgraphicsRegisterFlags
`static int`	`CU_GRAPHICS_REGISTER_FLAGS_TEXTURE_GATHER`	enum CUgraphicsRegisterFlags
`static int`	`CU_GRAPHICS_REGISTER_FLAGS_WRITE_DISCARD`	enum CUgraphicsRegisterFlags
`static int`	`CU_IPC_HANDLE_SIZE`	CUDA IPC handle size
`static int`	`CU_IPC_MEM_LAZY_ENABLE_PEER_ACCESS`	enum CUipcMem_flags
`static int`	`CU_JIT_CACHE_MODE`	enum CUjit_option
`static int`	`CU_JIT_CACHE_OPTION_CA`	enum CUjit_cacheMode
`static int`	`CU_JIT_CACHE_OPTION_CG`	enum CUjit_cacheMode
`static int`	`CU_JIT_CACHE_OPTION_NONE`	enum CUjit_cacheMode
`static int`	`CU_JIT_ERROR_LOG_BUFFER`	enum CUjit_option
`static int`	`CU_JIT_ERROR_LOG_BUFFER_SIZE_BYTES`	enum CUjit_option
`static int`	`CU_JIT_FALLBACK_STRATEGY`	enum CUjit_option
`static int`	`CU_JIT_FAST_COMPILE`	enum CUjit_option
`static int`	`CU_JIT_GENERATE_DEBUG_INFO`	enum CUjit_option
`static int`	`CU_JIT_GENERATE_LINE_INFO`	enum CUjit_option
`static int`	`CU_JIT_GLOBAL_SYMBOL_ADDRESSES`	enum CUjit_option
`static int`	`CU_JIT_GLOBAL_SYMBOL_COUNT`	enum CUjit_option
`static int`	`CU_JIT_GLOBAL_SYMBOL_NAMES`	enum CUjit_option
`static int`	`CU_JIT_INFO_LOG_BUFFER`	enum CUjit_option
`static int`	`CU_JIT_INFO_LOG_BUFFER_SIZE_BYTES`	enum CUjit_option
`static int`	`CU_JIT_INPUT_CUBIN`	enum CUjitInputType
`static int`	`CU_JIT_INPUT_FATBINARY`	enum CUjitInputType
`static int`	`CU_JIT_INPUT_LIBRARY`	enum CUjitInputType
`static int`	`CU_JIT_INPUT_OBJECT`	enum CUjitInputType
`static int`	`CU_JIT_INPUT_PTX`	enum CUjitInputType
`static int`	`CU_JIT_LOG_VERBOSE`	enum CUjit_option
`static int`	`CU_JIT_MAX_REGISTERS`	enum CUjit_option
`static int`	`CU_JIT_NEW_SM3X_OPT`	enum CUjit_option
`static int`	`CU_JIT_NUM_INPUT_TYPES`	enum CUjitInputType
`static int`	`CU_JIT_NUM_OPTIONS`	enum CUjit_option
`static int`	`CU_JIT_OPTIMIZATION_LEVEL`	enum CUjit_option
`static int`	`CU_JIT_TARGET`	enum CUjit_option
`static int`	`CU_JIT_TARGET_FROM_CUCONTEXT`	enum CUjit_option
`static int`	`CU_JIT_THREADS_PER_BLOCK`	enum CUjit_option
`static int`	`CU_JIT_WALL_TIME`	enum CUjit_option
`static Pointer`	`CU_LAUNCH_PARAM_BUFFER_POINTER`
`static Pointer`	`CU_LAUNCH_PARAM_BUFFER_SIZE`
`static Pointer`	`CU_LAUNCH_PARAM_END`
`static int`	`CU_LIMIT_DEV_RUNTIME_PENDING_LAUNCH_COUNT`	enum CUlimit
`static int`	`CU_LIMIT_DEV_RUNTIME_SYNC_DEPTH`	enum CUlimit
`static int`	`CU_LIMIT_MALLOC_HEAP_SIZE`	enum CUlimit
`static int`	`CU_LIMIT_MAX`	enum CUlimit
`static int`	`CU_LIMIT_MAX_L2_FETCH_GRANULARITY`	enum CUlimit
`static int`	`CU_LIMIT_PRINTF_FIFO_SIZE`	enum CUlimit
`static int`	`CU_LIMIT_STACK_SIZE`	enum CUlimit
`static int`	`CU_MEM_ACCESS_FLAGS_PROT_MAX`	enum CUmemAccess_flags
`static int`	`CU_MEM_ACCESS_FLAGS_PROT_NONE`	enum CUmemAccess_flags
`static int`	`CU_MEM_ACCESS_FLAGS_PROT_READ`	enum CUmemAccess_flags
`static int`	`CU_MEM_ACCESS_FLAGS_PROT_READWRITE`	enum CUmemAccess_flags
`static int`	`CU_MEM_ADVISE_SET_ACCESSED_BY`	enum CUmem_advise
`static int`	`CU_MEM_ADVISE_SET_PREFERRED_LOCATION`	enum CUmem_advise
`static int`	`CU_MEM_ADVISE_SET_READ_MOSTLY`	enum CUmem_advise
`static int`	`CU_MEM_ADVISE_UNSET_ACCESSED_BY`	enum CUmem_advise
`static int`	`CU_MEM_ADVISE_UNSET_PREFERRED_LOCATION`	enum CUmem_advise
`static int`	`CU_MEM_ADVISE_UNSET_READ_MOSTLY`	enum CUmem_advise
`static int`	`CU_MEM_ALLOC_GRANULARITY_MINIMUM`	enum CUmemAllocationGranularity_flags
`static int`	`CU_MEM_ALLOC_GRANULARITY_RECOMMENDED`	enum CUmemAllocationGranularity_flags
`static int`	`CU_MEM_ALLOCATION_TYPE_INVALID`	enum CUmemAllocationType
`static int`	`CU_MEM_ALLOCATION_TYPE_MAX`	enum CUmemAllocationType
`static int`	`CU_MEM_ALLOCATION_TYPE_PINNED`	enum CUmemAllocationType
`static int`	`CU_MEM_ATTACH_GLOBAL`	enum CUmemAttach_flags
`static int`	`CU_MEM_ATTACH_HOST`	enum CUmemAttach_flags
`static int`	`CU_MEM_ATTACH_SINGLE`	enum CUmemAttach_flags
`static int`	`CU_MEM_HANDLE_TYPE_MAX`	enum CUmemAllocationHandleType
`static int`	`CU_MEM_HANDLE_TYPE_POSIX_FILE_DESCRIPTOR`	enum CUmemAllocationHandleType
`static int`	`CU_MEM_HANDLE_TYPE_WIN32`	enum CUmemAllocationHandleType
`static int`	`CU_MEM_HANDLE_TYPE_WIN32_KMT`	enum CUmemAllocationHandleType
`static int`	`CU_MEM_LOCATION_TYPE_DEVICE`	enum CUmemLocationType
`static int`	`CU_MEM_LOCATION_TYPE_INVALID`	enum CUmemLocationType
`static int`	`CU_MEM_LOCATION_TYPE_MAX`	enum CUmemLocationType
`static int`	`CU_MEM_RANGE_ATTRIBUTE_ACCESSED_BY`	enum CUmem_range_attribute
`static int`	`CU_MEM_RANGE_ATTRIBUTE_LAST_PREFETCH_LOCATION`	enum CUmem_range_attribute
`static int`	`CU_MEM_RANGE_ATTRIBUTE_PREFERRED_LOCATION`	enum CUmem_range_attribute
`static int`	`CU_MEM_RANGE_ATTRIBUTE_READ_MOSTLY`	enum CUmem_range_attribute
`static int`	`CU_MEMHOSTALLOC_DEVICEMAP`	If set, host memory is mapped into CUDA address space and ::cuMemHostGetDevicePointer() may be called on the host pointer.
`static int`	`CU_MEMHOSTALLOC_PORTABLE`	If set, host memory is portable between CUDA contexts.
`static int`	`CU_MEMHOSTALLOC_WRITECOMBINED`	If set, host memory is allocated as write-combined - fast to write, faster to DMA, slow to read except via SSE4 streaming load instruction (MOVNTDQA).
`static int`	`CU_MEMHOSTREGISTER_DEVICEMAP`	If set, host memory is mapped into CUDA address space and ::cuMemHostGetDevicePointer() may be called on the host pointer.
`static int`	`CU_MEMHOSTREGISTER_IOMEMORY`	If set, the passed memory pointer is treated as pointing to some memory-mapped I/O space, e.g.
`static int`	`CU_MEMHOSTREGISTER_PORTABLE`	If set, host memory is portable between CUDA contexts.
`static int`	`CU_MEMORYTYPE_ARRAY`	enum CUmemorytype
`static int`	`CU_MEMORYTYPE_DEVICE`	enum CUmemorytype
`static int`	`CU_MEMORYTYPE_HOST`	enum CUmemorytype
`static int`	`CU_MEMORYTYPE_UNIFIED`	enum CUmemorytype
`static int`	`CU_OCCUPANCY_DEFAULT`	enum CUoccupancy_flags
`static int`	`CU_OCCUPANCY_DISABLE_CACHING_OVERRIDE`	enum CUoccupancy_flags
`static int`	`CU_PARAM_TR_DEFAULT`	For texture references loaded into the module, use default texunit from texture reference.
`static int`	`CU_POINTER_ATTRIBUTE_ALLOWED_HANDLE_TYPES`	enum CUpointer_attribute
`static int`	`CU_POINTER_ATTRIBUTE_BUFFER_ID`	enum CUpointer_attribute
`static int`	`CU_POINTER_ATTRIBUTE_CONTEXT`	enum CUpointer_attribute
`static int`	`CU_POINTER_ATTRIBUTE_DEVICE_ORDINAL`	enum CUpointer_attribute
`static int`	`CU_POINTER_ATTRIBUTE_DEVICE_POINTER`	enum CUpointer_attribute
`static int`	`CU_POINTER_ATTRIBUTE_HOST_POINTER`	enum CUpointer_attribute
`static int`	`CU_POINTER_ATTRIBUTE_IS_LEGACY_CUDA_IPC_CAPABLE`	enum CUpointer_attribute
`static int`	`CU_POINTER_ATTRIBUTE_IS_MANAGED`	enum CUpointer_attribute
`static int`	`CU_POINTER_ATTRIBUTE_MAPPED`	enum CUpointer_attribute
`static int`	`CU_POINTER_ATTRIBUTE_MEMORY_TYPE`	enum CUpointer_attribute
`static int`	`CU_POINTER_ATTRIBUTE_P2P_TOKENS`	enum CUpointer_attribute
`static int`	`CU_POINTER_ATTRIBUTE_RANGE_SIZE`	enum CUpointer_attribute
`static int`	`CU_POINTER_ATTRIBUTE_RANGE_START_ADDR`	enum CUpointer_attribute
`static int`	`CU_POINTER_ATTRIBUTE_SYNC_MEMOPS`	enum CUpointer_attribute
`static int`	`CU_PREFER_BINARY`	enum CUjit_fallback
`static int`	`CU_PREFER_PTX`	enum CUjit_fallback
`static int`	`CU_RES_VIEW_FORMAT_FLOAT_1X16`	enum CUresourceViewFormat
`static int`	`CU_RES_VIEW_FORMAT_FLOAT_1X32`	enum CUresourceViewFormat
`static int`	`CU_RES_VIEW_FORMAT_FLOAT_2X16`	enum CUresourceViewFormat
`static int`	`CU_RES_VIEW_FORMAT_FLOAT_2X32`	enum CUresourceViewFormat
`static int`	`CU_RES_VIEW_FORMAT_FLOAT_4X16`	enum CUresourceViewFormat
`static int`	`CU_RES_VIEW_FORMAT_FLOAT_4X32`	enum CUresourceViewFormat
`static int`	`CU_RES_VIEW_FORMAT_NONE`	enum CUresourceViewFormat
`static int`	`CU_RES_VIEW_FORMAT_SIGNED_BC4`	enum CUresourceViewFormat
`static int`	`CU_RES_VIEW_FORMAT_SIGNED_BC5`	enum CUresourceViewFormat
`static int`	`CU_RES_VIEW_FORMAT_SIGNED_BC6H`	enum CUresourceViewFormat
`static int`	`CU_RES_VIEW_FORMAT_SINT_1X16`	enum CUresourceViewFormat
`static int`	`CU_RES_VIEW_FORMAT_SINT_1X32`	enum CUresourceViewFormat
`static int`	`CU_RES_VIEW_FORMAT_SINT_1X8`	enum CUresourceViewFormat
`static int`	`CU_RES_VIEW_FORMAT_SINT_2X16`	enum CUresourceViewFormat
`static int`	`CU_RES_VIEW_FORMAT_SINT_2X32`	enum CUresourceViewFormat
`static int`	`CU_RES_VIEW_FORMAT_SINT_2X8`	enum CUresourceViewFormat
`static int`	`CU_RES_VIEW_FORMAT_SINT_4X16`	enum CUresourceViewFormat
`static int`	`CU_RES_VIEW_FORMAT_SINT_4X32`	enum CUresourceViewFormat
`static int`	`CU_RES_VIEW_FORMAT_SINT_4X8`	enum CUresourceViewFormat
`static int`	`CU_RES_VIEW_FORMAT_UINT_1X16`	enum CUresourceViewFormat
`static int`	`CU_RES_VIEW_FORMAT_UINT_1X32`	enum CUresourceViewFormat
`static int`	`CU_RES_VIEW_FORMAT_UINT_1X8`	enum CUresourceViewFormat
`static int`	`CU_RES_VIEW_FORMAT_UINT_2X16`	enum CUresourceViewFormat
`static int`	`CU_RES_VIEW_FORMAT_UINT_2X32`	enum CUresourceViewFormat
`static int`	`CU_RES_VIEW_FORMAT_UINT_2X8`	enum CUresourceViewFormat
`static int`	`CU_RES_VIEW_FORMAT_UINT_4X16`	enum CUresourceViewFormat
`static int`	`CU_RES_VIEW_FORMAT_UINT_4X32`	enum CUresourceViewFormat
`static int`	`CU_RES_VIEW_FORMAT_UINT_4X8`	enum CUresourceViewFormat
`static int`	`CU_RES_VIEW_FORMAT_UNSIGNED_BC1`	enum CUresourceViewFormat
`static int`	`CU_RES_VIEW_FORMAT_UNSIGNED_BC2`	enum CUresourceViewFormat
`static int`	`CU_RES_VIEW_FORMAT_UNSIGNED_BC3`	enum CUresourceViewFormat
`static int`	`CU_RES_VIEW_FORMAT_UNSIGNED_BC4`	enum CUresourceViewFormat
`static int`	`CU_RES_VIEW_FORMAT_UNSIGNED_BC5`	enum CUresourceViewFormat
`static int`	`CU_RES_VIEW_FORMAT_UNSIGNED_BC6H`	enum CUresourceViewFormat
`static int`	`CU_RES_VIEW_FORMAT_UNSIGNED_BC7`	enum CUresourceViewFormat
`static int`	`CU_RESOURCE_TYPE_ARRAY`	enum CUresourcetype
`static int`	`CU_RESOURCE_TYPE_LINEAR`	enum CUresourcetype
`static int`	`CU_RESOURCE_TYPE_MIPMAPPED_ARRAY`	enum CUresourcetype
`static int`	`CU_RESOURCE_TYPE_PITCH2D`	enum CUresourcetype
`static int`	`CU_SHARED_MEM_CONFIG_DEFAULT_BANK_SIZE`	enum CUsharedconfig
`static int`	`CU_SHARED_MEM_CONFIG_EIGHT_BYTE_BANK_SIZE`	enum CUsharedconfig
`static int`	`CU_SHARED_MEM_CONFIG_FOUR_BYTE_BANK_SIZE`	enum CUsharedconfig
`static int`	`CU_SHAREDMEM_CARVEOUT_DEFAULT`	enum CUshared_carveout
`static int`	`CU_SHAREDMEM_CARVEOUT_MAX_L1`	enum CUshared_carveout
`static int`	`CU_SHAREDMEM_CARVEOUT_MAX_SHARED`	enum CUshared_carveout
`static int`	`CU_STREAM_CAPTURE_MODE_GLOBAL`	enum CUstreamCaptureMode
`static int`	`CU_STREAM_CAPTURE_MODE_RELAXED`	enum CUstreamCaptureMode
`static int`	`CU_STREAM_CAPTURE_MODE_THREAD_LOCAL`	enum CUstreamCaptureMode
`static int`	`CU_STREAM_CAPTURE_STATUS_ACTIVE`	enum CUstreamCaptureStatus
`static int`	`CU_STREAM_CAPTURE_STATUS_INVALIDATED`	enum CUstreamCaptureStatus
`static int`	`CU_STREAM_CAPTURE_STATUS_NONE`	enum CUstreamCaptureStatus
`static int`	`CU_STREAM_DEFAULT`	enum CUstream_flags
`static CUstream_st`	`CU_STREAM_LEGACY`
`static int`	`CU_STREAM_MEM_OP_FLUSH_REMOTE_WRITES`	enum CUstreamBatchMemOpType
`static int`	`CU_STREAM_MEM_OP_WAIT_VALUE_32`	enum CUstreamBatchMemOpType
`static int`	`CU_STREAM_MEM_OP_WAIT_VALUE_64`	enum CUstreamBatchMemOpType
`static int`	`CU_STREAM_MEM_OP_WRITE_VALUE_32`	enum CUstreamBatchMemOpType
`static int`	`CU_STREAM_MEM_OP_WRITE_VALUE_64`	enum CUstreamBatchMemOpType
`static int`	`CU_STREAM_NON_BLOCKING`	enum CUstream_flags
`static CUstream_st`	`CU_STREAM_PER_THREAD`
`static int`	`CU_STREAM_WAIT_VALUE_AND`	enum CUstreamWaitValue_flags
`static int`	`CU_STREAM_WAIT_VALUE_EQ`	enum CUstreamWaitValue_flags
`static int`	`CU_STREAM_WAIT_VALUE_FLUSH`	enum CUstreamWaitValue_flags
`static int`	`CU_STREAM_WAIT_VALUE_GEQ`	enum CUstreamWaitValue_flags
`static int`	`CU_STREAM_WAIT_VALUE_NOR`	enum CUstreamWaitValue_flags
`static int`	`CU_STREAM_WRITE_VALUE_DEFAULT`	enum CUstreamWriteValue_flags
`static int`	`CU_STREAM_WRITE_VALUE_NO_MEMORY_BARRIER`	enum CUstreamWriteValue_flags
`static int`	`CU_TARGET_COMPUTE_20`	enum CUjit_target
`static int`	`CU_TARGET_COMPUTE_21`	enum CUjit_target
`static int`	`CU_TARGET_COMPUTE_30`	enum CUjit_target
`static int`	`CU_TARGET_COMPUTE_32`	enum CUjit_target
`static int`	`CU_TARGET_COMPUTE_35`	enum CUjit_target
`static int`	`CU_TARGET_COMPUTE_37`	enum CUjit_target
`static int`	`CU_TARGET_COMPUTE_50`	enum CUjit_target
`static int`	`CU_TARGET_COMPUTE_52`	enum CUjit_target
`static int`	`CU_TARGET_COMPUTE_53`	enum CUjit_target
`static int`	`CU_TARGET_COMPUTE_60`	enum CUjit_target
`static int`	`CU_TARGET_COMPUTE_61`	enum CUjit_target
`static int`	`CU_TARGET_COMPUTE_62`	enum CUjit_target
`static int`	`CU_TARGET_COMPUTE_70`	enum CUjit_target
`static int`	`CU_TARGET_COMPUTE_72`	enum CUjit_target
`static int`	`CU_TARGET_COMPUTE_75`	enum CUjit_target
`static int`	`CU_TR_ADDRESS_MODE_BORDER`	enum CUaddress_mode
`static int`	`CU_TR_ADDRESS_MODE_CLAMP`	enum CUaddress_mode
`static int`	`CU_TR_ADDRESS_MODE_MIRROR`	enum CUaddress_mode
`static int`	`CU_TR_ADDRESS_MODE_WRAP`	enum CUaddress_mode
`static int`	`CU_TR_FILTER_MODE_LINEAR`	enum CUfilter_mode
`static int`	`CU_TR_FILTER_MODE_POINT`	enum CUfilter_mode
`static int`	`CU_TRSA_OVERRIDE_FORMAT`	Override the texref format with a format inferred from the array.
`static int`	`CU_TRSF_NORMALIZED_COORDINATES`	Use normalized texture coordinates in the range [0,1) instead of [0,dim).
`static int`	`CU_TRSF_READ_AS_INTEGER`	Read the texture as integers rather than promoting the values to floats in the range [0,1].
`static int`	`CU_TRSF_SRGB`	Perform sRGB->linear conversion during texture read.
`static int`	`CUDA_ARRAY3D_2DARRAY`	Deprecated, use CUDA_ARRAY3D_LAYERED
`static int`	`CUDA_ARRAY3D_COLOR_ATTACHMENT`	This flag indicates that the CUDA array may be bound as a color target in an external graphics API
`static int`	`CUDA_ARRAY3D_CUBEMAP`	If set, the CUDA array is a collection of six 2D arrays, representing faces of a cube.
`static int`	`CUDA_ARRAY3D_DEPTH_TEXTURE`	This flag if set indicates that the CUDA array is a DEPTH_TEXTURE.
`static int`	`CUDA_ARRAY3D_LAYERED`	If set, the CUDA array is a collection of layers, where each layer is either a 1D or a 2D array and the Depth member of CUDA_ARRAY3D_DESCRIPTOR specifies the number of layers, not the depth of a 3D array.
`static int`	`CUDA_ARRAY3D_SURFACE_LDST`	This flag must be set in order to bind a surface reference to the CUDA array
`static int`	`CUDA_ARRAY3D_TEXTURE_GATHER`	This flag must be set in order to perform texture gather operations on a CUDA array.
`static int`	`CUDA_C_16F`	enum cudaDataType
`static int`	`CUDA_C_32F`	enum cudaDataType
`static int`	`CUDA_C_32I`	enum cudaDataType
`static int`	`CUDA_C_32U`	enum cudaDataType
`static int`	`CUDA_C_64F`	enum cudaDataType
`static int`	`CUDA_C_8I`	enum cudaDataType
`static int`	`CUDA_C_8U`	enum cudaDataType
`static int`	`CUDA_COOPERATIVE_LAUNCH_MULTI_DEVICE_NO_POST_LAUNCH_SYNC`	If set, any subsequent work pushed in a stream that participated in a call to ::cuLaunchCooperativeKernelMultiDevice will only wait for the kernel launched on the GPU corresponding to that stream to complete before it begins execution.
`static int`	`CUDA_COOPERATIVE_LAUNCH_MULTI_DEVICE_NO_PRE_LAUNCH_SYNC`	If set, each kernel launched as part of ::cuLaunchCooperativeKernelMultiDevice only waits for prior work in the stream corresponding to that GPU to complete before the kernel begins execution.
`static int`	`CUDA_ERROR_ALREADY_ACQUIRED`	enum CUresult
`static int`	`CUDA_ERROR_ALREADY_MAPPED`	enum CUresult
`static int`	`CUDA_ERROR_ARRAY_IS_MAPPED`	enum CUresult
`static int`	`CUDA_ERROR_ASSERT`	enum CUresult
`static int`	`CUDA_ERROR_CAPTURED_EVENT`	enum CUresult
`static int`	`CUDA_ERROR_COMPAT_NOT_SUPPORTED_ON_DEVICE`	enum CUresult
`static int`	`CUDA_ERROR_CONTEXT_ALREADY_CURRENT`	enum CUresult
`static int`	`CUDA_ERROR_CONTEXT_ALREADY_IN_USE`	enum CUresult
`static int`	`CUDA_ERROR_CONTEXT_IS_DESTROYED`	enum CUresult
`static int`	`CUDA_ERROR_COOPERATIVE_LAUNCH_TOO_LARGE`	enum CUresult
`static int`	`CUDA_ERROR_DEINITIALIZED`	enum CUresult
`static int`	`CUDA_ERROR_ECC_UNCORRECTABLE`	enum CUresult
`static int`	`CUDA_ERROR_FILE_NOT_FOUND`	enum CUresult
`static int`	`CUDA_ERROR_GRAPH_EXEC_UPDATE_FAILURE`	enum CUresult
`static int`	`CUDA_ERROR_HARDWARE_STACK_ERROR`	enum CUresult
`static int`	`CUDA_ERROR_HOST_MEMORY_ALREADY_REGISTERED`	enum CUresult
`static int`	`CUDA_ERROR_HOST_MEMORY_NOT_REGISTERED`	enum CUresult
`static int`	`CUDA_ERROR_ILLEGAL_ADDRESS`	enum CUresult
`static int`	`CUDA_ERROR_ILLEGAL_INSTRUCTION`	enum CUresult
`static int`	`CUDA_ERROR_ILLEGAL_STATE`	enum CUresult
`static int`	`CUDA_ERROR_INVALID_ADDRESS_SPACE`	enum CUresult
`static int`	`CUDA_ERROR_INVALID_CONTEXT`	enum CUresult
`static int`	`CUDA_ERROR_INVALID_DEVICE`	enum CUresult
`static int`	`CUDA_ERROR_INVALID_GRAPHICS_CONTEXT`	enum CUresult
`static int`	`CUDA_ERROR_INVALID_HANDLE`	enum CUresult
`static int`	`CUDA_ERROR_INVALID_IMAGE`	enum CUresult
`static int`	`CUDA_ERROR_INVALID_PC`	enum CUresult
`static int`	`CUDA_ERROR_INVALID_PTX`	enum CUresult
`static int`	`CUDA_ERROR_INVALID_SOURCE`	enum CUresult
`static int`	`CUDA_ERROR_INVALID_VALUE`	enum CUresult
`static int`	`CUDA_ERROR_JIT_COMPILER_NOT_FOUND`	enum CUresult
`static int`	`CUDA_ERROR_LAUNCH_FAILED`	enum CUresult
`static int`	`CUDA_ERROR_LAUNCH_INCOMPATIBLE_TEXTURING`	enum CUresult
`static int`	`CUDA_ERROR_LAUNCH_OUT_OF_RESOURCES`	enum CUresult
`static int`	`CUDA_ERROR_LAUNCH_TIMEOUT`	enum CUresult
`static int`	`CUDA_ERROR_MAP_FAILED`	enum CUresult
`static int`	`CUDA_ERROR_MISALIGNED_ADDRESS`	enum CUresult
`static int`	`CUDA_ERROR_NO_BINARY_FOR_GPU`	enum CUresult
`static int`	`CUDA_ERROR_NO_DEVICE`	enum CUresult
`static int`	`CUDA_ERROR_NOT_FOUND`	enum CUresult
`static int`	`CUDA_ERROR_NOT_INITIALIZED`	enum CUresult
`static int`	`CUDA_ERROR_NOT_MAPPED`	enum CUresult
`static int`	`CUDA_ERROR_NOT_MAPPED_AS_ARRAY`	enum CUresult
`static int`	`CUDA_ERROR_NOT_MAPPED_AS_POINTER`	enum CUresult
`static int`	`CUDA_ERROR_NOT_PERMITTED`	enum CUresult
`static int`	`CUDA_ERROR_NOT_READY`	enum CUresult
`static int`	`CUDA_ERROR_NOT_SUPPORTED`	enum CUresult
`static int`	`CUDA_ERROR_NVLINK_UNCORRECTABLE`	enum CUresult
`static int`	`CUDA_ERROR_OPERATING_SYSTEM`	enum CUresult
`static int`	`CUDA_ERROR_OUT_OF_MEMORY`	enum CUresult
`static int`	`CUDA_ERROR_PEER_ACCESS_ALREADY_ENABLED`	enum CUresult
`static int`	`CUDA_ERROR_PEER_ACCESS_NOT_ENABLED`	enum CUresult
`static int`	`CUDA_ERROR_PEER_ACCESS_UNSUPPORTED`	enum CUresult
`static int`	`CUDA_ERROR_PRIMARY_CONTEXT_ACTIVE`	enum CUresult
`static int`	`CUDA_ERROR_PROFILER_ALREADY_STARTED`	enum CUresult
`static int`	`CUDA_ERROR_PROFILER_ALREADY_STOPPED`	enum CUresult
`static int`	`CUDA_ERROR_PROFILER_DISABLED`	enum CUresult
`static int`	`CUDA_ERROR_PROFILER_NOT_INITIALIZED`	enum CUresult
`static int`	`CUDA_ERROR_SHARED_OBJECT_INIT_FAILED`	enum CUresult
`static int`	`CUDA_ERROR_SHARED_OBJECT_SYMBOL_NOT_FOUND`	enum CUresult
`static int`	`CUDA_ERROR_STREAM_CAPTURE_IMPLICIT`	enum CUresult
`static int`	`CUDA_ERROR_STREAM_CAPTURE_INVALIDATED`	enum CUresult
`static int`	`CUDA_ERROR_STREAM_CAPTURE_ISOLATION`	enum CUresult
`static int`	`CUDA_ERROR_STREAM_CAPTURE_MERGE`	enum CUresult
`static int`	`CUDA_ERROR_STREAM_CAPTURE_UNJOINED`	enum CUresult
`static int`	`CUDA_ERROR_STREAM_CAPTURE_UNMATCHED`	enum CUresult
`static int`	`CUDA_ERROR_STREAM_CAPTURE_UNSUPPORTED`	enum CUresult
`static int`	`CUDA_ERROR_STREAM_CAPTURE_WRONG_THREAD`	enum CUresult
`static int`	`CUDA_ERROR_SYSTEM_DRIVER_MISMATCH`	enum CUresult
`static int`	`CUDA_ERROR_SYSTEM_NOT_READY`	enum CUresult
`static int`	`CUDA_ERROR_TIMEOUT`	enum CUresult
`static int`	`CUDA_ERROR_TOO_MANY_PEERS`	enum CUresult
`static int`	`CUDA_ERROR_UNKNOWN`	enum CUresult
`static int`	`CUDA_ERROR_UNMAP_FAILED`	enum CUresult
`static int`	`CUDA_ERROR_UNSUPPORTED_LIMIT`	enum CUresult
`static int`	`CUDA_EXTERNAL_MEMORY_DEDICATED`	Indicates that the external memory object is a dedicated resource
`static int`	`CUDA_EXTERNAL_SEMAPHORE_SIGNAL_SKIP_NVSCIBUF_MEMSYNC`	When the /p flags parameter of ::CUDA_EXTERNAL_SEMAPHORE_SIGNAL_PARAMS contains this flag, it indicates that signaling an external semaphore object should skip performing appropriate memory synchronization operations over all the external memory objects that are imported as ::CU_EXTERNAL_MEMORY_HANDLE_TYPE_NVSCIBUF, which otherwise are performed by default to ensure data coherency with other importers of the same NvSciBuf memory objects.
`static int`	`CUDA_EXTERNAL_SEMAPHORE_WAIT_SKIP_NVSCIBUF_MEMSYNC`	When the /p flags parameter of ::CUDA_EXTERNAL_SEMAPHORE_WAIT_PARAMS contains this flag, it indicates that waiting on an external semaphore object should skip performing appropriate memory synchronization operations over all the external memory objects that are imported as ::CU_EXTERNAL_MEMORY_HANDLE_TYPE_NVSCIBUF, which otherwise are performed by default to ensure data coherency with other importers of the same NvSciBuf memory objects.
`static int`	`CUDA_IPC_HANDLE_SIZE`	CUDA IPC Handle Size
`static int`	`CUDA_NVSCISYNC_ATTR_SIGNAL`	When /p flags of ::cuDeviceGetNvSciSyncAttributes is set to this, it indicates that application needs signaler specific NvSciSyncAttr to be filled by ::cuDeviceGetNvSciSyncAttributes.
`static int`	`CUDA_NVSCISYNC_ATTR_WAIT`	When /p flags of ::cuDeviceGetNvSciSyncAttributes is set to this, it indicates that application needs waiter specific NvSciSyncAttr to be filled by ::cuDeviceGetNvSciSyncAttributes.
`static int`	`CUDA_R_16F`	enum cudaDataType
`static int`	`CUDA_R_32F`	enum cudaDataType
`static int`	`CUDA_R_32I`	enum cudaDataType
`static int`	`CUDA_R_32U`	enum cudaDataType
`static int`	`CUDA_R_64F`	enum cudaDataType
`static int`	`CUDA_R_8I`	enum cudaDataType
`static int`	`CUDA_R_8U`	enum cudaDataType
`static int`	`CUDA_SUCCESS`	enum CUresult
`static int`	`CUDA_VERSION`	CUDA API version number
`static int`	`cudaAddressModeBorder`	enum cudaTextureAddressMode
`static int`	`cudaAddressModeClamp`	enum cudaTextureAddressMode
`static int`	`cudaAddressModeMirror`	enum cudaTextureAddressMode
`static int`	`cudaAddressModeWrap`	enum cudaTextureAddressMode
`static int`	`cudaArrayColorAttachment`	Must be set in cudaExternalMemoryGetMappedMipmappedArray if the mipmapped array is used as a color target in a graphics API
`static int`	`cudaArrayCubemap`	Must be set in cudaMalloc3DArray to create a cubemap CUDA array
`static int`	`cudaArrayDefault`	Default CUDA array allocation flag
`static int`	`cudaArrayLayered`	Must be set in cudaMalloc3DArray to create a layered CUDA array
`static int`	`cudaArraySurfaceLoadStore`	Must be set in cudaMallocArray or cudaMalloc3DArray in order to bind surfaces to the CUDA array
`static int`	`cudaArrayTextureGather`	Must be set in cudaMallocArray or cudaMalloc3DArray in order to perform texture gather operations on the CUDA array
`static int`	`cudaBoundaryModeClamp`	enum cudaSurfaceBoundaryMode
`static int`	`cudaBoundaryModeTrap`	enum cudaSurfaceBoundaryMode
`static int`	`cudaBoundaryModeZero`	enum cudaSurfaceBoundaryMode
`static int`	`cudaCGScopeGrid`	enum cudaCGScope
`static int`	`cudaCGScopeInvalid`	enum cudaCGScope
`static int`	`cudaCGScopeMultiGrid`	enum cudaCGScope
`static int`	`cudaChannelFormatKindFloat`	enum cudaChannelFormatKind
`static int`	`cudaChannelFormatKindNone`	enum cudaChannelFormatKind
`static int`	`cudaChannelFormatKindSigned`	enum cudaChannelFormatKind
`static int`	`cudaChannelFormatKindUnsigned`	enum cudaChannelFormatKind
`static int`	`cudaComputeModeDefault`	enum cudaComputeMode
`static int`	`cudaComputeModeExclusive`	enum cudaComputeMode
`static int`	`cudaComputeModeExclusiveProcess`	enum cudaComputeMode
`static int`	`cudaComputeModeProhibited`	enum cudaComputeMode
`static int`	`cudaCooperativeLaunchMultiDeviceNoPostSync`	If set, any subsequent work pushed in a stream that participated in a call to ::cudaLaunchCooperativeKernelMultiDevice will only wait for the kernel launched on the GPU corresponding to that stream to complete before it begins execution.
`static int`	`cudaCooperativeLaunchMultiDeviceNoPreSync`	If set, each kernel launched as part of ::cudaLaunchCooperativeKernelMultiDevice only waits for prior work in the stream corresponding to that GPU to complete before the kernel begins execution.
`static int`	`cudaCpuDeviceId`	Device id that represents the CPU
`static int`	`cudaCSV`	enum cudaOutputMode
`static int`	`cudaDevAttrAsyncEngineCount`	enum cudaDeviceAttr
`static int`	`cudaDevAttrCanFlushRemoteWrites`	enum cudaDeviceAttr
`static int`	`cudaDevAttrCanMapHostMemory`	enum cudaDeviceAttr
`static int`	`cudaDevAttrCanUseHostPointerForRegisteredMem`	enum cudaDeviceAttr
`static int`	`cudaDevAttrClockRate`	enum cudaDeviceAttr
`static int`	`cudaDevAttrComputeCapabilityMajor`	enum cudaDeviceAttr
`static int`	`cudaDevAttrComputeCapabilityMinor`	enum cudaDeviceAttr
`static int`	`cudaDevAttrComputeMode`	enum cudaDeviceAttr
`static int`	`cudaDevAttrComputePreemptionSupported`	enum cudaDeviceAttr
`static int`	`cudaDevAttrConcurrentKernels`	enum cudaDeviceAttr
`static int`	`cudaDevAttrConcurrentManagedAccess`	enum cudaDeviceAttr
`static int`	`cudaDevAttrCooperativeLaunch`	enum cudaDeviceAttr
`static int`	`cudaDevAttrCooperativeMultiDeviceLaunch`	enum cudaDeviceAttr
`static int`	`cudaDevAttrDirectManagedMemAccessFromHost`	enum cudaDeviceAttr
`static int`	`cudaDevAttrEccEnabled`	enum cudaDeviceAttr
`static int`	`cudaDevAttrGlobalL1CacheSupported`	enum cudaDeviceAttr
`static int`	`cudaDevAttrGlobalMemoryBusWidth`	enum cudaDeviceAttr
`static int`	`cudaDevAttrGpuOverlap`	enum cudaDeviceAttr
`static int`	`cudaDevAttrHostNativeAtomicSupported`	enum cudaDeviceAttr
`static int`	`cudaDevAttrHostRegisterSupported`	enum cudaDeviceAttr
`static int`	`cudaDevAttrIntegrated`	enum cudaDeviceAttr
`static int`	`cudaDevAttrIsMultiGpuBoard`	enum cudaDeviceAttr
`static int`	`cudaDevAttrKernelExecTimeout`	enum cudaDeviceAttr
`static int`	`cudaDevAttrL2CacheSize`	enum cudaDeviceAttr
`static int`	`cudaDevAttrLocalL1CacheSupported`	enum cudaDeviceAttr
`static int`	`cudaDevAttrManagedMemory`	enum cudaDeviceAttr
`static int`	`cudaDevAttrMaxBlockDimX`	enum cudaDeviceAttr
`static int`	`cudaDevAttrMaxBlockDimY`	enum cudaDeviceAttr
`static int`	`cudaDevAttrMaxBlockDimZ`	enum cudaDeviceAttr
`static int`	`cudaDevAttrMaxGridDimX`	enum cudaDeviceAttr
`static int`	`cudaDevAttrMaxGridDimY`	enum cudaDeviceAttr
`static int`	`cudaDevAttrMaxGridDimZ`	enum cudaDeviceAttr
`static int`	`cudaDevAttrMaxPitch`	enum cudaDeviceAttr
`static int`	`cudaDevAttrMaxRegistersPerBlock`	enum cudaDeviceAttr
`static int`	`cudaDevAttrMaxRegistersPerMultiprocessor`	enum cudaDeviceAttr
`static int`	`cudaDevAttrMaxSharedMemoryPerBlock`	enum cudaDeviceAttr
`static int`	`cudaDevAttrMaxSharedMemoryPerBlockOptin`	enum cudaDeviceAttr
`static int`	`cudaDevAttrMaxSharedMemoryPerMultiprocessor`	enum cudaDeviceAttr
`static int`	`cudaDevAttrMaxSurface1DLayeredLayers`	enum cudaDeviceAttr
`static int`	`cudaDevAttrMaxSurface1DLayeredWidth`	enum cudaDeviceAttr
`static int`	`cudaDevAttrMaxSurface1DWidth`	enum cudaDeviceAttr
`static int`	`cudaDevAttrMaxSurface2DHeight`	enum cudaDeviceAttr
`static int`	`cudaDevAttrMaxSurface2DLayeredHeight`	enum cudaDeviceAttr
`static int`	`cudaDevAttrMaxSurface2DLayeredLayers`	enum cudaDeviceAttr
`static int`	`cudaDevAttrMaxSurface2DLayeredWidth`	enum cudaDeviceAttr
`static int`	`cudaDevAttrMaxSurface2DWidth`	enum cudaDeviceAttr
`static int`	`cudaDevAttrMaxSurface3DDepth`	enum cudaDeviceAttr
`static int`	`cudaDevAttrMaxSurface3DHeight`	enum cudaDeviceAttr
`static int`	`cudaDevAttrMaxSurface3DWidth`	enum cudaDeviceAttr
`static int`	`cudaDevAttrMaxSurfaceCubemapLayeredLayers`	enum cudaDeviceAttr
`static int`	`cudaDevAttrMaxSurfaceCubemapLayeredWidth`	enum cudaDeviceAttr
`static int`	`cudaDevAttrMaxSurfaceCubemapWidth`	enum cudaDeviceAttr
`static int`	`cudaDevAttrMaxTexture1DLayeredLayers`	enum cudaDeviceAttr
`static int`	`cudaDevAttrMaxTexture1DLayeredWidth`	enum cudaDeviceAttr
`static int`	`cudaDevAttrMaxTexture1DLinearWidth`	enum cudaDeviceAttr
`static int`	`cudaDevAttrMaxTexture1DMipmappedWidth`	enum cudaDeviceAttr
`static int`	`cudaDevAttrMaxTexture1DWidth`	enum cudaDeviceAttr
`static int`	`cudaDevAttrMaxTexture2DGatherHeight`	enum cudaDeviceAttr
`static int`	`cudaDevAttrMaxTexture2DGatherWidth`	enum cudaDeviceAttr
`static int`	`cudaDevAttrMaxTexture2DHeight`	enum cudaDeviceAttr
`static int`	`cudaDevAttrMaxTexture2DLayeredHeight`	enum cudaDeviceAttr
`static int`	`cudaDevAttrMaxTexture2DLayeredLayers`	enum cudaDeviceAttr
`static int`	`cudaDevAttrMaxTexture2DLayeredWidth`	enum cudaDeviceAttr
`static int`	`cudaDevAttrMaxTexture2DLinearHeight`	enum cudaDeviceAttr
`static int`	`cudaDevAttrMaxTexture2DLinearPitch`	enum cudaDeviceAttr
`static int`	`cudaDevAttrMaxTexture2DLinearWidth`	enum cudaDeviceAttr
`static int`	`cudaDevAttrMaxTexture2DMipmappedHeight`	enum cudaDeviceAttr
`static int`	`cudaDevAttrMaxTexture2DMipmappedWidth`	enum cudaDeviceAttr
`static int`	`cudaDevAttrMaxTexture2DWidth`	enum cudaDeviceAttr
`static int`	`cudaDevAttrMaxTexture3DDepth`	enum cudaDeviceAttr
`static int`	`cudaDevAttrMaxTexture3DDepthAlt`	enum cudaDeviceAttr
`static int`	`cudaDevAttrMaxTexture3DHeight`	enum cudaDeviceAttr
`static int`	`cudaDevAttrMaxTexture3DHeightAlt`	enum cudaDeviceAttr
`static int`	`cudaDevAttrMaxTexture3DWidth`	enum cudaDeviceAttr
`static int`	`cudaDevAttrMaxTexture3DWidthAlt`	enum cudaDeviceAttr
`static int`	`cudaDevAttrMaxTextureCubemapLayeredLayers`	enum cudaDeviceAttr
`static int`	`cudaDevAttrMaxTextureCubemapLayeredWidth`	enum cudaDeviceAttr
`static int`	`cudaDevAttrMaxTextureCubemapWidth`	enum cudaDeviceAttr
`static int`	`cudaDevAttrMaxThreadsPerBlock`	enum cudaDeviceAttr
`static int`	`cudaDevAttrMaxThreadsPerMultiProcessor`	enum cudaDeviceAttr
`static int`	`cudaDevAttrMemoryClockRate`	enum cudaDeviceAttr
`static int`	`cudaDevAttrMultiGpuBoardGroupID`	enum cudaDeviceAttr
`static int`	`cudaDevAttrMultiProcessorCount`	enum cudaDeviceAttr
`static int`	`cudaDevAttrPageableMemoryAccess`	enum cudaDeviceAttr
`static int`	`cudaDevAttrPageableMemoryAccessUsesHostPageTables`	enum cudaDeviceAttr
`static int`	`cudaDevAttrPciBusId`	enum cudaDeviceAttr
`static int`	`cudaDevAttrPciDeviceId`	enum cudaDeviceAttr
`static int`	`cudaDevAttrPciDomainId`	enum cudaDeviceAttr
`static int`	`cudaDevAttrReserved92`	enum cudaDeviceAttr
`static int`	`cudaDevAttrReserved93`	enum cudaDeviceAttr
`static int`	`cudaDevAttrReserved94`	enum cudaDeviceAttr
`static int`	`cudaDevAttrSingleToDoublePrecisionPerfRatio`	enum cudaDeviceAttr
`static int`	`cudaDevAttrStreamPrioritiesSupported`	enum cudaDeviceAttr
`static int`	`cudaDevAttrSurfaceAlignment`	enum cudaDeviceAttr
`static int`	`cudaDevAttrTccDriver`	enum cudaDeviceAttr
`static int`	`cudaDevAttrTextureAlignment`	enum cudaDeviceAttr
`static int`	`cudaDevAttrTexturePitchAlignment`	enum cudaDeviceAttr
`static int`	`cudaDevAttrTotalConstantMemory`	enum cudaDeviceAttr
`static int`	`cudaDevAttrUnifiedAddressing`	enum cudaDeviceAttr
`static int`	`cudaDevAttrWarpSize`	enum cudaDeviceAttr
`static int`	`cudaDeviceBlockingSync`	Deprecated. This flag was deprecated as of CUDA 4.0 and replaced with ::cudaDeviceScheduleBlockingSync.
`static int`	`cudaDeviceLmemResizeToMax`	Device flag - Keep local memory allocation after launch
`static int`	`cudaDeviceMapHost`	Device flag - Support mapped pinned allocations
`static int`	`cudaDeviceMask`	Device flags mask
`static int`	`cudaDeviceScheduleAuto`	Device flag - Automatic scheduling
`static int`	`cudaDeviceScheduleBlockingSync`	Device flag - Use blocking synchronization
`static int`	`cudaDeviceScheduleMask`	Device schedule flags mask
`static int`	`cudaDeviceScheduleSpin`	Device flag - Spin default scheduling
`static int`	`cudaDeviceScheduleYield`	Device flag - Yield default scheduling
`static int`	`cudaDevP2PAttrAccessSupported`	enum cudaDeviceP2PAttr
`static int`	`cudaDevP2PAttrCudaArrayAccessSupported`	enum cudaDeviceP2PAttr
`static int`	`cudaDevP2PAttrNativeAtomicSupported`	enum cudaDeviceP2PAttr
`static int`	`cudaDevP2PAttrPerformanceRank`	enum cudaDeviceP2PAttr
`static int`	`cudaErrorAddressOfConstant`	enum cudaError
`static int`	`cudaErrorAlreadyAcquired`	enum cudaError
`static int`	`cudaErrorAlreadyMapped`	enum cudaError
`static int`	`cudaErrorApiFailureBase`	enum cudaError
`static int`	`cudaErrorArrayIsMapped`	enum cudaError
`static int`	`cudaErrorAssert`	enum cudaError
`static int`	`cudaErrorCapturedEvent`	enum cudaError
`static int`	`cudaErrorCompatNotSupportedOnDevice`	enum cudaError
`static int`	`cudaErrorContextIsDestroyed`	enum cudaError
`static int`	`cudaErrorCooperativeLaunchTooLarge`	enum cudaError
`static int`	`cudaErrorCudartUnloading`	enum cudaError
`static int`	`cudaErrorDeviceAlreadyInUse`	enum cudaError
`static int`	`cudaErrorDevicesUnavailable`	enum cudaError
`static int`	`cudaErrorDeviceUninitialized`	enum cudaError
`static int`	`cudaErrorDuplicateSurfaceName`	enum cudaError
`static int`	`cudaErrorDuplicateTextureName`	enum cudaError
`static int`	`cudaErrorDuplicateVariableName`	enum cudaError
`static int`	`cudaErrorECCUncorrectable`	enum cudaError
`static int`	`cudaErrorFileNotFound`	enum cudaError
`static int`	`cudaErrorGraphExecUpdateFailure`	enum cudaError
`static int`	`cudaErrorHardwareStackError`	enum cudaError
`static int`	`cudaErrorHostMemoryAlreadyRegistered`	enum cudaError
`static int`	`cudaErrorHostMemoryNotRegistered`	enum cudaError
`static int`	`cudaErrorIllegalAddress`	enum cudaError
`static int`	`cudaErrorIllegalInstruction`	enum cudaError
`static int`	`cudaErrorIllegalState`	enum cudaError
`static int`	`cudaErrorIncompatibleDriverContext`	enum cudaError
`static int`	`cudaErrorInitializationError`	enum cudaError
`static int`	`cudaErrorInsufficientDriver`	enum cudaError
`static int`	`cudaErrorInvalidAddressSpace`	enum cudaError
`static int`	`cudaErrorInvalidChannelDescriptor`	enum cudaError
`static int`	`cudaErrorInvalidConfiguration`	enum cudaError
`static int`	`cudaErrorInvalidDevice`	enum cudaError
`static int`	`cudaErrorInvalidDeviceFunction`	enum cudaError
`static int`	`cudaErrorInvalidDevicePointer`	enum cudaError
`static int`	`cudaErrorInvalidFilterSetting`	enum cudaError
`static int`	`cudaErrorInvalidGraphicsContext`	enum cudaError
`static int`	`cudaErrorInvalidHostPointer`	enum cudaError
`static int`	`cudaErrorInvalidKernelImage`	enum cudaError
`static int`	`cudaErrorInvalidMemcpyDirection`	enum cudaError
`static int`	`cudaErrorInvalidNormSetting`	enum cudaError
`static int`	`cudaErrorInvalidPc`	enum cudaError
`static int`	`cudaErrorInvalidPitchValue`	enum cudaError
`static int`	`cudaErrorInvalidPtx`	enum cudaError
`static int`	`cudaErrorInvalidResourceHandle`	enum cudaError
`static int`	`cudaErrorInvalidSource`	enum cudaError
`static int`	`cudaErrorInvalidSurface`	enum cudaError
`static int`	`cudaErrorInvalidSymbol`	enum cudaError
`static int`	`cudaErrorInvalidTexture`	enum cudaError
`static int`	`cudaErrorInvalidTextureBinding`	enum cudaError
`static int`	`cudaErrorInvalidValue`	enum cudaError
`static int`	`cudaErrorJitCompilerNotFound`	enum cudaError
`static int`	`cudaErrorLaunchFailure`	enum cudaError
`static int`	`cudaErrorLaunchFileScopedSurf`	enum cudaError
`static int`	`cudaErrorLaunchFileScopedTex`	enum cudaError
`static int`	`cudaErrorLaunchIncompatibleTexturing`	enum cudaError
`static int`	`cudaErrorLaunchMaxDepthExceeded`	enum cudaError
`static int`	`cudaErrorLaunchOutOfResources`	enum cudaError
`static int`	`cudaErrorLaunchPendingCountExceeded`	enum cudaError
`static int`	`cudaErrorLaunchTimeout`	enum cudaError
`static int`	`cudaErrorMapBufferObjectFailed`	enum cudaError
`static int`	`cudaErrorMemoryAllocation`	enum cudaError
`static int`	`cudaErrorMemoryValueTooLarge`	enum cudaError
`static int`	`cudaErrorMisalignedAddress`	enum cudaError
`static int`	`cudaErrorMissingConfiguration`	enum cudaError
`static int`	`cudaErrorMixedDeviceExecution`	enum cudaError
`static int`	`cudaErrorNoDevice`	enum cudaError
`static int`	`cudaErrorNoKernelImageForDevice`	enum cudaError
`static int`	`cudaErrorNotMapped`	enum cudaError
`static int`	`cudaErrorNotMappedAsArray`	enum cudaError
`static int`	`cudaErrorNotMappedAsPointer`	enum cudaError
`static int`	`cudaErrorNotPermitted`	enum cudaError
`static int`	`cudaErrorNotReady`	enum cudaError
`static int`	`cudaErrorNotSupported`	enum cudaError
`static int`	`cudaErrorNotYetImplemented`	enum cudaError
`static int`	`cudaErrorNvlinkUncorrectable`	enum cudaError
`static int`	`cudaErrorOperatingSystem`	enum cudaError
`static int`	`cudaErrorPeerAccessAlreadyEnabled`	enum cudaError
`static int`	`cudaErrorPeerAccessNotEnabled`	enum cudaError
`static int`	`cudaErrorPeerAccessUnsupported`	enum cudaError
`static int`	`cudaErrorPriorLaunchFailure`	enum cudaError
`static int`	`cudaErrorProfilerAlreadyStarted`	enum cudaError
`static int`	`cudaErrorProfilerAlreadyStopped`	enum cudaError
`static int`	`cudaErrorProfilerDisabled`	enum cudaError
`static int`	`cudaErrorProfilerNotInitialized`	enum cudaError
`static int`	`cudaErrorSetOnActiveProcess`	enum cudaError
`static int`	`cudaErrorSharedObjectInitFailed`	enum cudaError
`static int`	`cudaErrorSharedObjectSymbolNotFound`	enum cudaError
`static int`	`cudaErrorStartupFailure`	enum cudaError
`static int`	`cudaErrorStreamCaptureImplicit`	enum cudaError
`static int`	`cudaErrorStreamCaptureInvalidated`	enum cudaError
`static int`	`cudaErrorStreamCaptureIsolation`	enum cudaError
`static int`	`cudaErrorStreamCaptureMerge`	enum cudaError
`static int`	`cudaErrorStreamCaptureUnjoined`	enum cudaError
`static int`	`cudaErrorStreamCaptureUnmatched`	enum cudaError
`static int`	`cudaErrorStreamCaptureUnsupported`	enum cudaError
`static int`	`cudaErrorStreamCaptureWrongThread`	enum cudaError
`static int`	`cudaErrorSymbolNotFound`	enum cudaError
`static int`	`cudaErrorSyncDepthExceeded`	enum cudaError
`static int`	`cudaErrorSynchronizationError`	enum cudaError
`static int`	`cudaErrorSystemDriverMismatch`	enum cudaError
`static int`	`cudaErrorSystemNotReady`	enum cudaError
`static int`	`cudaErrorTextureFetchFailed`	enum cudaError
`static int`	`cudaErrorTextureNotBound`	enum cudaError
`static int`	`cudaErrorTimeout`	enum cudaError
`static int`	`cudaErrorTooManyPeers`	enum cudaError
`static int`	`cudaErrorUnknown`	enum cudaError
`static int`	`cudaErrorUnmapBufferObjectFailed`	enum cudaError
`static int`	`cudaErrorUnsupportedLimit`	enum cudaError
`static int`	`cudaEventBlockingSync`	Event uses blocking synchronization
`static int`	`cudaEventDefault`	Default event flag
`static int`	`cudaEventDisableTiming`	Event will not record timing data
`static int`	`cudaEventInterprocess`	Event is suitable for interprocess use.
`static int`	`cudaExternalMemoryDedicated`	Indicates that the external memory object is a dedicated resource
`static int`	`cudaExternalMemoryHandleTypeD3D11Resource`	enum cudaExternalMemoryHandleType
`static int`	`cudaExternalMemoryHandleTypeD3D11ResourceKmt`	enum cudaExternalMemoryHandleType
`static int`	`cudaExternalMemoryHandleTypeD3D12Heap`	enum cudaExternalMemoryHandleType
`static int`	`cudaExternalMemoryHandleTypeD3D12Resource`	enum cudaExternalMemoryHandleType
`static int`	`cudaExternalMemoryHandleTypeNvSciBuf`	enum cudaExternalMemoryHandleType
`static int`	`cudaExternalMemoryHandleTypeOpaqueFd`	enum cudaExternalMemoryHandleType
`static int`	`cudaExternalMemoryHandleTypeOpaqueWin32`	enum cudaExternalMemoryHandleType
`static int`	`cudaExternalMemoryHandleTypeOpaqueWin32Kmt`	enum cudaExternalMemoryHandleType
`static int`	`cudaExternalSemaphoreHandleTypeD3D11Fence`	enum cudaExternalSemaphoreHandleType
`static int`	`cudaExternalSemaphoreHandleTypeD3D12Fence`	enum cudaExternalSemaphoreHandleType
`static int`	`cudaExternalSemaphoreHandleTypeKeyedMutex`	enum cudaExternalSemaphoreHandleType
`static int`	`cudaExternalSemaphoreHandleTypeKeyedMutexKmt`	enum cudaExternalSemaphoreHandleType
`static int`	`cudaExternalSemaphoreHandleTypeNvSciSync`	enum cudaExternalSemaphoreHandleType
`static int`	`cudaExternalSemaphoreHandleTypeOpaqueFd`	enum cudaExternalSemaphoreHandleType
`static int`	`cudaExternalSemaphoreHandleTypeOpaqueWin32`	enum cudaExternalSemaphoreHandleType
`static int`	`cudaExternalSemaphoreHandleTypeOpaqueWin32Kmt`	enum cudaExternalSemaphoreHandleType
`static int`	`cudaExternalSemaphoreSignalSkipNvSciBufMemSync`	When the /p flags parameter of ::cudaExternalSemaphoreSignalParams contains this flag, it indicates that signaling an external semaphore object should skip performing appropriate memory synchronization operations over all the external memory objects that are imported as ::cudaExternalMemoryHandleTypeNvSciBuf, which otherwise are performed by default to ensure data coherency with other importers of the same NvSciBuf memory objects.
`static int`	`cudaExternalSemaphoreWaitSkipNvSciBufMemSync`	When the /p flags parameter of ::cudaExternalSemaphoreWaitParams contains this flag, it indicates that waiting an external semaphore object should skip performing appropriate memory synchronization operations over all the external memory objects that are imported as ::cudaExternalMemoryHandleTypeNvSciBuf, which otherwise are performed by default to ensure data coherency with other importers of the same NvSciBuf memory objects.
`static int`	`cudaFilterModeLinear`	enum cudaTextureFilterMode
`static int`	`cudaFilterModePoint`	enum cudaTextureFilterMode
`static int`	`cudaFormatModeAuto`	enum cudaSurfaceFormatMode
`static int`	`cudaFormatModeForced`	enum cudaSurfaceFormatMode
`static int`	`cudaFuncAttributeMax`	enum cudaFuncAttribute
`static int`	`cudaFuncAttributeMaxDynamicSharedMemorySize`	enum cudaFuncAttribute
`static int`	`cudaFuncAttributePreferredSharedMemoryCarveout`	enum cudaFuncAttribute
`static int`	`cudaFuncCachePreferEqual`	enum cudaFuncCache
`static int`	`cudaFuncCachePreferL1`	enum cudaFuncCache
`static int`	`cudaFuncCachePreferNone`	enum cudaFuncCache
`static int`	`cudaFuncCachePreferShared`	enum cudaFuncCache
`static int`	`cudaGraphExecUpdateError`	enum cudaGraphExecUpdateResult
`static int`	`cudaGraphExecUpdateErrorFunctionChanged`	enum cudaGraphExecUpdateResult
`static int`	`cudaGraphExecUpdateErrorNodeTypeChanged`	enum cudaGraphExecUpdateResult
`static int`	`cudaGraphExecUpdateErrorNotSupported`	enum cudaGraphExecUpdateResult
`static int`	`cudaGraphExecUpdateErrorParametersChanged`	enum cudaGraphExecUpdateResult
`static int`	`cudaGraphExecUpdateErrorTopologyChanged`	enum cudaGraphExecUpdateResult
`static int`	`cudaGraphExecUpdateSuccess`	enum cudaGraphExecUpdateResult
`static int`	`cudaGraphicsCubeFaceNegativeX`	enum cudaGraphicsCubeFace
`static int`	`cudaGraphicsCubeFaceNegativeY`	enum cudaGraphicsCubeFace
`static int`	`cudaGraphicsCubeFaceNegativeZ`	enum cudaGraphicsCubeFace
`static int`	`cudaGraphicsCubeFacePositiveX`	enum cudaGraphicsCubeFace
`static int`	`cudaGraphicsCubeFacePositiveY`	enum cudaGraphicsCubeFace
`static int`	`cudaGraphicsCubeFacePositiveZ`	enum cudaGraphicsCubeFace
`static int`	`cudaGraphicsMapFlagsNone`	enum cudaGraphicsMapFlags
`static int`	`cudaGraphicsMapFlagsReadOnly`	enum cudaGraphicsMapFlags
`static int`	`cudaGraphicsMapFlagsWriteDiscard`	enum cudaGraphicsMapFlags
`static int`	`cudaGraphicsRegisterFlagsNone`	enum cudaGraphicsRegisterFlags
`static int`	`cudaGraphicsRegisterFlagsReadOnly`	enum cudaGraphicsRegisterFlags
`static int`	`cudaGraphicsRegisterFlagsSurfaceLoadStore`	enum cudaGraphicsRegisterFlags
`static int`	`cudaGraphicsRegisterFlagsTextureGather`	enum cudaGraphicsRegisterFlags
`static int`	`cudaGraphicsRegisterFlagsWriteDiscard`	enum cudaGraphicsRegisterFlags
`static int`	`cudaGraphNodeTypeCount`	enum cudaGraphNodeType
`static int`	`cudaGraphNodeTypeEmpty`	enum cudaGraphNodeType
`static int`	`cudaGraphNodeTypeGraph`	enum cudaGraphNodeType
`static int`	`cudaGraphNodeTypeHost`	enum cudaGraphNodeType
`static int`	`cudaGraphNodeTypeKernel`	enum cudaGraphNodeType
`static int`	`cudaGraphNodeTypeMemcpy`	enum cudaGraphNodeType
`static int`	`cudaGraphNodeTypeMemset`	enum cudaGraphNodeType
`static int`	`cudaHostAllocDefault`	Default page-locked allocation flag
`static int`	`cudaHostAllocMapped`	Map allocation into device space
`static int`	`cudaHostAllocPortable`	Pinned memory accessible by all CUDA contexts
`static int`	`cudaHostAllocWriteCombined`	Write-combined memory
`static int`	`cudaHostRegisterDefault`	Default host memory registration flag
`static int`	`cudaHostRegisterIoMemory`	Memory-mapped I/O space
`static int`	`cudaHostRegisterMapped`	Map registered memory into device space
`static int`	`cudaHostRegisterPortable`	Pinned memory accessible by all CUDA contexts
`static int`	`cudaInvalidDeviceId`	Device id that represents an invalid device
`static int`	`cudaIpcMemLazyEnablePeerAccess`	Automatically enable peer access between remote devices as needed
`static int`	`cudaKeyValuePair`	enum cudaOutputMode
`static int`	`cudaLimitDevRuntimePendingLaunchCount`	enum cudaLimit
`static int`	`cudaLimitDevRuntimeSyncDepth`	enum cudaLimit
`static int`	`cudaLimitMallocHeapSize`	enum cudaLimit
`static int`	`cudaLimitMaxL2FetchGranularity`	enum cudaLimit
`static int`	`cudaLimitPrintfFifoSize`	enum cudaLimit
`static int`	`cudaLimitStackSize`	enum cudaLimit
`static int`	`cudaMemAdviseSetAccessedBy`	enum cudaMemoryAdvise
`static int`	`cudaMemAdviseSetPreferredLocation`	enum cudaMemoryAdvise
`static int`	`cudaMemAdviseSetReadMostly`	enum cudaMemoryAdvise
`static int`	`cudaMemAdviseUnsetAccessedBy`	enum cudaMemoryAdvise
`static int`	`cudaMemAdviseUnsetPreferredLocation`	enum cudaMemoryAdvise
`static int`	`cudaMemAdviseUnsetReadMostly`	enum cudaMemoryAdvise
`static int`	`cudaMemAttachGlobal`	Memory can be accessed by any stream on any device
`static int`	`cudaMemAttachHost`	Memory cannot be accessed by any stream on any device
`static int`	`cudaMemAttachSingle`	Memory can only be accessed by a single stream on the associated device
`static int`	`cudaMemcpyDefault`	enum cudaMemcpyKind
`static int`	`cudaMemcpyDeviceToDevice`	enum cudaMemcpyKind
`static int`	`cudaMemcpyDeviceToHost`	enum cudaMemcpyKind
`static int`	`cudaMemcpyHostToDevice`	enum cudaMemcpyKind
`static int`	`cudaMemcpyHostToHost`	enum cudaMemcpyKind
`static int`	`cudaMemoryTypeDevice`	enum cudaMemoryType
`static int`	`cudaMemoryTypeHost`	enum cudaMemoryType
`static int`	`cudaMemoryTypeManaged`	enum cudaMemoryType
`static int`	`cudaMemoryTypeUnregistered`	enum cudaMemoryType
`static int`	`cudaMemRangeAttributeAccessedBy`	enum cudaMemRangeAttribute
`static int`	`cudaMemRangeAttributeLastPrefetchLocation`	enum cudaMemRangeAttribute
`static int`	`cudaMemRangeAttributePreferredLocation`	enum cudaMemRangeAttribute
`static int`	`cudaMemRangeAttributeReadMostly`	enum cudaMemRangeAttribute
`static int`	`cudaNvSciSyncAttrSignal`	When /p flags of ::cudaDeviceGetNvSciSyncAttributes is set to this, it indicates that application need signaler specific NvSciSyncAttr to be filled by ::cudaDeviceGetNvSciSyncAttributes.
`static int`	`cudaNvSciSyncAttrWait`	When /p flags of ::cudaDeviceGetNvSciSyncAttributes is set to this, it indicates that application need waiter specific NvSciSyncAttr to be filled by ::cudaDeviceGetNvSciSyncAttributes.
`static int`	`cudaOccupancyDefault`	Default behavior
`static int`	`cudaOccupancyDisableCachingOverride`	Assume global caching is enabled and cannot be automatically turned off
`static int`	`cudaPeerAccessDefault`	Default peer addressing enable flag
`static int`	`cudaReadModeElementType`	enum cudaTextureReadMode
`static int`	`cudaReadModeNormalizedFloat`	enum cudaTextureReadMode
`static int`	`cudaResourceTypeArray`	enum cudaResourceType
`static int`	`cudaResourceTypeLinear`	enum cudaResourceType
`static int`	`cudaResourceTypeMipmappedArray`	enum cudaResourceType
`static int`	`cudaResourceTypePitch2D`	enum cudaResourceType
`static int`	`cudaResViewFormatFloat1`	enum cudaResourceViewFormat
`static int`	`cudaResViewFormatFloat2`	enum cudaResourceViewFormat
`static int`	`cudaResViewFormatFloat4`	enum cudaResourceViewFormat
`static int`	`cudaResViewFormatHalf1`	enum cudaResourceViewFormat
`static int`	`cudaResViewFormatHalf2`	enum cudaResourceViewFormat
`static int`	`cudaResViewFormatHalf4`	enum cudaResourceViewFormat
`static int`	`cudaResViewFormatNone`	enum cudaResourceViewFormat
`static int`	`cudaResViewFormatSignedBlockCompressed4`	enum cudaResourceViewFormat
`static int`	`cudaResViewFormatSignedBlockCompressed5`	enum cudaResourceViewFormat
`static int`	`cudaResViewFormatSignedBlockCompressed6H`	enum cudaResourceViewFormat
`static int`	`cudaResViewFormatSignedChar1`	enum cudaResourceViewFormat
`static int`	`cudaResViewFormatSignedChar2`	enum cudaResourceViewFormat
`static int`	`cudaResViewFormatSignedChar4`	enum cudaResourceViewFormat
`static int`	`cudaResViewFormatSignedInt1`	enum cudaResourceViewFormat
`static int`	`cudaResViewFormatSignedInt2`	enum cudaResourceViewFormat
`static int`	`cudaResViewFormatSignedInt4`	enum cudaResourceViewFormat
`static int`	`cudaResViewFormatSignedShort1`	enum cudaResourceViewFormat
`static int`	`cudaResViewFormatSignedShort2`	enum cudaResourceViewFormat
`static int`	`cudaResViewFormatSignedShort4`	enum cudaResourceViewFormat
`static int`	`cudaResViewFormatUnsignedBlockCompressed1`	enum cudaResourceViewFormat
`static int`	`cudaResViewFormatUnsignedBlockCompressed2`	enum cudaResourceViewFormat
`static int`	`cudaResViewFormatUnsignedBlockCompressed3`	enum cudaResourceViewFormat
`static int`	`cudaResViewFormatUnsignedBlockCompressed4`	enum cudaResourceViewFormat
`static int`	`cudaResViewFormatUnsignedBlockCompressed5`	enum cudaResourceViewFormat
`static int`	`cudaResViewFormatUnsignedBlockCompressed6H`	enum cudaResourceViewFormat
`static int`	`cudaResViewFormatUnsignedBlockCompressed7`	enum cudaResourceViewFormat
`static int`	`cudaResViewFormatUnsignedChar1`	enum cudaResourceViewFormat
`static int`	`cudaResViewFormatUnsignedChar2`	enum cudaResourceViewFormat
`static int`	`cudaResViewFormatUnsignedChar4`	enum cudaResourceViewFormat
`static int`	`cudaResViewFormatUnsignedInt1`	enum cudaResourceViewFormat
`static int`	`cudaResViewFormatUnsignedInt2`	enum cudaResourceViewFormat
`static int`	`cudaResViewFormatUnsignedInt4`	enum cudaResourceViewFormat
`static int`	`cudaResViewFormatUnsignedShort1`	enum cudaResourceViewFormat
`static int`	`cudaResViewFormatUnsignedShort2`	enum cudaResourceViewFormat
`static int`	`cudaResViewFormatUnsignedShort4`	enum cudaResourceViewFormat
`static int`	`cudaRoundMinInf`	enum cudaRoundMode
`static int`	`cudaRoundNearest`	enum cudaRoundMode
`static int`	`cudaRoundPosInf`	enum cudaRoundMode
`static int`	`cudaRoundZero`	enum cudaRoundMode
`static int`	`CUDART_VERSION`	CUDA Runtime API Version
`static int`	`cudaSharedMemBankSizeDefault`	enum cudaSharedMemConfig
`static int`	`cudaSharedMemBankSizeEightByte`	enum cudaSharedMemConfig
`static int`	`cudaSharedMemBankSizeFourByte`	enum cudaSharedMemConfig
`static int`	`cudaSharedmemCarveoutDefault`	enum cudaSharedCarveout
`static int`	`cudaSharedmemCarveoutMaxL1`	enum cudaSharedCarveout
`static int`	`cudaSharedmemCarveoutMaxShared`	enum cudaSharedCarveout
`static int`	`cudaStreamCaptureModeGlobal`	enum cudaStreamCaptureMode
`static int`	`cudaStreamCaptureModeRelaxed`	enum cudaStreamCaptureMode
`static int`	`cudaStreamCaptureModeThreadLocal`	enum cudaStreamCaptureMode
`static int`	`cudaStreamCaptureStatusActive`	enum cudaStreamCaptureStatus
`static int`	`cudaStreamCaptureStatusInvalidated`	enum cudaStreamCaptureStatus
`static int`	`cudaStreamCaptureStatusNone`	enum cudaStreamCaptureStatus
`static int`	`cudaStreamDefault`	Default stream flag
`static CUstream_st`	`cudaStreamLegacy`
`static int`	`cudaStreamNonBlocking`	Stream does not synchronize with stream 0 (the NULL stream)
`static CUstream_st`	`cudaStreamPerThread`
`static int`	`cudaSuccess`	enum cudaError
`static int`	`cudaSurfaceType1D`	* * *
`static int`	`cudaSurfaceType1DLayered`
`static int`	`cudaSurfaceType2D`
`static int`	`cudaSurfaceType2DLayered`
`static int`	`cudaSurfaceType3D`
`static int`	`cudaSurfaceTypeCubemap`
`static int`	`cudaSurfaceTypeCubemapLayered`
`static int`	`cudaTextureType1D`	* * *
`static int`	`cudaTextureType1DLayered`
`static int`	`cudaTextureType2D`
`static int`	`cudaTextureType2DLayered`
`static int`	`cudaTextureType3D`
`static int`	`cudaTextureTypeCubemap`
`static int`	`cudaTextureTypeCubemapLayered`
`static int`	`MAJOR_VERSION`	enum libraryPropertyType
`static int`	`MINOR_VERSION`	enum libraryPropertyType
`static int`	`PATCH_LEVEL`	enum libraryPropertyType

Constructor Summary

Constructors
Constructor Description

cudart()

Method Summary

All Methods Static Methods Concrete Methods Deprecated Methods
Modifier and Type	Method	Description
`static __half`	`__float2half(float a)`	\ingroup CUDA_MATH__HALF_MISC \brief Converts float number to half precision in round-to-nearest-even mode and returns \p half with converted value.
`static __half`	`__float2half_rd(float a)`	\ingroup CUDA_MATH__HALF_MISC \brief Converts float number to half precision in round-down mode and returns \p half with converted value.
`static __half`	`__float2half_rn(float a)`	\ingroup CUDA_MATH__HALF_MISC \brief Converts float number to half precision in round-to-nearest-even mode and returns \p half with converted value.
`static __half`	`__float2half_ru(float a)`	\ingroup CUDA_MATH__HALF_MISC \brief Converts float number to half precision in round-up mode and returns \p half with converted value.
`static __half`	`__float2half_rz(float a)`	\ingroup CUDA_MATH__HALF_MISC \brief Converts float number to half precision in round-towards-zero mode and returns \p half with converted value.
`static __half2`	`__float2half2_rn(float a)`	\ingroup CUDA_MATH__HALF_MISC \brief Converts input to half precision in round-to-nearest-even mode and populates both halves of \p half2 with converted value.
`static __half2`	`__floats2half2_rn(float a, float b)`	\ingroup CUDA_MATH__HALF_MISC \brief Converts both input floats to half precision in round-to-nearest-even mode and returns \p half2 with converted values.
`static float`	`__half2float(__half a)`	\ingroup CUDA_MATH__HALF_MISC \brief Converts \p half number to float.
`static float`	`__high2float(__half2 a)`	\ingroup CUDA_MATH__HALF_MISC \brief Converts high 16 bits of \p half2 to float and returns the result \details Converts high 16 bits of \p half2 input \p a to 32 bit floating point number and returns the result.
`static short`	`__internal_float2half(float f, int[] sign, int[] remainder)`
`static short`	`__internal_float2half(float f, IntBuffer sign, IntBuffer remainder)`
`static short`	`__internal_float2half(float f, IntPointer sign, IntPointer remainder)`
`static float`	`__internal_half2float(short h)`
`static float`	`__low2float(__half2 a)`	\ingroup CUDA_MATH__HALF_MISC \brief Converts low 16 bits of \p half2 to float and returns the result \details Converts low 16 bits of \p half2 input \p a to 32 bit floating point number and returns the result.
`static int`	`CU_DEVICE_CPU()`	Device that represents the CPU
`static int`	`CU_DEVICE_INVALID()`	Device that represents an invalid device
`static Pointer`	`CU_LAUNCH_PARAM_BUFFER_POINTER()`	Indicator that the next value in the \p extra parameter to ::cuLaunchKernel will be a pointer to a buffer containing all kernel parameters used for launching kernel \p f.
`static Pointer`	`CU_LAUNCH_PARAM_BUFFER_SIZE()`	Indicator that the next value in the \p extra parameter to ::cuLaunchKernel will be a pointer to a size_t which contains the size of the buffer specified with ::CU_LAUNCH_PARAM_BUFFER_POINTER.
`static Pointer`	`CU_LAUNCH_PARAM_END()`	End of array terminator for the \p extra parameter to ::cuLaunchKernel
`static CUstream_st`	`CU_STREAM_LEGACY()`	Legacy stream handle Stream handle that can be passed as a CUstream to use an implicit stream with legacy synchronization behavior.
`static CUstream_st`	`CU_STREAM_PER_THREAD()`	Per-thread stream handle Stream handle that can be passed as a CUstream to use an implicit stream with per-thread synchronization behavior.
`static int`	`cuArray3DCreate(CUarray_st pHandle, CUDA_ARRAY3D_DESCRIPTOR pAllocateArray)`	\brief Creates a 3D CUDA array Creates a CUDA array according to the ::CUDA_ARRAY3D_DESCRIPTOR structure \p pAllocateArray and returns a handle to the new CUDA array in \p *pHandle.
`static int`	`cuArray3DGetDescriptor(CUDA_ARRAY3D_DESCRIPTOR pArrayDescriptor, CUarray_st hArray)`	\brief Get a 3D CUDA array descriptor Returns in \p *pArrayDescriptor a descriptor containing information on the format and dimensions of the CUDA array \p hArray.
`static int`	`cuArrayCreate(CUarray_st pHandle, CUDA_ARRAY_DESCRIPTOR pAllocateArray)`	\brief Creates a 1D or 2D CUDA array Creates a CUDA array according to the ::CUDA_ARRAY_DESCRIPTOR structure \p pAllocateArray and returns a handle to the new CUDA array in \p *pHandle.
`static int`	`cuArrayDestroy(CUarray_st hArray)`	\brief Destroys a CUDA array Destroys the CUDA array \p hArray.
`static int`	`cuArrayGetDescriptor(CUDA_ARRAY_DESCRIPTOR pArrayDescriptor, CUarray_st hArray)`	\brief Get a 1D or 2D CUDA array descriptor Returns in \p *pArrayDescriptor a descriptor containing information on the format and dimensions of the CUDA array \p hArray.
`static double`	`cuCabs(double2 x)`
`static float`	`cuCabsf(float2 x)`
`static double2`	`cuCadd(double2 x, double2 y)`
`static float2`	`cuCaddf(float2 x, float2 y)`
`static double2`	`cuCdiv(double2 x, double2 y)`
`static float2`	`cuCdivf(float2 x, float2 y)`
`static double2`	`cuCfma(double2 x, double2 y, double2 d)`
`static float2`	`cuCfmaf(float2 x, float2 y, float2 d)`
`static double`	`cuCimag(double2 x)`
`static float`	`cuCimagf(float2 x)`
`static double2`	`cuCmul(double2 x, double2 y)`
`static float2`	`cuCmulf(float2 x, float2 y)`
`static float2`	`cuComplexDoubleToFloat(double2 c)`
`static double2`	`cuComplexFloatToDouble(float2 c)`
`static double2`	`cuConj(double2 x)`
`static float2`	`cuConjf(float2 x)`
`static double`	`cuCreal(double2 x)`
`static float`	`cuCrealf(float2 x)`
`static double2`	`cuCsub(double2 x, double2 y)`
`static float2`	`cuCsubf(float2 x, float2 y)`
`static int`	`cuCtxAttach(CUctx_st pctx, int flags)`	Deprecated. Note that this function is deprecated and should not be used.
`static int`	`cuCtxCreate(CUctx_st pctx, int flags, int dev)`	\brief Create a CUDA context \note In most cases it is recommended to use ::cuDevicePrimaryCtxRetain.
`static int`	`cuCtxDestroy(CUctx_st ctx)`	\brief Destroy a CUDA context Destroys the CUDA context specified by \p ctx.
`static int`	`cuCtxDetach(CUctx_st ctx)`	Deprecated. Note that this function is deprecated and should not be used.
`static int`	`cuCtxDisablePeerAccess(CUctx_st peerContext)`	\brief Disables direct access to memory allocations in a peer context and unregisters any registered allocations.
`static int`	`cuCtxEnablePeerAccess(CUctx_st peerContext, int Flags)`	\brief Enables direct access to memory allocations in a peer context.
`static int`	`cuCtxGetApiVersion(CUctx_st ctx, int[] version)`
`static int`	`cuCtxGetApiVersion(CUctx_st ctx, IntBuffer version)`
`static int`	`cuCtxGetApiVersion(CUctx_st ctx, IntPointer version)`	\brief Gets the context's API version.
`static int`	`cuCtxGetCacheConfig(int[] pconfig)`
`static int`	`cuCtxGetCacheConfig(IntBuffer pconfig)`
`static int`	`cuCtxGetCacheConfig(IntPointer pconfig)`	\brief Returns the preferred cache configuration for the current context.
`static int`	`cuCtxGetCurrent(CUctx_st pctx)`	\brief Returns the CUDA context bound to the calling CPU thread.
`static int`	`cuCtxGetDevice(int[] device)`
`static int`	`cuCtxGetDevice(IntBuffer device)`
`static int`	`cuCtxGetDevice(IntPointer device)`	\brief Returns the device ID for the current context Returns in \p *device the ordinal of the current context's device.
`static int`	`cuCtxGetFlags(int[] flags)`
`static int`	`cuCtxGetFlags(IntBuffer flags)`
`static int`	`cuCtxGetFlags(IntPointer flags)`	\brief Returns the flags for the current context Returns in \p *flags the flags of the current context.
`static int`	`cuCtxGetLimit(SizeTPointer pvalue, int _limit)`	\brief Returns resource limits Returns in \p *pvalue the current size of \p limit.
`static int`	`cuCtxGetSharedMemConfig(int[] pConfig)`
`static int`	`cuCtxGetSharedMemConfig(IntBuffer pConfig)`
`static int`	`cuCtxGetSharedMemConfig(IntPointer pConfig)`	\brief Returns the current shared memory configuration for the current context.
`static int`	`cuCtxGetStreamPriorityRange(int[] leastPriority, int[] greatestPriority)`
`static int`	`cuCtxGetStreamPriorityRange(IntBuffer leastPriority, IntBuffer greatestPriority)`
`static int`	`cuCtxGetStreamPriorityRange(IntPointer leastPriority, IntPointer greatestPriority)`	\brief Returns numerical values that correspond to the least and greatest stream priorities.
`static int`	`cuCtxPopCurrent(CUctx_st pctx)`	\brief Pops the current CUDA context from the current CPU thread.
`static int`	`cuCtxPushCurrent(CUctx_st ctx)`	\brief Pushes a context on the current CPU thread Pushes the given context \p ctx onto the CPU thread's stack of current contexts.
`static int`	`cuCtxSetCacheConfig(int config)`	\brief Sets the preferred cache configuration for the current context.
`static int`	`cuCtxSetCurrent(CUctx_st ctx)`	\brief Binds the specified CUDA context to the calling CPU thread Binds the specified CUDA context to the calling CPU thread.
`static int`	`cuCtxSetLimit(int _limit, long value)`	\brief Set resource limits Setting \p limit to \p value is a request by the application to update the current limit maintained by the context.
`static int`	`cuCtxSetSharedMemConfig(int config)`	\brief Sets the shared memory configuration for the current context.
`static int`	`cuCtxSynchronize()`	\brief Block for a context's tasks to complete Blocks until the device has completed all preceding requested tasks.
`static int`	`cudaArrayGetInfo(cudaChannelFormatDesc desc, cudaExtent extent, int[] flags, cudaArray array)`
`static int`	`cudaArrayGetInfo(cudaChannelFormatDesc desc, cudaExtent extent, IntBuffer flags, cudaArray array)`
`static int`	`cudaArrayGetInfo(cudaChannelFormatDesc desc, cudaExtent extent, IntPointer flags, cudaArray array)`	\brief Gets info about the specified cudaArray Returns in \p desc, \p extent and \p *flags respectively, the type, shape and flags of \p array.
`static int`	`cudaBindSurfaceToArray(surfaceReference surfref, cudaArray array, cudaChannelFormatDesc desc)`	Deprecated. Binds the CUDA array \p array to the surface reference \p surfref.
`static int`	`cudaBindTexture(SizeTPointer offset, textureReference texref, Pointer devPtr, cudaChannelFormatDesc desc)`
`static int`	`cudaBindTexture(SizeTPointer offset, textureReference texref, Pointer devPtr, cudaChannelFormatDesc desc, long size)`	Deprecated. Binds \p size bytes of the memory area pointed to by \p devPtr to the texture reference \p texref.
`static int`	`cudaBindTexture2D(SizeTPointer offset, textureReference texref, Pointer devPtr, cudaChannelFormatDesc desc, long width, long height, long pitch)`	Deprecated. Binds the 2D memory area pointed to by \p devPtr to the texture reference \p texref.
`static int`	`cudaBindTextureToArray(textureReference texref, cudaArray array, cudaChannelFormatDesc desc)`	Deprecated. Binds the CUDA array \p array to the texture reference \p texref.
`static int`	`cudaBindTextureToMipmappedArray(textureReference texref, cudaMipmappedArray mipmappedArray, cudaChannelFormatDesc desc)`	Deprecated. Binds the CUDA mipmapped array \p mipmappedArray to the texture reference \p texref.
`static int`	`cudaChooseDevice(int[] device, cudaDeviceProp prop)`
`static int`	`cudaChooseDevice(IntBuffer device, cudaDeviceProp prop)`
`static int`	`cudaChooseDevice(IntPointer device, cudaDeviceProp prop)`	\brief Select compute-device which best matches criteria Returns in \p device the device which has properties that best match \p prop.
`static cudaChannelFormatDesc`	`cudaCreateChannelDesc(int x, int y, int z, int w, int f)`	\brief Returns a channel descriptor using the specified format Returns a channel descriptor with format \p f and number of bits of each component \p x, \p y, \p z, and \p w.
`static int`	`cudaCreateSurfaceObject(long[] pSurfObject, cudaResourceDesc pResDesc)`
`static int`	`cudaCreateSurfaceObject(LongBuffer pSurfObject, cudaResourceDesc pResDesc)`
`static int`	`cudaCreateSurfaceObject(LongPointer pSurfObject, cudaResourceDesc pResDesc)`	\brief Creates a surface object Creates a surface object and returns it in \p pSurfObject.
`static int`	`cudaCreateTextureObject(long[] pTexObject, cudaResourceDesc pResDesc, cudaTextureDesc pTexDesc, cudaResourceViewDesc pResViewDesc)`
`static int`	`cudaCreateTextureObject(LongBuffer pTexObject, cudaResourceDesc pResDesc, cudaTextureDesc pTexDesc, cudaResourceViewDesc pResViewDesc)`
`static int`	`cudaCreateTextureObject(LongPointer pTexObject, cudaResourceDesc pResDesc, cudaTextureDesc pTexDesc, cudaResourceViewDesc pResViewDesc)`	\brief Creates a texture object Creates a texture object and returns it in \p pTexObject.
`static int`	`cudaDestroyExternalMemory(CUexternalMemory_st extMem)`	\brief Destroys an external memory object.
`static int`	`cudaDestroyExternalSemaphore(CUexternalSemaphore_st extSem)`	\brief Destroys an external semaphore Destroys an external semaphore object and releases any references to the underlying resource.
`static int`	`cudaDestroySurfaceObject(long surfObject)`	\brief Destroys a surface object Destroys the surface object specified by \p surfObject.
`static int`	`cudaDestroyTextureObject(long texObject)`	\brief Destroys a texture object Destroys the texture object specified by \p texObject.
`static int`	`cudaDeviceCanAccessPeer(int[] canAccessPeer, int device, int peerDevice)`
`static int`	`cudaDeviceCanAccessPeer(IntBuffer canAccessPeer, int device, int peerDevice)`
`static int`	`cudaDeviceCanAccessPeer(IntPointer canAccessPeer, int device, int peerDevice)`	\brief Queries if a device may directly access a peer device's memory.
`static int`	`cudaDeviceDisablePeerAccess(int peerDevice)`	\brief Disables direct access to memory allocations on a peer device.
`static int`	`cudaDeviceEnablePeerAccess(int peerDevice, int flags)`	\brief Enables direct access to memory allocations on a peer device.
`static int`	`cudaDeviceGetAttribute(int[] value, int attr, int device)`
`static int`	`cudaDeviceGetAttribute(IntBuffer value, int attr, int device)`
`static int`	`cudaDeviceGetAttribute(IntPointer value, int attr, int device)`	\brief Returns information about the device Returns in \p *value the integer value of the attribute \p attr on device \p device.
`static int`	`cudaDeviceGetByPCIBusId(int[] device, String pciBusId)`
`static int`	`cudaDeviceGetByPCIBusId(int[] device, BytePointer pciBusId)`
`static int`	`cudaDeviceGetByPCIBusId(IntBuffer device, String pciBusId)`
`static int`	`cudaDeviceGetByPCIBusId(IntBuffer device, BytePointer pciBusId)`
`static int`	`cudaDeviceGetByPCIBusId(IntPointer device, String pciBusId)`
`static int`	`cudaDeviceGetByPCIBusId(IntPointer device, BytePointer pciBusId)`	\brief Returns a handle to a compute device Returns in \p *device a device ordinal given a PCI bus ID string.
`static int`	`cudaDeviceGetCacheConfig(int[] pCacheConfig)`
`static int`	`cudaDeviceGetCacheConfig(IntBuffer pCacheConfig)`
`static int`	`cudaDeviceGetCacheConfig(IntPointer pCacheConfig)`	\brief Returns the preferred cache configuration for the current device.
`static int`	`cudaDeviceGetLimit(SizeTPointer pValue, int _limit)`	\brief Returns resource limits Returns in \p *pValue the current size of \p limit.
`static int`	`cudaDeviceGetP2PAttribute(int[] value, int attr, int srcDevice, int dstDevice)`
`static int`	`cudaDeviceGetP2PAttribute(IntBuffer value, int attr, int srcDevice, int dstDevice)`
`static int`	`cudaDeviceGetP2PAttribute(IntPointer value, int attr, int srcDevice, int dstDevice)`	\brief Queries attributes of the link between two devices.
`static int`	`cudaDeviceGetPCIBusId(byte[] pciBusId, int len, int device)`
`static int`	`cudaDeviceGetPCIBusId(ByteBuffer pciBusId, int len, int device)`
`static int`	`cudaDeviceGetPCIBusId(BytePointer pciBusId, int len, int device)`	\brief Returns a PCI Bus Id string for the device Returns an ASCII string identifying the device \p dev in the NULL-terminated string pointed to by \p pciBusId.
`static int`	`cudaDeviceGetSharedMemConfig(int[] pConfig)`
`static int`	`cudaDeviceGetSharedMemConfig(IntBuffer pConfig)`
`static int`	`cudaDeviceGetSharedMemConfig(IntPointer pConfig)`	\brief Returns the shared memory configuration for the current device.
`static int`	`cudaDeviceGetStreamPriorityRange(int[] leastPriority, int[] greatestPriority)`
`static int`	`cudaDeviceGetStreamPriorityRange(IntBuffer leastPriority, IntBuffer greatestPriority)`
`static int`	`cudaDeviceGetStreamPriorityRange(IntPointer leastPriority, IntPointer greatestPriority)`	\brief Returns numerical values that correspond to the least and greatest stream priorities.
`static int`	`cudaDeviceReset()`	\brief Destroy all allocations and reset all state on the current device in the current process.
`static int`	`cudaDeviceSetCacheConfig(int cacheConfig)`	\brief Sets the preferred cache configuration for the current device.
`static int`	`cudaDeviceSetLimit(int _limit, long value)`	\brief Set resource limits Setting \p limit to \p value is a request by the application to update the current limit maintained by the device.
`static int`	`cudaDeviceSetSharedMemConfig(int config)`	\brief Sets the shared memory configuration for the current device.
`static int`	`cudaDeviceSynchronize()`	\brief Wait for compute device to finish Blocks until the device has completed all preceding requested tasks.
`static int`	`cudaDriverGetVersion(int[] driverVersion)`
`static int`	`cudaDriverGetVersion(IntBuffer driverVersion)`
`static int`	`cudaDriverGetVersion(IntPointer driverVersion)`	\brief Returns the latest version of CUDA supported by the driver Returns in \p *driverVersion the latest version of CUDA supported by the driver.
`static int`	`cudaEventCreate(CUevent_st event)`	\brief Creates an event object Creates an event object for the current device using ::cudaEventDefault.
`static int`	`cudaEventCreateWithFlags(CUevent_st event, int flags)`	\brief Creates an event object with the specified flags Creates an event object for the current device with the specified flags.
`static int`	`cudaEventDestroy(CUevent_st event)`	\brief Destroys an event object Destroys the event specified by \p event.
`static int`	`cudaEventElapsedTime(float[] ms, CUevent_st start, CUevent_st end)`
`static int`	`cudaEventElapsedTime(FloatBuffer ms, CUevent_st start, CUevent_st end)`
`static int`	`cudaEventElapsedTime(FloatPointer ms, CUevent_st start, CUevent_st end)`	\brief Computes the elapsed time between events Computes the elapsed time between two events (in milliseconds with a resolution of around 0.5 microseconds).
`static int`	`cudaEventQuery(CUevent_st event)`	\brief Queries an event's status Queries the status of all work currently captured by \p event.
`static int`	`cudaEventRecord(CUevent_st event)`
`static int`	`cudaEventRecord(CUevent_st event, CUstream_st stream)`	\brief Records an event Captures in \p event the contents of \p stream at the time of this call.
`static int`	`cudaEventSynchronize(CUevent_st event)`	\brief Waits for an event to complete Waits until the completion of all work currently captured in \p event.
`static int`	`cudaExternalMemoryGetMappedBuffer(PointerPointer devPtr, CUexternalMemory_st extMem, cudaExternalMemoryBufferDesc bufferDesc)`	\brief Maps a buffer onto an imported memory object Maps a buffer onto an imported memory object and returns a device pointer in \p devPtr.
`static int`	`cudaExternalMemoryGetMappedBuffer(Pointer devPtr, CUexternalMemory_st extMem, cudaExternalMemoryBufferDesc bufferDesc)`
`static int`	`cudaExternalMemoryGetMappedMipmappedArray(cudaMipmappedArray mipmap, CUexternalMemory_st extMem, cudaExternalMemoryMipmappedArrayDesc mipmapDesc)`	\brief Maps a CUDA mipmapped array onto an external memory object Maps a CUDA mipmapped array onto an external object and returns a handle to it in \p mipmap.
`static int`	`cudaFree(Pointer devPtr)`	\brief Frees memory on the device Frees the memory space pointed to by \p devPtr, which must have been returned by a previous call to ::cudaMalloc() or ::cudaMallocPitch().
`static int`	`cudaFreeArray(cudaArray array)`	\brief Frees an array on the device Frees the CUDA array \p array, which must have been returned by a previous call to ::cudaMallocArray().
`static int`	`cudaFreeHost(Pointer ptr)`	\brief Frees page-locked memory Frees the memory space pointed to by \p hostPtr, which must have been returned by a previous call to ::cudaMallocHost() or ::cudaHostAlloc().
`static int`	`cudaFreeMipmappedArray(cudaMipmappedArray mipmappedArray)`	\brief Frees a mipmapped array on the device Frees the CUDA mipmapped array \p mipmappedArray, which must have been returned by a previous call to ::cudaMallocMipmappedArray().
`static int`	`cudaFuncGetAttributes(cudaFuncAttributes attr, Pointer func)`	\brief Find out attributes for a given function This function obtains the attributes of a function specified via \p func.
`static int`	`cudaFuncSetAttribute(Pointer func, int attr, int value)`	\brief Set attributes for a given function This function sets the attributes of a function specified via \p func.
`static int`	`cudaFuncSetCacheConfig(Pointer func, int cacheConfig)`	\brief Sets the preferred cache configuration for a device function On devices where the L1 cache and shared memory use the same hardware resources, this sets through \p cacheConfig the preferred cache configuration for the function specified via \p func.
`static int`	`cudaFuncSetSharedMemConfig(Pointer func, int config)`	\brief Sets the shared memory configuration for a device function On devices with configurable shared memory banks, this function will force all subsequent launches of the specified device function to have the given shared memory bank size configuration.
`static int`	`cudaGetChannelDesc(cudaChannelFormatDesc desc, cudaArray array)`	\brief Get the channel descriptor of an array Returns in \p *desc the channel descriptor of the CUDA array \p array.
`static int`	`cudaGetDevice(int[] device)`
`static int`	`cudaGetDevice(IntBuffer device)`
`static int`	`cudaGetDevice(IntPointer device)`	\brief Returns which device is currently being used Returns in \p *device the current device for the calling host thread.
`static int`	`cudaGetDeviceCount(int[] count)`
`static int`	`cudaGetDeviceCount(IntBuffer count)`
`static int`	`cudaGetDeviceCount(IntPointer count)`	\brief Returns the number of compute-capable devices Returns in \p *count the number of devices with compute capability greater or equal to 2.0 that are available for execution.
`static int`	`cudaGetDeviceFlags(int[] flags)`
`static int`	`cudaGetDeviceFlags(IntBuffer flags)`
`static int`	`cudaGetDeviceFlags(IntPointer flags)`	\brief Gets the flags for the current device Returns in \p flags the flags for the current device.
`static int`	`cudaGetDeviceProperties(cudaDeviceProp prop, int device)`	\brief Returns information about the compute-device Returns in \p *prop the properties of device \p dev.
`static BytePointer`	`cudaGetErrorName(int error)`	\brief Returns the string representation of an error code enum name Returns a string containing the name of an error code in the enum.
`static BytePointer`	`cudaGetErrorString(int error)`	\brief Returns the description string for an error code Returns the description string for an error code.
`static int`	`cudaGetExportTable(PointerPointer ppExportTable, cudaUUID_t pExportTableId)`	\cond impl_private
`static int`	`cudaGetExportTable(Pointer ppExportTable, cudaUUID_t pExportTableId)`
`static int`	`cudaGetLastError()`	\brief Returns the last error from a runtime call Returns the last error that has been produced by any of the runtime calls in the same host thread and resets it to ::cudaSuccess.
`static int`	`cudaGetMipmappedArrayLevel(cudaArray levelArray, cudaMipmappedArray mipmappedArray, int level)`	\brief Gets a mipmap level of a CUDA mipmapped array Returns in \p *levelArray a CUDA array that represents a single mipmap level of the CUDA mipmapped array \p mipmappedArray.
`static int`	`cudaGetSurfaceObjectResourceDesc(cudaResourceDesc pResDesc, long surfObject)`	\brief Returns a surface object's resource descriptor Returns the resource descriptor for the surface object specified by \p surfObject.
`static int`	`cudaGetSurfaceReference(surfaceReference surfref, Pointer symbol)`
`static int`	`cudaGetSurfaceReference(PointerPointer surfref, Pointer symbol)`	Deprecated. Returns in \p *surfref the structure associated to the surface reference defined by symbol \p symbol.
`static int`	`cudaGetSymbolAddress(PointerPointer devPtr, Pointer symbol)`	\brief Finds the address associated with a CUDA symbol Returns in \p *devPtr the address of symbol \p symbol on the device.
`static int`	`cudaGetSymbolAddress(Pointer devPtr, Pointer symbol)`
`static int`	`cudaGetSymbolSize(SizeTPointer size, Pointer symbol)`	\brief Finds the size of the object associated with a CUDA symbol Returns in \p *size the size of symbol \p symbol.
`static int`	`cudaGetTextureAlignmentOffset(SizeTPointer offset, textureReference texref)`	Deprecated. Returns in \p *offset the offset that was returned when texture reference \p texref was bound.
`static int`	`cudaGetTextureObjectResourceDesc(cudaResourceDesc pResDesc, long texObject)`	\brief Returns a texture object's resource descriptor Returns the resource descriptor for the texture object specified by \p texObject.
`static int`	`cudaGetTextureObjectResourceViewDesc(cudaResourceViewDesc pResViewDesc, long texObject)`	\brief Returns a texture object's resource view descriptor Returns the resource view descriptor for the texture object specified by \p texObject.
`static int`	`cudaGetTextureObjectTextureDesc(cudaTextureDesc pTexDesc, long texObject)`	\brief Returns a texture object's texture descriptor Returns the texture descriptor for the texture object specified by \p texObject.
`static int`	`cudaGetTextureReference(textureReference texref, Pointer symbol)`
`static int`	`cudaGetTextureReference(PointerPointer texref, Pointer symbol)`	Deprecated. Returns in \p *texref the structure associated to the texture reference defined by symbol \p symbol.
`static int`	`cudaGraphAddChildGraphNode(CUgraphNode_st pGraphNode, CUgraph_st graph, CUgraphNode_st pDependencies, long numDependencies, CUgraph_st childGraph)`	\brief Creates a child graph node and adds it to a graph Creates a new node which executes an embedded graph, and adds it to \p graph with \p numDependencies dependencies specified via \p pDependencies.
`static int`	`cudaGraphAddDependencies(CUgraph_st graph, CUgraphNode_st from, CUgraphNode_st to, long numDependencies)`	\brief Adds dependency edges to a graph.
`static int`	`cudaGraphAddEmptyNode(CUgraphNode_st pGraphNode, CUgraph_st graph, CUgraphNode_st pDependencies, long numDependencies)`	\brief Creates an empty node and adds it to a graph Creates a new node which performs no operation, and adds it to \p graph with \p numDependencies dependencies specified via \p pDependencies.
`static int`	`cudaGraphAddHostNode(CUgraphNode_st pGraphNode, CUgraph_st graph, CUgraphNode_st pDependencies, long numDependencies, cudaHostNodeParams pNodeParams)`	\brief Creates a host execution node and adds it to a graph Creates a new CPU execution node and adds it to \p graph with \p numDependencies dependencies specified via \p pDependencies and arguments specified in \p pNodeParams.
`static int`	`cudaGraphAddKernelNode(CUgraphNode_st pGraphNode, CUgraph_st graph, CUgraphNode_st pDependencies, long numDependencies, cudaKernelNodeParams pNodeParams)`	\brief Creates a kernel execution node and adds it to a graph Creates a new kernel execution node and adds it to \p graph with \p numDependencies dependencies specified via \p pDependencies and arguments specified in \p pNodeParams.
`static int`	`cudaGraphAddMemcpyNode(CUgraphNode_st pGraphNode, CUgraph_st graph, CUgraphNode_st pDependencies, long numDependencies, cudaMemcpy3DParms pCopyParams)`	\brief Creates a memcpy node and adds it to a graph Creates a new memcpy node and adds it to \p graph with \p numDependencies dependencies specified via \p pDependencies.
`static int`	`cudaGraphAddMemsetNode(CUgraphNode_st pGraphNode, CUgraph_st graph, CUgraphNode_st pDependencies, long numDependencies, cudaMemsetParams pMemsetParams)`	\brief Creates a memset node and adds it to a graph Creates a new memset node and adds it to \p graph with \p numDependencies dependencies specified via \p pDependencies.
`static int`	`cudaGraphChildGraphNodeGetGraph(CUgraphNode_st node, CUgraph_st pGraph)`	\brief Gets a handle to the embedded graph of a child graph node Gets a handle to the embedded graph in a child graph node.
`static int`	`cudaGraphClone(CUgraph_st pGraphClone, CUgraph_st originalGraph)`	\brief Clones a graph This function creates a copy of \p originalGraph and returns it in \p pGraphClone.
`static int`	`cudaGraphCreate(CUgraph_st pGraph, int flags)`	\brief Creates a graph Creates an empty graph, which is returned via \p pGraph.
`static int`	`cudaGraphDestroy(CUgraph_st graph)`	\brief Destroys a graph Destroys the graph specified by \p graph, as well as all of its nodes.
`static int`	`cudaGraphDestroyNode(CUgraphNode_st node)`	\brief Remove a node from the graph Removes \p node from its graph.
`static int`	`cudaGraphExecDestroy(CUgraphExec_st graphExec)`	\brief Destroys an executable graph Destroys the executable graph specified by \p graphExec.
`static int`	`cudaGraphExecHostNodeSetParams(CUgraphExec_st hGraphExec, CUgraphNode_st node, cudaHostNodeParams pNodeParams)`	\brief Sets the parameters for a host node in the given graphExec.
`static int`	`cudaGraphExecKernelNodeSetParams(CUgraphExec_st hGraphExec, CUgraphNode_st node, cudaKernelNodeParams pNodeParams)`	\brief Sets the parameters for a kernel node in the given graphExec Sets the parameters of a kernel node in an executable graph \p hGraphExec.
`static int`	`cudaGraphExecMemcpyNodeSetParams(CUgraphExec_st hGraphExec, CUgraphNode_st node, cudaMemcpy3DParms pNodeParams)`	\brief Sets the parameters for a memcpy node in the given graphExec.
`static int`	`cudaGraphExecMemsetNodeSetParams(CUgraphExec_st hGraphExec, CUgraphNode_st node, cudaMemsetParams pNodeParams)`	\brief Sets the parameters for a memset node in the given graphExec.
`static int`	`cudaGraphExecUpdate(CUgraphExec_st hGraphExec, CUgraph_st hGraph, CUgraphNode_st hErrorNode_out, int[] updateResult_out)`
`static int`	`cudaGraphExecUpdate(CUgraphExec_st hGraphExec, CUgraph_st hGraph, CUgraphNode_st hErrorNode_out, IntBuffer updateResult_out)`
`static int`	`cudaGraphExecUpdate(CUgraphExec_st hGraphExec, CUgraph_st hGraph, CUgraphNode_st hErrorNode_out, IntPointer updateResult_out)`	\brief Check whether an executable graph can be updated with a graph and perform the update if possible Updates the node parameters in the instantiated graph specified by \p hGraphExec with the node parameters in a topologically identical graph specified by \p hGraph.
`static int`	`cudaGraphGetEdges(CUgraph_st graph, CUgraphNode_st from, CUgraphNode_st to, SizeTPointer numEdges)`	\brief Returns a graph's dependency edges Returns a list of \p graph's dependency edges.
`static int`	`cudaGraphGetNodes(CUgraph_st graph, CUgraphNode_st nodes, SizeTPointer numNodes)`	\brief Returns a graph's nodes Returns a list of \p graph's nodes.
`static int`	`cudaGraphGetRootNodes(CUgraph_st graph, CUgraphNode_st pRootNodes, SizeTPointer pNumRootNodes)`	\brief Returns a graph's root nodes Returns a list of \p graph's root nodes.
`static int`	`cudaGraphHostNodeGetParams(CUgraphNode_st node, cudaHostNodeParams pNodeParams)`	\brief Returns a host node's parameters Returns the parameters of host node \p node in \p pNodeParams.
`static int`	`cudaGraphHostNodeSetParams(CUgraphNode_st node, cudaHostNodeParams pNodeParams)`	\brief Sets a host node's parameters Sets the parameters of host node \p node to \p nodeParams.
`static int`	`cudaGraphicsMapResources(int count, cudaGraphicsResource resources)`
`static int`	`cudaGraphicsMapResources(int count, cudaGraphicsResource resources, CUstream_st stream)`	\brief Map graphics resources for access by CUDA Maps the \p count graphics resources in \p resources for access by CUDA.
`static int`	`cudaGraphicsResourceGetMappedMipmappedArray(cudaMipmappedArray mipmappedArray, cudaGraphicsResource resource)`	\brief Get a mipmapped array through which to access a mapped graphics resource.
`static int`	`cudaGraphicsResourceGetMappedPointer(PointerPointer devPtr, SizeTPointer size, cudaGraphicsResource resource)`	\brief Get an device pointer through which to access a mapped graphics resource.
`static int`	`cudaGraphicsResourceGetMappedPointer(Pointer devPtr, SizeTPointer size, cudaGraphicsResource resource)`
`static int`	`cudaGraphicsResourceSetMapFlags(cudaGraphicsResource resource, int flags)`	\brief Set usage flags for mapping a graphics resource Set \p flags for mapping the graphics resource \p resource.
`static int`	`cudaGraphicsSubResourceGetMappedArray(cudaArray array, cudaGraphicsResource resource, int arrayIndex, int mipLevel)`	\brief Get an array through which to access a subresource of a mapped graphics resource.
`static int`	`cudaGraphicsUnmapResources(int count, cudaGraphicsResource resources)`
`static int`	`cudaGraphicsUnmapResources(int count, cudaGraphicsResource resources, CUstream_st stream)`	\brief Unmap graphics resources.
`static int`	`cudaGraphicsUnregisterResource(cudaGraphicsResource resource)`	\brief Unregisters a graphics resource for access by CUDA Unregisters the graphics resource \p resource so it is not accessible by CUDA unless registered again.
`static int`	`cudaGraphInstantiate(CUgraphExec_st pGraphExec, CUgraph_st graph, CUgraphNode_st pErrorNode, byte[] pLogBuffer, long bufferSize)`
`static int`	`cudaGraphInstantiate(CUgraphExec_st pGraphExec, CUgraph_st graph, CUgraphNode_st pErrorNode, ByteBuffer pLogBuffer, long bufferSize)`
`static int`	`cudaGraphInstantiate(CUgraphExec_st pGraphExec, CUgraph_st graph, CUgraphNode_st pErrorNode, BytePointer pLogBuffer, long bufferSize)`	\brief Creates an executable graph from a graph Instantiates \p graph as an executable graph.
`static int`	`cudaGraphKernelNodeGetParams(CUgraphNode_st node, cudaKernelNodeParams pNodeParams)`	\brief Returns a kernel node's parameters Returns the parameters of kernel node \p node in \p pNodeParams.
`static int`	`cudaGraphKernelNodeSetParams(CUgraphNode_st node, cudaKernelNodeParams pNodeParams)`	\brief Sets a kernel node's parameters Sets the parameters of kernel node \p node to \p pNodeParams.
`static int`	`cudaGraphLaunch(CUgraphExec_st graphExec, CUstream_st stream)`	\brief Launches an executable graph in a stream Executes \p graphExec in \p stream.
`static int`	`cudaGraphMemcpyNodeGetParams(CUgraphNode_st node, cudaMemcpy3DParms pNodeParams)`	\brief Returns a memcpy node's parameters Returns the parameters of memcpy node \p node in \p pNodeParams.
`static int`	`cudaGraphMemcpyNodeSetParams(CUgraphNode_st node, cudaMemcpy3DParms pNodeParams)`	\brief Sets a memcpy node's parameters Sets the parameters of memcpy node \p node to \p pNodeParams.
`static int`	`cudaGraphMemsetNodeGetParams(CUgraphNode_st node, cudaMemsetParams pNodeParams)`	\brief Returns a memset node's parameters Returns the parameters of memset node \p node in \p pNodeParams.
`static int`	`cudaGraphMemsetNodeSetParams(CUgraphNode_st node, cudaMemsetParams pNodeParams)`	\brief Sets a memset node's parameters Sets the parameters of memset node \p node to \p pNodeParams.
`static int`	`cudaGraphNodeFindInClone(CUgraphNode_st pNode, CUgraphNode_st originalNode, CUgraph_st clonedGraph)`	\brief Finds a cloned version of a node This function returns the node in \p clonedGraph corresponding to \p originalNode in the original graph.
`static int`	`cudaGraphNodeGetDependencies(CUgraphNode_st node, CUgraphNode_st pDependencies, SizeTPointer pNumDependencies)`	\brief Returns a node's dependencies Returns a list of \p node's dependencies.
`static int`	`cudaGraphNodeGetDependentNodes(CUgraphNode_st node, CUgraphNode_st pDependentNodes, SizeTPointer pNumDependentNodes)`	\brief Returns a node's dependent nodes Returns a list of \p node's dependent nodes.
`static int`	`cudaGraphNodeGetType(CUgraphNode_st node, int[] pType)`
`static int`	`cudaGraphNodeGetType(CUgraphNode_st node, IntBuffer pType)`
`static int`	`cudaGraphNodeGetType(CUgraphNode_st node, IntPointer pType)`	\brief Returns a node's type Returns the node type of \p node in \p pType.
`static int`	`cudaGraphRemoveDependencies(CUgraph_st graph, CUgraphNode_st from, CUgraphNode_st to, long numDependencies)`	\brief Removes dependency edges from a graph.
`static int`	`cudaHostAlloc(Pointer pHost, long size, int flags)`
`static int`	`cudaHostAlloc(PointerPointer pHost, long size, int flags)`	\brief Allocates page-locked memory on the host Allocates \p size bytes of host memory that is page-locked and accessible to the device.
`static int`	`cudaHostGetDevicePointer(PointerPointer pDevice, Pointer pHost, int flags)`	\brief Passes back device pointer of mapped host memory allocated by cudaHostAlloc or registered by cudaHostRegister Passes back the device pointer corresponding to the mapped, pinned host buffer allocated by ::cudaHostAlloc() or registered by ::cudaHostRegister().
`static int`	`cudaHostGetDevicePointer(Pointer pDevice, Pointer pHost, int flags)`
`static int`	`cudaHostGetFlags(int[] pFlags, Pointer pHost)`
`static int`	`cudaHostGetFlags(IntBuffer pFlags, Pointer pHost)`
`static int`	`cudaHostGetFlags(IntPointer pFlags, Pointer pHost)`	\brief Passes back flags used to allocate pinned host memory allocated by cudaHostAlloc ::cudaHostGetFlags() will fail if the input pointer does not reside in an address range allocated by ::cudaHostAlloc().
`static int`	`cudaHostRegister(Pointer ptr, long size, int flags)`	\brief Registers an existing host memory range for use by CUDA Page-locks the memory range specified by \p ptr and \p size and maps it for the device(s) as specified by \p flags.
`static int`	`cudaHostUnregister(Pointer ptr)`	\brief Unregisters a memory range that was registered with cudaHostRegister Unmaps the memory range whose base address is specified by \p ptr, and makes it pageable again.
`static int`	`cudaImportExternalMemory(CUexternalMemory_st extMem_out, cudaExternalMemoryHandleDesc memHandleDesc)`	\brief Imports an external memory object Imports an externally allocated memory object and returns a handle to that in \p extMem_out.
`static int`	`cudaImportExternalSemaphore(CUexternalSemaphore_st extSem_out, cudaExternalSemaphoreHandleDesc semHandleDesc)`	\brief Imports an external semaphore Imports an externally allocated synchronization object and returns a handle to that in \p extSem_out.
`static int`	`cudaIpcCloseMemHandle(Pointer devPtr)`	\brief Close memory mapped with cudaIpcOpenMemHandle Unmaps memory returnd by ::cudaIpcOpenMemHandle.
`static int`	`cudaIpcGetEventHandle(cudaIpcEventHandle_t handle, CUevent_st event)`	\brief Gets an interprocess handle for a previously allocated event Takes as input a previously allocated event.
`static int`	`cudaIpcGetMemHandle(cudaIpcMemHandle_t handle, Pointer devPtr)`	\brief Gets an interprocess memory handle for an existing device memory allocation Takes a pointer to the base of an existing device memory allocation created with ::cudaMalloc and exports it for use in another process.
`static int`	`cudaIpcOpenEventHandle(CUevent_st event, cudaIpcEventHandle_t handle)`	\brief Opens an interprocess event handle for use in the current process Opens an interprocess event handle exported from another process with ::cudaIpcGetEventHandle.
`static int`	`cudaIpcOpenMemHandle(PointerPointer devPtr, cudaIpcMemHandle_t handle, int flags)`	\brief Opens an interprocess memory handle exported from another process and returns a device pointer usable in the local process.
`static int`	`cudaIpcOpenMemHandle(Pointer devPtr, cudaIpcMemHandle_t handle, int flags)`
`static int`	`cudaLaunchCooperativeKernel(Pointer func, dim3 gridDim, dim3 blockDim, Pointer args, long sharedMem, CUstream_st stream)`
`static int`	`cudaLaunchCooperativeKernel(Pointer func, dim3 gridDim, dim3 blockDim, PointerPointer args, long sharedMem, CUstream_st stream)`	\brief Launches a device function where thread blocks can cooperate and synchronize as they execute The function invokes kernel \p func on \p gridDim (\p gridDim.x × \p gridDim.y × \p gridDim.z) grid of blocks.
`static int`	`cudaLaunchCooperativeKernelMultiDevice(cudaLaunchParams launchParamsList, int numDevices)`
`static int`	`cudaLaunchCooperativeKernelMultiDevice(cudaLaunchParams launchParamsList, int numDevices, int flags)`	\brief Launches device functions on multiple devices where thread blocks can cooperate and synchronize as they execute Invokes kernels as specified in the \p launchParamsList array where each element of the array specifies all the parameters required to perform a single kernel launch.
`static int`	`cudaLaunchHostFunc(CUstream_st stream, cudaHostFn_t fn, Pointer userData)`	\brief Enqueues a host function call in a stream Enqueues a host function to run in a stream.
`static int`	`cudaLaunchKernel(Pointer func, dim3 gridDim, dim3 blockDim, Pointer args, long sharedMem, CUstream_st stream)`
`static int`	`cudaLaunchKernel(Pointer func, dim3 gridDim, dim3 blockDim, PointerPointer args, long sharedMem, CUstream_st stream)`	\brief Launches a device function The function invokes kernel \p func on \p gridDim (\p gridDim.x × \p gridDim.y × \p gridDim.z) grid of blocks.
`static int`	`cudaMalloc(Pointer devPtr, long size)`
`static int`	`cudaMalloc(PointerPointer devPtr, long size)`	\brief Allocate memory on the device Allocates \p size bytes of linear memory on the device and returns in \p *devPtr a pointer to the allocated memory.
`static int`	`cudaMalloc3D(cudaPitchedPtr pitchedDevPtr, cudaExtent extent)`	\brief Allocates logical 1D, 2D, or 3D memory objects on the device Allocates at least \p width * \p height * \p depth bytes of linear memory on the device and returns a ::cudaPitchedPtr in which \p ptr is a pointer to the allocated memory.
`static int`	`cudaMalloc3DArray(cudaArray array, cudaChannelFormatDesc desc, cudaExtent extent)`
`static int`	`cudaMalloc3DArray(cudaArray array, cudaChannelFormatDesc desc, cudaExtent extent, int flags)`	\brief Allocate an array on the device Allocates a CUDA array according to the ::cudaChannelFormatDesc structure \p desc and returns a handle to the new CUDA array in \p *array.
`static int`	`cudaMallocArray(cudaArray array, cudaChannelFormatDesc desc, long width)`
`static int`	`cudaMallocArray(cudaArray array, cudaChannelFormatDesc desc, long width, long height, int flags)`	\brief Allocate an array on the device Allocates a CUDA array according to the ::cudaChannelFormatDesc structure \p desc and returns a handle to the new CUDA array in \p *array.
`static int`	`cudaMallocHost(Pointer ptr, long size)`
`static int`	`cudaMallocHost(PointerPointer ptr, long size)`	\brief Allocates page-locked memory on the host Allocates \p size bytes of host memory that is page-locked and accessible to the device.
`static int`	`cudaMallocManaged(Pointer devPtr, long size)`
`static int`	`cudaMallocManaged(Pointer devPtr, long size, int flags)`
`static int`	`cudaMallocManaged(PointerPointer devPtr, long size, int flags)`	\brief Allocates memory that will be automatically managed by the Unified Memory system Allocates \p size bytes of managed memory on the device and returns in \p *devPtr a pointer to the allocated memory.
`static int`	`cudaMallocMipmappedArray(cudaMipmappedArray mipmappedArray, cudaChannelFormatDesc desc, cudaExtent extent, int numLevels)`
`static int`	`cudaMallocMipmappedArray(cudaMipmappedArray mipmappedArray, cudaChannelFormatDesc desc, cudaExtent extent, int numLevels, int flags)`	\brief Allocate a mipmapped array on the device Allocates a CUDA mipmapped array according to the ::cudaChannelFormatDesc structure \p desc and returns a handle to the new CUDA mipmapped array in \p *mipmappedArray.
`static int`	`cudaMallocPitch(PointerPointer devPtr, SizeTPointer pitch, long width, long height)`	\brief Allocates pitched memory on the device Allocates at least \p width (in bytes) * \p height bytes of linear memory on the device and returns in \p *devPtr a pointer to the allocated memory.
`static int`	`cudaMallocPitch(Pointer devPtr, SizeTPointer pitch, long width, long height)`
`static int`	`cudaMemAdvise(Pointer devPtr, long count, int advice, int device)`	\brief Advise about the usage of a given memory range Advise the Unified Memory subsystem about the usage pattern for the memory range starting at \p devPtr with a size of \p count bytes.
`static int`	`cudaMemcpy(Pointer dst, Pointer src, long count, int kind)`	\brief Copies data between host and device Copies \p count bytes from the memory area pointed to by \p src to the memory area pointed to by \p dst, where \p kind specifies the direction of the copy, and must be one of ::cudaMemcpyHostToHost, ::cudaMemcpyHostToDevice, ::cudaMemcpyDeviceToHost, ::cudaMemcpyDeviceToDevice, or ::cudaMemcpyDefault.
`static int`	`cudaMemcpy2D(Pointer dst, long dpitch, Pointer src, long spitch, long width, long height, int kind)`	\brief Copies data between host and device Copies a matrix (\p height rows of \p width bytes each) from the memory area pointed to by \p src to the memory area pointed to by \p dst, where \p kind specifies the direction of the copy, and must be one of ::cudaMemcpyHostToHost, ::cudaMemcpyHostToDevice, ::cudaMemcpyDeviceToHost, ::cudaMemcpyDeviceToDevice, or ::cudaMemcpyDefault.
`static int`	`cudaMemcpy2DArrayToArray(cudaArray dst, long wOffsetDst, long hOffsetDst, cudaArray src, long wOffsetSrc, long hOffsetSrc, long width, long height)`
`static int`	`cudaMemcpy2DArrayToArray(cudaArray dst, long wOffsetDst, long hOffsetDst, cudaArray src, long wOffsetSrc, long hOffsetSrc, long width, long height, int kind)`	\brief Copies data between host and device Copies a matrix (\p height rows of \p width bytes each) from the CUDA array \p srcArray starting at the upper left corner (\p wOffsetSrc, \p hOffsetSrc) to the CUDA array \p dst starting at the upper left corner (\p wOffsetDst, \p hOffsetDst), where \p kind specifies the direction of the copy, and must be one of ::cudaMemcpyHostToHost, ::cudaMemcpyHostToDevice, ::cudaMemcpyDeviceToHost, ::cudaMemcpyDeviceToDevice, or ::cudaMemcpyDefault.
`static int`	`cudaMemcpy2DAsync(Pointer dst, long dpitch, Pointer src, long spitch, long width, long height, int kind)`
`static int`	`cudaMemcpy2DAsync(Pointer dst, long dpitch, Pointer src, long spitch, long width, long height, int kind, CUstream_st stream)`	\brief Copies data between host and device Copies a matrix (\p height rows of \p width bytes each) from the memory area pointed to by \p src to the memory area pointed to by \p dst, where \p kind specifies the direction of the copy, and must be one of ::cudaMemcpyHostToHost, ::cudaMemcpyHostToDevice, ::cudaMemcpyDeviceToHost, ::cudaMemcpyDeviceToDevice, or ::cudaMemcpyDefault.
`static int`	`cudaMemcpy2DFromArray(Pointer dst, long dpitch, cudaArray src, long wOffset, long hOffset, long width, long height, int kind)`	\brief Copies data between host and device Copies a matrix (\p height rows of \p width bytes each) from the CUDA array \p srcArray starting at the upper left corner (\p wOffset, \p hOffset) to the memory area pointed to by \p dst, where \p kind specifies the direction of the copy, and must be one of ::cudaMemcpyHostToHost, ::cudaMemcpyHostToDevice, ::cudaMemcpyDeviceToHost, ::cudaMemcpyDeviceToDevice, or ::cudaMemcpyDefault.
`static int`	`cudaMemcpy2DFromArrayAsync(Pointer dst, long dpitch, cudaArray src, long wOffset, long hOffset, long width, long height, int kind)`
`static int`	`cudaMemcpy2DFromArrayAsync(Pointer dst, long dpitch, cudaArray src, long wOffset, long hOffset, long width, long height, int kind, CUstream_st stream)`	\brief Copies data between host and device Copies a matrix (\p height rows of \p width bytes each) from the CUDA array \p srcArray starting at the upper left corner (\p wOffset, \p hOffset) to the memory area pointed to by \p dst, where \p kind specifies the direction of the copy, and must be one of ::cudaMemcpyHostToHost, ::cudaMemcpyHostToDevice, ::cudaMemcpyDeviceToHost, ::cudaMemcpyDeviceToDevice, or ::cudaMemcpyDefault.
`static int`	`cudaMemcpy2DToArray(cudaArray dst, long wOffset, long hOffset, Pointer src, long spitch, long width, long height, int kind)`	\brief Copies data between host and device Copies a matrix (\p height rows of \p width bytes each) from the memory area pointed to by \p src to the CUDA array \p dst starting at the upper left corner (\p wOffset, \p hOffset) where \p kind specifies the direction of the copy, and must be one of ::cudaMemcpyHostToHost, ::cudaMemcpyHostToDevice, ::cudaMemcpyDeviceToHost, ::cudaMemcpyDeviceToDevice, or ::cudaMemcpyDefault.
`static int`	`cudaMemcpy2DToArrayAsync(cudaArray dst, long wOffset, long hOffset, Pointer src, long spitch, long width, long height, int kind)`
`static int`	`cudaMemcpy2DToArrayAsync(cudaArray dst, long wOffset, long hOffset, Pointer src, long spitch, long width, long height, int kind, CUstream_st stream)`	\brief Copies data between host and device Copies a matrix (\p height rows of \p width bytes each) from the memory area pointed to by \p src to the CUDA array \p dst starting at the upper left corner (\p wOffset, \p hOffset) where \p kind specifies the direction of the copy, and must be one of ::cudaMemcpyHostToHost, ::cudaMemcpyHostToDevice, ::cudaMemcpyDeviceToHost, ::cudaMemcpyDeviceToDevice, or ::cudaMemcpyDefault.
`static int`	`cudaMemcpy3D(cudaMemcpy3DParms p)`	\brief Copies data between 3D objects
`static int`	`cudaMemcpy3DAsync(cudaMemcpy3DParms p)`
`static int`	`cudaMemcpy3DAsync(cudaMemcpy3DParms p, CUstream_st stream)`	\brief Copies data between 3D objects
`static int`	`cudaMemcpy3DPeer(cudaMemcpy3DPeerParms p)`	\brief Copies memory between devices Perform a 3D memory copy according to the parameters specified in \p p.
`static int`	`cudaMemcpy3DPeerAsync(cudaMemcpy3DPeerParms p)`
`static int`	`cudaMemcpy3DPeerAsync(cudaMemcpy3DPeerParms p, CUstream_st stream)`	\brief Copies memory between devices asynchronously.
`static int`	`cudaMemcpyArrayToArray(cudaArray dst, long wOffsetDst, long hOffsetDst, cudaArray src, long wOffsetSrc, long hOffsetSrc, long count)`	Deprecated.
`static int`	`cudaMemcpyArrayToArray(cudaArray dst, long wOffsetDst, long hOffsetDst, cudaArray src, long wOffsetSrc, long hOffsetSrc, long count, int kind)`	Deprecated. Copies \p count bytes from the CUDA array \p src starting at the upper left corner (\p wOffsetSrc, \p hOffsetSrc) to the CUDA array \p dst starting at the upper left corner (\p wOffsetDst, \p hOffsetDst) where \p kind specifies the direction of the copy, and must be one of ::cudaMemcpyHostToHost, ::cudaMemcpyHostToDevice, ::cudaMemcpyDeviceToHost, ::cudaMemcpyDeviceToDevice, or ::cudaMemcpyDefault.
`static int`	`cudaMemcpyAsync(Pointer dst, Pointer src, long count, int kind)`
`static int`	`cudaMemcpyAsync(Pointer dst, Pointer src, long count, int kind, CUstream_st stream)`	\brief Copies data between host and device Copies \p count bytes from the memory area pointed to by \p src to the memory area pointed to by \p dst, where \p kind specifies the direction of the copy, and must be one of ::cudaMemcpyHostToHost, ::cudaMemcpyHostToDevice, ::cudaMemcpyDeviceToHost, ::cudaMemcpyDeviceToDevice, or ::cudaMemcpyDefault.
`static int`	`cudaMemcpyFromArray(Pointer dst, cudaArray src, long wOffset, long hOffset, long count, int kind)`	Deprecated. Copies \p count bytes from the CUDA array \p src starting at the upper left corner (\p wOffset, hOffset) to the memory area pointed to by \p dst, where \p kind specifies the direction of the copy, and must be one of ::cudaMemcpyHostToHost, ::cudaMemcpyHostToDevice, ::cudaMemcpyDeviceToHost, ::cudaMemcpyDeviceToDevice, or ::cudaMemcpyDefault.
`static int`	`cudaMemcpyFromArrayAsync(Pointer dst, cudaArray src, long wOffset, long hOffset, long count, int kind)`	Deprecated.
`static int`	`cudaMemcpyFromArrayAsync(Pointer dst, cudaArray src, long wOffset, long hOffset, long count, int kind, CUstream_st stream)`	Deprecated. Copies \p count bytes from the CUDA array \p src starting at the upper left corner (\p wOffset, hOffset) to the memory area pointed to by \p dst, where \p kind specifies the direction of the copy, and must be one of ::cudaMemcpyHostToHost, ::cudaMemcpyHostToDevice, ::cudaMemcpyDeviceToHost, ::cudaMemcpyDeviceToDevice, or ::cudaMemcpyDefault.
`static int`	`cudaMemcpyFromSymbol(Pointer dst, Pointer symbol, long count)`
`static int`	`cudaMemcpyFromSymbol(Pointer dst, Pointer symbol, long count, long offset, int kind)`	\brief Copies data from the given symbol on the device Copies \p count bytes from the memory area pointed to by \p offset bytes from the start of symbol \p symbol to the memory area pointed to by \p dst.
`static int`	`cudaMemcpyFromSymbolAsync(Pointer dst, Pointer symbol, long count, long offset, int kind)`
`static int`	`cudaMemcpyFromSymbolAsync(Pointer dst, Pointer symbol, long count, long offset, int kind, CUstream_st stream)`	\brief Copies data from the given symbol on the device Copies \p count bytes from the memory area pointed to by \p offset bytes from the start of symbol \p symbol to the memory area pointed to by \p dst.
`static int`	`cudaMemcpyPeer(Pointer dst, int dstDevice, Pointer src, int srcDevice, long count)`	\brief Copies memory between two devices Copies memory from one device to memory on another device.
`static int`	`cudaMemcpyPeerAsync(Pointer dst, int dstDevice, Pointer src, int srcDevice, long count)`
`static int`	`cudaMemcpyPeerAsync(Pointer dst, int dstDevice, Pointer src, int srcDevice, long count, CUstream_st stream)`	\brief Copies memory between two devices asynchronously.
`static int`	`cudaMemcpyToArray(cudaArray dst, long wOffset, long hOffset, Pointer src, long count, int kind)`	Deprecated. Copies \p count bytes from the memory area pointed to by \p src to the CUDA array \p dst starting at the upper left corner (\p wOffset, \p hOffset), where \p kind specifies the direction of the copy, and must be one of ::cudaMemcpyHostToHost, ::cudaMemcpyHostToDevice, ::cudaMemcpyDeviceToHost, ::cudaMemcpyDeviceToDevice, or ::cudaMemcpyDefault.
`static int`	`cudaMemcpyToArrayAsync(cudaArray dst, long wOffset, long hOffset, Pointer src, long count, int kind)`	Deprecated.
`static int`	`cudaMemcpyToArrayAsync(cudaArray dst, long wOffset, long hOffset, Pointer src, long count, int kind, CUstream_st stream)`	Deprecated. Copies \p count bytes from the memory area pointed to by \p src to the CUDA array \p dst starting at the upper left corner (\p wOffset, \p hOffset), where \p kind specifies the direction of the copy, and must be one of ::cudaMemcpyHostToHost, ::cudaMemcpyHostToDevice, ::cudaMemcpyDeviceToHost, ::cudaMemcpyDeviceToDevice, or ::cudaMemcpyDefault.
`static int`	`cudaMemcpyToSymbol(Pointer symbol, Pointer src, long count)`
`static int`	`cudaMemcpyToSymbol(Pointer symbol, Pointer src, long count, long offset, int kind)`	\brief Copies data to the given symbol on the device Copies \p count bytes from the memory area pointed to by \p src to the memory area pointed to by \p offset bytes from the start of symbol \p symbol.
`static int`	`cudaMemcpyToSymbolAsync(Pointer symbol, Pointer src, long count, long offset, int kind)`
`static int`	`cudaMemcpyToSymbolAsync(Pointer symbol, Pointer src, long count, long offset, int kind, CUstream_st stream)`	\brief Copies data to the given symbol on the device Copies \p count bytes from the memory area pointed to by \p src to the memory area pointed to by \p offset bytes from the start of symbol \p symbol.
`static int`	`cudaMemGetInfo(SizeTPointer _free, SizeTPointer total)`	\brief Gets free and total device memory Returns in \p free and \p total respectively, the free and total amount of memory available for allocation by the device in bytes.
`static int`	`cudaMemPrefetchAsync(Pointer devPtr, long count, int dstDevice)`
`static int`	`cudaMemPrefetchAsync(Pointer devPtr, long count, int dstDevice, CUstream_st stream)`	\brief Prefetches memory to the specified destination device Prefetches memory to the specified destination device.
`static int`	`cudaMemRangeGetAttribute(Pointer data, long dataSize, int attribute, Pointer devPtr, long count)`	\brief Query an attribute of a given memory range Query an attribute about the memory range starting at \p devPtr with a size of \p count bytes.
`static int`	`cudaMemRangeGetAttributes(PointerPointer data, SizeTPointer dataSizes, IntPointer attributes, long numAttributes, Pointer devPtr, long count)`	\brief Query attributes of a given memory range.
`static int`	`cudaMemRangeGetAttributes(Pointer data, SizeTPointer dataSizes, int[] attributes, long numAttributes, Pointer devPtr, long count)`
`static int`	`cudaMemRangeGetAttributes(Pointer data, SizeTPointer dataSizes, IntBuffer attributes, long numAttributes, Pointer devPtr, long count)`
`static int`	`cudaMemRangeGetAttributes(Pointer data, SizeTPointer dataSizes, IntPointer attributes, long numAttributes, Pointer devPtr, long count)`
`static int`	`cudaMemset(Pointer devPtr, int value, long count)`	\brief Initializes or sets device memory to a value Fills the first \p count bytes of the memory area pointed to by \p devPtr with the constant byte value \p value.
`static int`	`cudaMemset2D(Pointer devPtr, long pitch, int value, long width, long height)`	\brief Initializes or sets device memory to a value Sets to the specified value \p value a matrix (\p height rows of \p width bytes each) pointed to by \p dstPtr.
`static int`	`cudaMemset2DAsync(Pointer devPtr, long pitch, int value, long width, long height)`
`static int`	`cudaMemset2DAsync(Pointer devPtr, long pitch, int value, long width, long height, CUstream_st stream)`	\brief Initializes or sets device memory to a value Sets to the specified value \p value a matrix (\p height rows of \p width bytes each) pointed to by \p dstPtr.
`static int`	`cudaMemset3D(cudaPitchedPtr pitchedDevPtr, int value, cudaExtent extent)`	\brief Initializes or sets device memory to a value Initializes each element of a 3D array to the specified value \p value.
`static int`	`cudaMemset3DAsync(cudaPitchedPtr pitchedDevPtr, int value, cudaExtent extent)`
`static int`	`cudaMemset3DAsync(cudaPitchedPtr pitchedDevPtr, int value, cudaExtent extent, CUstream_st stream)`	\brief Initializes or sets device memory to a value Initializes each element of a 3D array to the specified value \p value.
`static int`	`cudaMemsetAsync(Pointer devPtr, int value, long count)`
`static int`	`cudaMemsetAsync(Pointer devPtr, int value, long count, CUstream_st stream)`	\brief Initializes or sets device memory to a value Fills the first \p count bytes of the memory area pointed to by \p devPtr with the constant byte value \p value.
`static int`	`cudaOccupancyMaxActiveBlocksPerMultiprocessor(int[] numBlocks, Pointer func, int blockSize, long dynamicSMemSize)`
`static int`	`cudaOccupancyMaxActiveBlocksPerMultiprocessor(IntBuffer numBlocks, Pointer func, int blockSize, long dynamicSMemSize)`
`static int`	`cudaOccupancyMaxActiveBlocksPerMultiprocessor(IntPointer numBlocks, Pointer func, int blockSize, long dynamicSMemSize)`	\brief Returns occupancy for a device function Returns in \p *numBlocks the maximum number of active blocks per streaming multiprocessor for the device function.
`static int`	`cudaOccupancyMaxActiveBlocksPerMultiprocessorWithFlags(int[] numBlocks, Pointer func, int blockSize, long dynamicSMemSize, int flags)`
`static int`	`cudaOccupancyMaxActiveBlocksPerMultiprocessorWithFlags(IntBuffer numBlocks, Pointer func, int blockSize, long dynamicSMemSize, int flags)`
`static int`	`cudaOccupancyMaxActiveBlocksPerMultiprocessorWithFlags(IntPointer numBlocks, Pointer func, int blockSize, long dynamicSMemSize, int flags)`	\brief Returns occupancy for a device function with the specified flags Returns in \p *numBlocks the maximum number of active blocks per streaming multiprocessor for the device function.
`static int`	`cudaPeekAtLastError()`	\brief Returns the last error from a runtime call Returns the last error that has been produced by any of the runtime calls in the same host thread.
`static int`	`cudaPointerGetAttributes(cudaPointerAttributes attributes, Pointer ptr)`	\brief Returns attributes about a specified pointer Returns in \p *attributes the attributes of the pointer \p ptr.
`static int`	`cudaRuntimeGetVersion(int[] runtimeVersion)`
`static int`	`cudaRuntimeGetVersion(IntBuffer runtimeVersion)`
`static int`	`cudaRuntimeGetVersion(IntPointer runtimeVersion)`	\brief Returns the CUDA Runtime version Returns in \p *runtimeVersion the version number of the current CUDA Runtime instance.
`static int`	`cudaSetDevice(int device)`	\brief Set device to be used for GPU executions Sets \p device as the current device for the calling host thread.
`static int`	`cudaSetDeviceFlags(int flags)`	\brief Sets flags to be used for device executions Records \p flags as the flags to use when initializing the current device.
`static int`	`cudaSetDoubleForDevice(double[] d)`	Deprecated.
`static int`	`cudaSetDoubleForDevice(DoubleBuffer d)`	Deprecated.
`static int`	`cudaSetDoubleForDevice(DoublePointer d)`	Deprecated. This function is deprecated as of CUDA 7.5 Converts the double value of \p d to an internal float representation if the device does not support double arithmetic.
`static int`	`cudaSetDoubleForHost(double[] d)`	Deprecated.
`static int`	`cudaSetDoubleForHost(DoubleBuffer d)`	Deprecated.
`static int`	`cudaSetDoubleForHost(DoublePointer d)`	Deprecated. This function is deprecated as of CUDA 7.5 Converts the double value of \p d from a potentially internal float representation if the device does not support double arithmetic.
`static int`	`cudaSetValidDevices(int[] device_arr, int len)`
`static int`	`cudaSetValidDevices(IntBuffer device_arr, int len)`
`static int`	`cudaSetValidDevices(IntPointer device_arr, int len)`	\brief Set a list of devices that can be used for CUDA Sets a list of devices for CUDA execution in priority order using \p device_arr.
`static int`	`cudaSignalExternalSemaphoresAsync(CUexternalSemaphore_st extSemArray, cudaExternalSemaphoreSignalParams paramsArray, int numExtSems)`
`static int`	`cudaSignalExternalSemaphoresAsync(CUexternalSemaphore_st extSemArray, cudaExternalSemaphoreSignalParams paramsArray, int numExtSems, CUstream_st stream)`	\brief Signals a set of external semaphore objects Enqueues a signal operation on a set of externally allocated semaphore object in the specified stream.
`static int`	`cudaStreamAddCallback(CUstream_st stream, cudaStreamCallback_t callback, Pointer userData, int flags)`	\brief Add a callback to a compute stream \note This function is slated for eventual deprecation and removal.
`static int`	`cudaStreamAttachMemAsync(CUstream_st stream, Pointer devPtr)`
`static int`	`cudaStreamAttachMemAsync(CUstream_st stream, Pointer devPtr, long length, int flags)`	\brief Attach memory to a stream asynchronously Enqueues an operation in \p stream to specify stream association of \p length bytes of memory starting from \p devPtr.
`static int`	`cudaStreamBeginCapture(CUstream_st stream, int mode)`	\brief Begins graph capture on a stream Begin graph capture on \p stream.
`static int`	`cudaStreamCreate(CUstream_st pStream)`	\brief Create an asynchronous stream Creates a new asynchronous stream.
`static int`	`cudaStreamCreateWithFlags(CUstream_st pStream, int flags)`	\brief Create an asynchronous stream Creates a new asynchronous stream.
`static int`	`cudaStreamCreateWithPriority(CUstream_st pStream, int flags, int priority)`	\brief Create an asynchronous stream with the specified priority Creates a stream with the specified priority and returns a handle in \p pStream.
`static int`	`cudaStreamDestroy(CUstream_st stream)`	\brief Destroys and cleans up an asynchronous stream Destroys and cleans up the asynchronous stream specified by \p stream.
`static int`	`cudaStreamEndCapture(CUstream_st stream, CUgraph_st pGraph)`	\brief Ends capture on a stream, returning the captured graph End capture on \p stream, returning the captured graph via \p pGraph.
`static int`	`cudaStreamGetCaptureInfo(CUstream_st stream, int[] pCaptureStatus, long[] pId)`
`static int`	`cudaStreamGetCaptureInfo(CUstream_st stream, IntBuffer pCaptureStatus, LongBuffer pId)`
`static int`	`cudaStreamGetCaptureInfo(CUstream_st stream, IntPointer pCaptureStatus, LongPointer pId)`	\brief Query capture status of a stream Query the capture status of a stream and get a unique id representing the capture sequence over the lifetime of the process.
`static int`	`cudaStreamGetFlags(CUstream_st hStream, int[] flags)`
`static int`	`cudaStreamGetFlags(CUstream_st hStream, IntBuffer flags)`
`static int`	`cudaStreamGetFlags(CUstream_st hStream, IntPointer flags)`	\brief Query the flags of a stream Query the flags of a stream.
`static int`	`cudaStreamGetPriority(CUstream_st hStream, int[] priority)`
`static int`	`cudaStreamGetPriority(CUstream_st hStream, IntBuffer priority)`
`static int`	`cudaStreamGetPriority(CUstream_st hStream, IntPointer priority)`	\brief Query the priority of a stream Query the priority of a stream.
`static int`	`cudaStreamIsCapturing(CUstream_st stream, int[] pCaptureStatus)`
`static int`	`cudaStreamIsCapturing(CUstream_st stream, IntBuffer pCaptureStatus)`
`static int`	`cudaStreamIsCapturing(CUstream_st stream, IntPointer pCaptureStatus)`	\brief Returns a stream's capture status Return the capture status of \p stream via \p pCaptureStatus.
`static CUstream_st`	`cudaStreamLegacy()`	Legacy stream handle Stream handle that can be passed as a cudaStream_t to use an implicit stream with legacy synchronization behavior.
`static CUstream_st`	`cudaStreamPerThread()`	Per-thread stream handle Stream handle that can be passed as a cudaStream_t to use an implicit stream with per-thread synchronization behavior.
`static int`	`cudaStreamQuery(CUstream_st stream)`	\brief Queries an asynchronous stream for completion status Returns ::cudaSuccess if all operations in \p stream have completed, or ::cudaErrorNotReady if not.
`static int`	`cudaStreamSynchronize(CUstream_st stream)`	\brief Waits for stream tasks to complete Blocks until \p stream has completed all operations.
`static int`	`cudaStreamWaitEvent(CUstream_st stream, CUevent_st event, int flags)`	\brief Make a compute stream wait on an event Makes all future work submitted to \p stream wait for all work captured in \p event.
`static int`	`cudaThreadExchangeStreamCaptureMode(int[] mode)`
`static int`	`cudaThreadExchangeStreamCaptureMode(IntBuffer mode)`
`static int`	`cudaThreadExchangeStreamCaptureMode(IntPointer mode)`	\brief Swaps the stream capture interaction mode for a thread Sets the calling thread's stream capture interaction mode to the value contained in \p mode, and overwrites \p mode with the previous mode for the thread.
`static int`	`cudaThreadExit()`	Deprecated. Note that this function is deprecated because its name does not reflect its behavior.
`static int`	`cudaThreadGetCacheConfig(int[] pCacheConfig)`	Deprecated.
`static int`	`cudaThreadGetCacheConfig(IntBuffer pCacheConfig)`	Deprecated.
`static int`	`cudaThreadGetCacheConfig(IntPointer pCacheConfig)`	Deprecated. Note that this function is deprecated because its name does not reflect its behavior.
`static int`	`cudaThreadGetLimit(SizeTPointer pValue, int _limit)`	Deprecated. Note that this function is deprecated because its name does not reflect its behavior.
`static int`	`cudaThreadSetCacheConfig(int cacheConfig)`	Deprecated. Note that this function is deprecated because its name does not reflect its behavior.
`static int`	`cudaThreadSetLimit(int _limit, long value)`	Deprecated. Note that this function is deprecated because its name does not reflect its behavior.
`static int`	`cudaThreadSynchronize()`	Deprecated. Note that this function is deprecated because its name does not reflect its behavior.
`static int`	`cudaUnbindTexture(textureReference texref)`	Deprecated. Unbinds the texture bound to \p texref.
`static int`	`cudaWaitExternalSemaphoresAsync(CUexternalSemaphore_st extSemArray, cudaExternalSemaphoreWaitParams paramsArray, int numExtSems)`
`static int`	`cudaWaitExternalSemaphoresAsync(CUexternalSemaphore_st extSemArray, cudaExternalSemaphoreWaitParams paramsArray, int numExtSems, CUstream_st stream)`	\brief Waits on a set of external semaphore objects Enqueues a wait operation on a set of externally allocated semaphore object in the specified stream.
`static int`	`cuDestroyExternalMemory(CUextMemory_st extMem)`	\brief Destroys an external memory object.
`static int`	`cuDestroyExternalSemaphore(CUextSemaphore_st extSem)`	\brief Destroys an external semaphore Destroys an external semaphore object and releases any references to the underlying resource.
`static int`	`cuDeviceCanAccessPeer(int[] canAccessPeer, int dev, int peerDev)`
`static int`	`cuDeviceCanAccessPeer(IntBuffer canAccessPeer, int dev, int peerDev)`
`static int`	`cuDeviceCanAccessPeer(IntPointer canAccessPeer, int dev, int peerDev)`	\brief Queries if a device may directly access a peer device's memory.
`static int`	`cuDeviceComputeCapability(int[] major, int[] minor, int dev)`	Deprecated.
`static int`	`cuDeviceComputeCapability(IntBuffer major, IntBuffer minor, int dev)`	Deprecated.
`static int`	`cuDeviceComputeCapability(IntPointer major, IntPointer minor, int dev)`	Deprecated. This function was deprecated as of CUDA 5.0 and its functionality superceded by ::cuDeviceGetAttribute().
`static int`	`cuDeviceGet(int[] device, int ordinal)`
`static int`	`cuDeviceGet(IntBuffer device, int ordinal)`
`static int`	`cuDeviceGet(IntPointer device, int ordinal)`	\brief Returns a handle to a compute device Returns in \p device a device handle given an ordinal in the range [0, ::cuDeviceGetCount()-1]*.
`static int`	`cuDeviceGetAttribute(int[] pi, int attrib, int dev)`
`static int`	`cuDeviceGetAttribute(IntBuffer pi, int attrib, int dev)`
`static int`	`cuDeviceGetAttribute(IntPointer pi, int attrib, int dev)`	\brief Returns information about the device Returns in \p *pi the integer value of the attribute \p attrib on device \p dev.
`static int`	`cuDeviceGetByPCIBusId(int[] dev, String pciBusId)`
`static int`	`cuDeviceGetByPCIBusId(int[] dev, BytePointer pciBusId)`
`static int`	`cuDeviceGetByPCIBusId(IntBuffer dev, String pciBusId)`
`static int`	`cuDeviceGetByPCIBusId(IntBuffer dev, BytePointer pciBusId)`
`static int`	`cuDeviceGetByPCIBusId(IntPointer dev, String pciBusId)`
`static int`	`cuDeviceGetByPCIBusId(IntPointer dev, BytePointer pciBusId)`	\brief Returns a handle to a compute device Returns in \p *device a device handle given a PCI bus ID string.
`static int`	`cuDeviceGetCount(int[] count)`
`static int`	`cuDeviceGetCount(IntBuffer count)`
`static int`	`cuDeviceGetCount(IntPointer count)`	\brief Returns the number of compute-capable devices Returns in \p *count the number of devices with compute capability greater than or equal to 2.0 that are available for execution.
`static int`	`cuDeviceGetName(byte[] name, int len, int dev)`
`static int`	`cuDeviceGetName(ByteBuffer name, int len, int dev)`
`static int`	`cuDeviceGetName(BytePointer name, int len, int dev)`	\brief Returns an identifer string for the device Returns an ASCII string identifying the device \p dev in the NULL-terminated string pointed to by \p name.
`static int`	`cuDeviceGetPCIBusId(byte[] pciBusId, int len, int dev)`
`static int`	`cuDeviceGetPCIBusId(ByteBuffer pciBusId, int len, int dev)`
`static int`	`cuDeviceGetPCIBusId(BytePointer pciBusId, int len, int dev)`	\brief Returns a PCI Bus Id string for the device Returns an ASCII string identifying the device \p dev in the NULL-terminated string pointed to by \p pciBusId.
`static int`	`cuDeviceGetProperties(CUdevprop prop, int dev)`	Deprecated. This function was deprecated as of CUDA 5.0 and replaced by ::cuDeviceGetAttribute().
`static int`	`cuDeviceGetUuid(CUuuid uuid, int dev)`	\brief Return an UUID for the device Returns 16-octets identifing the device \p dev in the structure pointed by the \p uuid.
`static int`	`cuDevicePrimaryCtxGetState(int dev, int[] flags, int[] active)`
`static int`	`cuDevicePrimaryCtxGetState(int dev, IntBuffer flags, IntBuffer active)`
`static int`	`cuDevicePrimaryCtxGetState(int dev, IntPointer flags, IntPointer active)`	\brief Get the state of the primary context Returns in \p flags the flags for the primary context of \p dev, and in \p active whether it is active.
`static int`	`cuDevicePrimaryCtxRelease(int dev)`	\brief Release the primary context on the GPU Releases the primary context interop on the device by decreasing the usage count by 1.
`static int`	`cuDevicePrimaryCtxReset(int dev)`	\brief Destroy all allocations and reset all state on the primary context Explicitly destroys and cleans up all resources associated with the current device in the current process.
`static int`	`cuDevicePrimaryCtxRetain(CUctx_st pctx, int dev)`	\brief Retain the primary context on the GPU Retains the primary context on the device, creating it if necessary, increasing its usage count.
`static int`	`cuDevicePrimaryCtxSetFlags(int dev, int flags)`	\brief Set flags for the primary context Sets the flags for the primary context on the device overwriting perviously set ones.
`static int`	`cuDeviceTotalMem(SizeTPointer bytes, int dev)`	\brief Returns the total amount of memory on the device Returns in \p *bytes the total amount of memory available on the device \p dev in bytes.
`static int`	`cuDriverGetVersion(int[] driverVersion)`
`static int`	`cuDriverGetVersion(IntBuffer driverVersion)`
`static int`	`cuDriverGetVersion(IntPointer driverVersion)`	\brief Returns the latest CUDA version supported by driver Returns in \p *driverVersion the version of CUDA supported by the driver.
`static int`	`cuEventCreate(CUevent_st phEvent, int Flags)`	\brief Creates an event Creates an event *phEvent for the current context with the flags specified via \p Flags.
`static int`	`cuEventDestroy(CUevent_st hEvent)`	\brief Destroys an event Destroys the event specified by \p hEvent.
`static int`	`cuEventElapsedTime(float[] pMilliseconds, CUevent_st hStart, CUevent_st hEnd)`
`static int`	`cuEventElapsedTime(FloatBuffer pMilliseconds, CUevent_st hStart, CUevent_st hEnd)`
`static int`	`cuEventElapsedTime(FloatPointer pMilliseconds, CUevent_st hStart, CUevent_st hEnd)`	\brief Computes the elapsed time between two events Computes the elapsed time between two events (in milliseconds with a resolution of around 0.5 microseconds).
`static int`	`cuEventQuery(CUevent_st hEvent)`	\brief Queries an event's status Queries the status of all work currently captured by \p hEvent.
`static int`	`cuEventRecord(CUevent_st hEvent, CUstream_st hStream)`	\brief Records an event Captures in \p hEvent the contents of \p hStream at the time of this call.
`static int`	`cuEventSynchronize(CUevent_st hEvent)`	\brief Waits for an event to complete Waits until the completion of all work currently captured in \p hEvent.
`static int`	`cuExternalMemoryGetMappedBuffer(long[] devPtr, CUextMemory_st extMem, CUDA_EXTERNAL_MEMORY_BUFFER_DESC bufferDesc)`
`static int`	`cuExternalMemoryGetMappedBuffer(LongBuffer devPtr, CUextMemory_st extMem, CUDA_EXTERNAL_MEMORY_BUFFER_DESC bufferDesc)`
`static int`	`cuExternalMemoryGetMappedBuffer(LongPointer devPtr, CUextMemory_st extMem, CUDA_EXTERNAL_MEMORY_BUFFER_DESC bufferDesc)`	\brief Maps a buffer onto an imported memory object Maps a buffer onto an imported memory object and returns a device pointer in \p devPtr.
`static int`	`cuExternalMemoryGetMappedMipmappedArray(CUmipmappedArray_st mipmap, CUextMemory_st extMem, CUDA_EXTERNAL_MEMORY_MIPMAPPED_ARRAY_DESC mipmapDesc)`	\brief Maps a CUDA mipmapped array onto an external memory object Maps a CUDA mipmapped array onto an external object and returns a handle to it in \p mipmap.
`static int`	`cuFuncGetAttribute(int[] pi, int attrib, CUfunc_st hfunc)`
`static int`	`cuFuncGetAttribute(IntBuffer pi, int attrib, CUfunc_st hfunc)`
`static int`	`cuFuncGetAttribute(IntPointer pi, int attrib, CUfunc_st hfunc)`	\brief Returns information about a function Returns in \p *pi the integer value of the attribute \p attrib on the kernel given by \p hfunc.
`static int`	`cuFuncSetAttribute(CUfunc_st hfunc, int attrib, int value)`	\brief Sets information about a function This call sets the value of a specified attribute \p attrib on the kernel given by \p hfunc to an integer value specified by \p val This function returns CUDA_SUCCESS if the new value of the attribute could be successfully set.
`static int`	`cuFuncSetBlockShape(CUfunc_st hfunc, int x, int y, int z)`	Deprecated. Specifies the \p x, \p y, and \p z dimensions of the thread blocks that are created when the kernel given by \p hfunc is launched.
`static int`	`cuFuncSetCacheConfig(CUfunc_st hfunc, int config)`	\brief Sets the preferred cache configuration for a device function On devices where the L1 cache and shared memory use the same hardware resources, this sets through \p config the preferred cache configuration for the device function \p hfunc.
`static int`	`cuFuncSetSharedMemConfig(CUfunc_st hfunc, int config)`	\brief Sets the shared memory configuration for a device function.
`static int`	`cuFuncSetSharedSize(CUfunc_st hfunc, int bytes)`	Deprecated. Sets through \p bytes the amount of dynamic shared memory that will be available to each thread block when the kernel given by \p hfunc is launched.
`static int`	`cuGetErrorName(int error, byte[] pStr)`
`static int`	`cuGetErrorName(int error, ByteBuffer pStr)`
`static int`	`cuGetErrorName(int error, BytePointer pStr)`
`static int`	`cuGetErrorName(int error, PointerPointer pStr)`	\brief Gets the string representation of an error code enum name Sets \p *pStr to the address of a NULL-terminated string representation of the name of the enum error code \p error.
`static int`	`cuGetErrorString(int error, byte[] pStr)`
`static int`	`cuGetErrorString(int error, ByteBuffer pStr)`
`static int`	`cuGetErrorString(int error, BytePointer pStr)`
`static int`	`cuGetErrorString(int error, PointerPointer pStr)`	\brief Gets the string description of an error code Sets \p *pStr to the address of a NULL-terminated string description of the error code \p error.
`static int`	`cuGetExportTable(PointerPointer ppExportTable, CUuuid pExportTableId)`	\}
`static int`	`cuGetExportTable(Pointer ppExportTable, CUuuid pExportTableId)`
`static int`	`cuGraphAddChildGraphNode(CUgraphNode_st phGraphNode, CUgraph_st hGraph, CUgraphNode_st dependencies, long numDependencies, CUgraph_st childGraph)`	\brief Creates a child graph node and adds it to a graph Creates a new node which executes an embedded graph, and adds it to \p hGraph with \p numDependencies dependencies specified via \p dependencies.
`static int`	`cuGraphAddDependencies(CUgraph_st hGraph, CUgraphNode_st from, CUgraphNode_st to, long numDependencies)`	\brief Adds dependency edges to a graph The number of dependencies to be added is defined by \p numDependencies Elements in \p from and \p to at corresponding indices define a dependency.
`static int`	`cuGraphAddEmptyNode(CUgraphNode_st phGraphNode, CUgraph_st hGraph, CUgraphNode_st dependencies, long numDependencies)`	\brief Creates an empty node and adds it to a graph Creates a new node which performs no operation, and adds it to \p hGraph with \p numDependencies dependencies specified via \p dependencies.
`static int`	`cuGraphAddHostNode(CUgraphNode_st phGraphNode, CUgraph_st hGraph, CUgraphNode_st dependencies, long numDependencies, CUDA_HOST_NODE_PARAMS nodeParams)`	\brief Creates a host execution node and adds it to a graph Creates a new CPU execution node and adds it to \p hGraph with \p numDependencies dependencies specified via \p dependencies and arguments specified in \p nodeParams.
`static int`	`cuGraphAddKernelNode(CUgraphNode_st phGraphNode, CUgraph_st hGraph, CUgraphNode_st dependencies, long numDependencies, CUDA_KERNEL_NODE_PARAMS nodeParams)`	\brief Creates a kernel execution node and adds it to a graph Creates a new kernel execution node and adds it to \p hGraph with \p numDependencies dependencies specified via \p dependencies and arguments specified in \p nodeParams.
`static int`	`cuGraphAddMemcpyNode(CUgraphNode_st phGraphNode, CUgraph_st hGraph, CUgraphNode_st dependencies, long numDependencies, CUDA_MEMCPY3D copyParams, CUctx_st ctx)`	\brief Creates a memcpy node and adds it to a graph Creates a new memcpy node and adds it to \p hGraph with \p numDependencies dependencies specified via \p dependencies.
`static int`	`cuGraphAddMemsetNode(CUgraphNode_st phGraphNode, CUgraph_st hGraph, CUgraphNode_st dependencies, long numDependencies, CUDA_MEMSET_NODE_PARAMS memsetParams, CUctx_st ctx)`	\brief Creates a memset node and adds it to a graph Creates a new memset node and adds it to \p hGraph with \p numDependencies dependencies specified via \p dependencies.
`static int`	`cuGraphChildGraphNodeGetGraph(CUgraphNode_st hNode, CUgraph_st phGraph)`	\brief Gets a handle to the embedded graph of a child graph node Gets a handle to the embedded graph in a child graph node.
`static int`	`cuGraphClone(CUgraph_st phGraphClone, CUgraph_st originalGraph)`	\brief Clones a graph This function creates a copy of \p originalGraph and returns it in \p * phGraphClone.
`static int`	`cuGraphCreate(CUgraph_st phGraph, int flags)`	\brief Creates a graph Creates an empty graph, which is returned via \p phGraph.
`static int`	`cuGraphDestroy(CUgraph_st hGraph)`	\brief Destroys a graph Destroys the graph specified by \p hGraph, as well as all of its nodes.
`static int`	`cuGraphDestroyNode(CUgraphNode_st hNode)`	\brief Remove a node from the graph Removes \p hNode from its graph.
`static int`	`cuGraphExecDestroy(CUgraphExec_st hGraphExec)`	\brief Destroys an executable graph Destroys the executable graph specified by \p hGraphExec, as well as all of its executable nodes.
`static int`	`cuGraphExecHostNodeSetParams(CUgraphExec_st hGraphExec, CUgraphNode_st hNode, CUDA_HOST_NODE_PARAMS nodeParams)`	\brief Sets the parameters for a host node in the given graphExec.
`static int`	`cuGraphExecKernelNodeSetParams(CUgraphExec_st hGraphExec, CUgraphNode_st hNode, CUDA_KERNEL_NODE_PARAMS nodeParams)`	\brief Sets the parameters for a kernel node in the given graphExec Sets the parameters of a kernel node in an executable graph \p hGraphExec.
`static int`	`cuGraphExecMemcpyNodeSetParams(CUgraphExec_st hGraphExec, CUgraphNode_st hNode, CUDA_MEMCPY3D copyParams, CUctx_st ctx)`	\brief Sets the parameters for a memcpy node in the given graphExec.
`static int`	`cuGraphExecMemsetNodeSetParams(CUgraphExec_st hGraphExec, CUgraphNode_st hNode, CUDA_MEMSET_NODE_PARAMS memsetParams, CUctx_st ctx)`	\brief Sets the parameters for a memset node in the given graphExec.
`static int`	`cuGraphExecUpdate(CUgraphExec_st hGraphExec, CUgraph_st hGraph, CUgraphNode_st hErrorNode_out, int[] updateResult_out)`
`static int`	`cuGraphExecUpdate(CUgraphExec_st hGraphExec, CUgraph_st hGraph, CUgraphNode_st hErrorNode_out, IntBuffer updateResult_out)`
`static int`	`cuGraphExecUpdate(CUgraphExec_st hGraphExec, CUgraph_st hGraph, CUgraphNode_st hErrorNode_out, IntPointer updateResult_out)`	\brief Check whether an executable graph can be updated with a graph and perform the update if possible Updates the node parameters in the instantiated graph specified by \p hGraphExec with the node parameters in a topologically identical graph specified by \p hGraph.
`static int`	`cuGraphGetEdges(CUgraph_st hGraph, CUgraphNode_st from, CUgraphNode_st to, SizeTPointer numEdges)`	\brief Returns a graph's dependency edges Returns a list of \p hGraph's dependency edges.
`static int`	`cuGraphGetNodes(CUgraph_st hGraph, CUgraphNode_st nodes, SizeTPointer numNodes)`	\brief Returns a graph's nodes Returns a list of \p hGraph's nodes.
`static int`	`cuGraphGetRootNodes(CUgraph_st hGraph, CUgraphNode_st rootNodes, SizeTPointer numRootNodes)`	\brief Returns a graph's root nodes Returns a list of \p hGraph's root nodes.
`static int`	`cuGraphHostNodeGetParams(CUgraphNode_st hNode, CUDA_HOST_NODE_PARAMS nodeParams)`	\brief Returns a host node's parameters Returns the parameters of host node \p hNode in \p nodeParams.
`static int`	`cuGraphHostNodeSetParams(CUgraphNode_st hNode, CUDA_HOST_NODE_PARAMS nodeParams)`	\brief Sets a host node's parameters Sets the parameters of host node \p hNode to \p nodeParams.
`static int`	`cuGraphicsMapResources(int count, CUgraphicsResource_st resources, CUstream_st hStream)`	\brief Map graphics resources for access by CUDA Maps the \p count graphics resources in \p resources for access by CUDA.
`static int`	`cuGraphicsResourceGetMappedMipmappedArray(CUmipmappedArray_st pMipmappedArray, CUgraphicsResource_st resource)`	\brief Get a mipmapped array through which to access a mapped graphics resource.
`static int`	`cuGraphicsResourceGetMappedPointer(long[] pDevPtr, SizeTPointer pSize, CUgraphicsResource_st resource)`
`static int`	`cuGraphicsResourceGetMappedPointer(LongBuffer pDevPtr, SizeTPointer pSize, CUgraphicsResource_st resource)`
`static int`	`cuGraphicsResourceGetMappedPointer(LongPointer pDevPtr, SizeTPointer pSize, CUgraphicsResource_st resource)`	\brief Get a device pointer through which to access a mapped graphics resource.
`static int`	`cuGraphicsResourceSetMapFlags(CUgraphicsResource_st resource, int flags)`	\brief Set usage flags for mapping a graphics resource Set \p flags for mapping the graphics resource \p resource.
`static int`	`cuGraphicsSubResourceGetMappedArray(CUarray_st pArray, CUgraphicsResource_st resource, int arrayIndex, int mipLevel)`	\brief Get an array through which to access a subresource of a mapped graphics resource.
`static int`	`cuGraphicsUnmapResources(int count, CUgraphicsResource_st resources, CUstream_st hStream)`	\brief Unmap graphics resources.
`static int`	`cuGraphicsUnregisterResource(CUgraphicsResource_st resource)`	\brief Unregisters a graphics resource for access by CUDA Unregisters the graphics resource \p resource so it is not accessible by CUDA unless registered again.
`static int`	`cuGraphInstantiate(CUgraphExec_st phGraphExec, CUgraph_st hGraph, CUgraphNode_st phErrorNode, byte[] logBuffer, long bufferSize)`
`static int`	`cuGraphInstantiate(CUgraphExec_st phGraphExec, CUgraph_st hGraph, CUgraphNode_st phErrorNode, ByteBuffer logBuffer, long bufferSize)`
`static int`	`cuGraphInstantiate(CUgraphExec_st phGraphExec, CUgraph_st hGraph, CUgraphNode_st phErrorNode, BytePointer logBuffer, long bufferSize)`	\brief Creates an executable graph from a graph Instantiates \p hGraph as an executable graph.
`static int`	`cuGraphKernelNodeGetParams(CUgraphNode_st hNode, CUDA_KERNEL_NODE_PARAMS nodeParams)`	\brief Returns a kernel node's parameters Returns the parameters of kernel node \p hNode in \p nodeParams.
`static int`	`cuGraphKernelNodeSetParams(CUgraphNode_st hNode, CUDA_KERNEL_NODE_PARAMS nodeParams)`	\brief Sets a kernel node's parameters Sets the parameters of kernel node \p hNode to \p nodeParams.
`static int`	`cuGraphLaunch(CUgraphExec_st hGraphExec, CUstream_st hStream)`	\brief Launches an executable graph in a stream Executes \p hGraphExec in \p hStream.
`static int`	`cuGraphMemcpyNodeGetParams(CUgraphNode_st hNode, CUDA_MEMCPY3D nodeParams)`	\brief Returns a memcpy node's parameters Returns the parameters of memcpy node \p hNode in \p nodeParams.
`static int`	`cuGraphMemcpyNodeSetParams(CUgraphNode_st hNode, CUDA_MEMCPY3D nodeParams)`	\brief Sets a memcpy node's parameters Sets the parameters of memcpy node \p hNode to \p nodeParams.
`static int`	`cuGraphMemsetNodeGetParams(CUgraphNode_st hNode, CUDA_MEMSET_NODE_PARAMS nodeParams)`	\brief Returns a memset node's parameters Returns the parameters of memset node \p hNode in \p nodeParams.
`static int`	`cuGraphMemsetNodeSetParams(CUgraphNode_st hNode, CUDA_MEMSET_NODE_PARAMS nodeParams)`	\brief Sets a memset node's parameters Sets the parameters of memset node \p hNode to \p nodeParams.
`static int`	`cuGraphNodeFindInClone(CUgraphNode_st phNode, CUgraphNode_st hOriginalNode, CUgraph_st hClonedGraph)`	\brief Finds a cloned version of a node This function returns the node in \p hClonedGraph corresponding to \p hOriginalNode in the original graph.
`static int`	`cuGraphNodeGetDependencies(CUgraphNode_st hNode, CUgraphNode_st dependencies, SizeTPointer numDependencies)`	\brief Returns a node's dependencies Returns a list of \p node's dependencies.
`static int`	`cuGraphNodeGetDependentNodes(CUgraphNode_st hNode, CUgraphNode_st dependentNodes, SizeTPointer numDependentNodes)`	\brief Returns a node's dependent nodes Returns a list of \p node's dependent nodes.
`static int`	`cuGraphNodeGetType(CUgraphNode_st hNode, int[] type)`
`static int`	`cuGraphNodeGetType(CUgraphNode_st hNode, IntBuffer type)`
`static int`	`cuGraphNodeGetType(CUgraphNode_st hNode, IntPointer type)`	\brief Returns a node's type Returns the node type of \p hNode in \p type.
`static int`	`cuGraphRemoveDependencies(CUgraph_st hGraph, CUgraphNode_st from, CUgraphNode_st to, long numDependencies)`	\brief Removes dependency edges from a graph The number of \p dependencies to be removed is defined by \p numDependencies.
`static int`	`cuImportExternalMemory(CUextMemory_st extMem_out, CUDA_EXTERNAL_MEMORY_HANDLE_DESC memHandleDesc)`	\brief Imports an external memory object Imports an externally allocated memory object and returns a handle to that in \p extMem_out.
`static int`	`cuImportExternalSemaphore(CUextSemaphore_st extSem_out, CUDA_EXTERNAL_SEMAPHORE_HANDLE_DESC semHandleDesc)`	\brief Imports an external semaphore Imports an externally allocated synchronization object and returns a handle to that in \p extSem_out.
`static int`	`cuInit(int Flags)`	\brief Initialize the CUDA driver API Initializes the driver API and must be called before any other function from the driver API.
`static int`	`cuIpcCloseMemHandle(long dptr)`	\brief Close memory mapped with ::cuIpcOpenMemHandle Unmaps memory returnd by ::cuIpcOpenMemHandle.
`static int`	`cuIpcGetEventHandle(CUipcEventHandle pHandle, CUevent_st event)`	\brief Gets an interprocess handle for a previously allocated event Takes as input a previously allocated event.
`static int`	`cuIpcGetMemHandle(CUipcMemHandle pHandle, long dptr)`	\brief Gets an interprocess memory handle for an existing device memory allocation Takes a pointer to the base of an existing device memory allocation created with ::cuMemAlloc and exports it for use in another process.
`static int`	`cuIpcOpenEventHandle(CUevent_st phEvent, CUipcEventHandle handle)`	\brief Opens an interprocess event handle for use in the current process Opens an interprocess event handle exported from another process with ::cuIpcGetEventHandle.
`static int`	`cuIpcOpenMemHandle(long[] pdptr, CUipcMemHandle handle, int Flags)`
`static int`	`cuIpcOpenMemHandle(LongBuffer pdptr, CUipcMemHandle handle, int Flags)`
`static int`	`cuIpcOpenMemHandle(LongPointer pdptr, CUipcMemHandle handle, int Flags)`	\brief Opens an interprocess memory handle exported from another process and returns a device pointer usable in the local process.
`static int`	`cuLaunch(CUfunc_st f)`	Deprecated. Invokes the kernel \p f on a 1 x 1 x 1 grid of blocks.
`static int`	`cuLaunchCooperativeKernel(CUfunc_st f, int gridDimX, int gridDimY, int gridDimZ, int blockDimX, int blockDimY, int blockDimZ, int sharedMemBytes, CUstream_st hStream, Pointer kernelParams)`
`static int`	`cuLaunchCooperativeKernel(CUfunc_st f, int gridDimX, int gridDimY, int gridDimZ, int blockDimX, int blockDimY, int blockDimZ, int sharedMemBytes, CUstream_st hStream, PointerPointer kernelParams)`	\brief Launches a CUDA function where thread blocks can cooperate and synchronize as they execute Invokes the kernel \p f on a \p gridDimX x \p gridDimY x \p gridDimZ grid of blocks.
`static int`	`cuLaunchCooperativeKernelMultiDevice(CUDA_LAUNCH_PARAMS launchParamsList, int numDevices, int flags)`	\brief Launches CUDA functions on multiple devices where thread blocks can cooperate and synchronize as they execute Invokes kernels as specified in the \p launchParamsList array where each element of the array specifies all the parameters required to perform a single kernel launch.
`static int`	`cuLaunchGrid(CUfunc_st f, int grid_width, int grid_height)`	Deprecated. Invokes the kernel \p f on a \p grid_width x \p grid_height grid of blocks.
`static int`	`cuLaunchGridAsync(CUfunc_st f, int grid_width, int grid_height, CUstream_st hStream)`	Deprecated. Invokes the kernel \p f on a \p grid_width x \p grid_height grid of blocks.
`static int`	`cuLaunchHostFunc(CUstream_st hStream, CUhostFn fn, Pointer userData)`	\brief Enqueues a host function call in a stream Enqueues a host function to run in a stream.
`static int`	`cuLaunchKernel(CUfunc_st f, int gridDimX, int gridDimY, int gridDimZ, int blockDimX, int blockDimY, int blockDimZ, int sharedMemBytes, CUstream_st hStream, PointerPointer kernelParams, PointerPointer extra)`	\brief Launches a CUDA function Invokes the kernel \p f on a \p gridDimX x \p gridDimY x \p gridDimZ grid of blocks.
`static int`	`cuLaunchKernel(CUfunc_st f, int gridDimX, int gridDimY, int gridDimZ, int blockDimX, int blockDimY, int blockDimZ, int sharedMemBytes, CUstream_st hStream, Pointer kernelParams, Pointer extra)`
`static int`	`cuLinkAddData(CUlinkState_st state, int type, Pointer data, long size, String name, int numOptions, int[] options, Pointer optionValues)`
`static int`	`cuLinkAddData(CUlinkState_st state, int type, Pointer data, long size, String name, int numOptions, IntBuffer options, Pointer optionValues)`
`static int`	`cuLinkAddData(CUlinkState_st state, int type, Pointer data, long size, String name, int numOptions, IntPointer options, Pointer optionValues)`
`static int`	`cuLinkAddData(CUlinkState_st state, int type, Pointer data, long size, BytePointer name, int numOptions, int[] options, Pointer optionValues)`
`static int`	`cuLinkAddData(CUlinkState_st state, int type, Pointer data, long size, BytePointer name, int numOptions, IntBuffer options, Pointer optionValues)`
`static int`	`cuLinkAddData(CUlinkState_st state, int type, Pointer data, long size, BytePointer name, int numOptions, IntPointer options, Pointer optionValues)`
`static int`	`cuLinkAddData(CUlinkState_st state, int type, Pointer data, long size, BytePointer name, int numOptions, IntPointer options, PointerPointer optionValues)`	\brief Add an input to a pending linker invocation Ownership of \p data is retained by the caller.
`static int`	`cuLinkAddFile(CUlinkState_st state, int type, String path, int numOptions, int[] options, Pointer optionValues)`
`static int`	`cuLinkAddFile(CUlinkState_st state, int type, String path, int numOptions, IntBuffer options, Pointer optionValues)`
`static int`	`cuLinkAddFile(CUlinkState_st state, int type, String path, int numOptions, IntPointer options, Pointer optionValues)`
`static int`	`cuLinkAddFile(CUlinkState_st state, int type, BytePointer path, int numOptions, int[] options, Pointer optionValues)`
`static int`	`cuLinkAddFile(CUlinkState_st state, int type, BytePointer path, int numOptions, IntBuffer options, Pointer optionValues)`
`static int`	`cuLinkAddFile(CUlinkState_st state, int type, BytePointer path, int numOptions, IntPointer options, Pointer optionValues)`
`static int`	`cuLinkAddFile(CUlinkState_st state, int type, BytePointer path, int numOptions, IntPointer options, PointerPointer optionValues)`	\brief Add a file input to a pending linker invocation No reference is retained to any inputs after this call returns.
`static int`	`cuLinkComplete(CUlinkState_st state, PointerPointer cubinOut, SizeTPointer sizeOut)`	\brief Complete a pending linker invocation Completes the pending linker action and returns the cubin image for the linked device code, which can be used with ::cuModuleLoadData.
`static int`	`cuLinkComplete(CUlinkState_st state, Pointer cubinOut, SizeTPointer sizeOut)`
`static int`	`cuLinkCreate(int numOptions, int[] options, Pointer optionValues, CUlinkState_st stateOut)`
`static int`	`cuLinkCreate(int numOptions, IntBuffer options, Pointer optionValues, CUlinkState_st stateOut)`
`static int`	`cuLinkCreate(int numOptions, IntPointer options, PointerPointer optionValues, CUlinkState_st stateOut)`	\brief Creates a pending JIT linker invocation.
`static int`	`cuLinkCreate(int numOptions, IntPointer options, Pointer optionValues, CUlinkState_st stateOut)`
`static int`	`cuLinkDestroy(CUlinkState_st state)`	\brief Destroys state for a JIT linker invocation.
`static int`	`cuMemAddressFree(long ptr, long size)`	\brief Free an address range reservation.
`static int`	`cuMemAddressReserve(long[] ptr, long size, long alignment, long addr, long flags)`
`static int`	`cuMemAddressReserve(LongBuffer ptr, long size, long alignment, long addr, long flags)`
`static int`	`cuMemAddressReserve(LongPointer ptr, long size, long alignment, long addr, long flags)`	\brief Allocate an address range reservation.
`static int`	`cuMemAdvise(long devPtr, long count, int advice, int device)`	\brief Advise about the usage of a given memory range Advise the Unified Memory subsystem about the usage pattern for the memory range starting at \p devPtr with a size of \p count bytes.
`static int`	`cuMemAlloc(long[] dptr, long bytesize)`
`static int`	`cuMemAlloc(LongBuffer dptr, long bytesize)`
`static int`	`cuMemAlloc(LongPointer dptr, long bytesize)`	\brief Allocates device memory Allocates \p bytesize bytes of linear memory on the device and returns in \p *dptr a pointer to the allocated memory.
`static int`	`cuMemAllocHost(Pointer pp, long bytesize)`
`static int`	`cuMemAllocHost(PointerPointer pp, long bytesize)`	\brief Allocates page-locked host memory Allocates \p bytesize bytes of host memory that is page-locked and accessible to the device.
`static int`	`cuMemAllocManaged(long[] dptr, long bytesize, int flags)`
`static int`	`cuMemAllocManaged(LongBuffer dptr, long bytesize, int flags)`
`static int`	`cuMemAllocManaged(LongPointer dptr, long bytesize, int flags)`	\brief Allocates memory that will be automatically managed by the Unified Memory system Allocates \p bytesize bytes of managed memory on the device and returns in \p *dptr a pointer to the allocated memory.
`static int`	`cuMemAllocPitch(long[] dptr, SizeTPointer pPitch, long WidthInBytes, long Height, int ElementSizeBytes)`
`static int`	`cuMemAllocPitch(LongBuffer dptr, SizeTPointer pPitch, long WidthInBytes, long Height, int ElementSizeBytes)`
`static int`	`cuMemAllocPitch(LongPointer dptr, SizeTPointer pPitch, long WidthInBytes, long Height, int ElementSizeBytes)`	\brief Allocates pitched device memory Allocates at least \p WidthInBytes * \p Height bytes of linear memory on the device and returns in \p *dptr a pointer to the allocated memory.
`static int`	`cuMemcpy(long dst, long src, long ByteCount)`	\brief Copies memory Copies data between two pointers.
`static int`	`cuMemcpy2D(CUDA_MEMCPY2D pCopy)`	\brief Copies memory for 2D arrays Perform a 2D memory copy according to the parameters specified in \p pCopy.
`static int`	`cuMemcpy2DAsync(CUDA_MEMCPY2D pCopy, CUstream_st hStream)`	\brief Copies memory for 2D arrays Perform a 2D memory copy according to the parameters specified in \p pCopy.
`static int`	`cuMemcpy2DUnaligned(CUDA_MEMCPY2D pCopy)`	\brief Copies memory for 2D arrays Perform a 2D memory copy according to the parameters specified in \p pCopy.
`static int`	`cuMemcpy3D(CUDA_MEMCPY3D pCopy)`	\brief Copies memory for 3D arrays Perform a 3D memory copy according to the parameters specified in \p pCopy.
`static int`	`cuMemcpy3DAsync(CUDA_MEMCPY3D pCopy, CUstream_st hStream)`	\brief Copies memory for 3D arrays Perform a 3D memory copy according to the parameters specified in \p pCopy.
`static int`	`cuMemcpy3DPeer(CUDA_MEMCPY3D_PEER pCopy)`	\brief Copies memory between contexts Perform a 3D memory copy according to the parameters specified in \p pCopy.
`static int`	`cuMemcpy3DPeerAsync(CUDA_MEMCPY3D_PEER pCopy, CUstream_st hStream)`	\brief Copies memory between contexts asynchronously.
`static int`	`cuMemcpyAsync(long dst, long src, long ByteCount, CUstream_st hStream)`	\brief Copies memory asynchronously Copies data between two pointers.
`static int`	`cuMemcpyAtoA(CUarray_st dstArray, long dstOffset, CUarray_st srcArray, long srcOffset, long ByteCount)`	\brief Copies memory from Array to Array Copies from one 1D CUDA array to another.
`static int`	`cuMemcpyAtoD(long dstDevice, CUarray_st srcArray, long srcOffset, long ByteCount)`	\brief Copies memory from Array to Device Copies from one 1D CUDA array to device memory.
`static int`	`cuMemcpyAtoH(Pointer dstHost, CUarray_st srcArray, long srcOffset, long ByteCount)`	\brief Copies memory from Array to Host Copies from one 1D CUDA array to host memory.
`static int`	`cuMemcpyAtoHAsync(Pointer dstHost, CUarray_st srcArray, long srcOffset, long ByteCount, CUstream_st hStream)`	\brief Copies memory from Array to Host Copies from one 1D CUDA array to host memory.
`static int`	`cuMemcpyDtoA(CUarray_st dstArray, long dstOffset, long srcDevice, long ByteCount)`	\brief Copies memory from Device to Array Copies from device memory to a 1D CUDA array.
`static int`	`cuMemcpyDtoD(long dstDevice, long srcDevice, long ByteCount)`	\brief Copies memory from Device to Device Copies from device memory to device memory.
`static int`	`cuMemcpyDtoDAsync(long dstDevice, long srcDevice, long ByteCount, CUstream_st hStream)`	\brief Copies memory from Device to Device Copies from device memory to device memory.
`static int`	`cuMemcpyDtoH(Pointer dstHost, long srcDevice, long ByteCount)`	\brief Copies memory from Device to Host Copies from device to host memory.
`static int`	`cuMemcpyDtoHAsync(Pointer dstHost, long srcDevice, long ByteCount, CUstream_st hStream)`	\brief Copies memory from Device to Host Copies from device to host memory.
`static int`	`cuMemcpyHtoA(CUarray_st dstArray, long dstOffset, Pointer srcHost, long ByteCount)`	\brief Copies memory from Host to Array Copies from host memory to a 1D CUDA array.
`static int`	`cuMemcpyHtoAAsync(CUarray_st dstArray, long dstOffset, Pointer srcHost, long ByteCount, CUstream_st hStream)`	\brief Copies memory from Host to Array Copies from host memory to a 1D CUDA array.
`static int`	`cuMemcpyHtoD(long dstDevice, Pointer srcHost, long ByteCount)`	\brief Copies memory from Host to Device Copies from host memory to device memory.
`static int`	`cuMemcpyHtoDAsync(long dstDevice, Pointer srcHost, long ByteCount, CUstream_st hStream)`	\brief Copies memory from Host to Device Copies from host memory to device memory.
`static int`	`cuMemcpyPeer(long dstDevice, CUctx_st dstContext, long srcDevice, CUctx_st srcContext, long ByteCount)`	\brief Copies device memory between two contexts Copies from device memory in one context to device memory in another context.
`static int`	`cuMemcpyPeerAsync(long dstDevice, CUctx_st dstContext, long srcDevice, CUctx_st srcContext, long ByteCount, CUstream_st hStream)`	\brief Copies device memory between two contexts asynchronously.
`static int`	`cuMemCreate(long[] handle, long size, CUmemAllocationProp prop, long flags)`
`static int`	`cuMemCreate(LongBuffer handle, long size, CUmemAllocationProp prop, long flags)`
`static int`	`cuMemCreate(LongPointer handle, long size, CUmemAllocationProp prop, long flags)`	\brief Create a shareable memory handle representing a memory allocation of a given size described by the given properties This creates a memory allocation on the target device specified through the \p prop strcuture.
`static int`	`cuMemExportToShareableHandle(Pointer shareableHandle, long handle, int handleType, long flags)`	\brief Exports an allocation to a requested shareable handle type Given a CUDA memory handle, create a shareable memory allocation handle that can be used to share the memory with other processes.
`static int`	`cuMemFree(long dptr)`	\brief Frees device memory Frees the memory space pointed to by \p dptr, which must have been returned by a previous call to ::cuMemAlloc() or ::cuMemAllocPitch().
`static int`	`cuMemFreeHost(Pointer p)`	\brief Frees page-locked host memory Frees the memory space pointed to by \p p, which must have been returned by a previous call to ::cuMemAllocHost().
`static int`	`cuMemGetAccess(long[] flags, CUmemLocation location, long ptr)`
`static int`	`cuMemGetAccess(LongBuffer flags, CUmemLocation location, long ptr)`
`static int`	`cuMemGetAccess(LongPointer flags, CUmemLocation location, long ptr)`	\brief Get the access \p flags set for the given \p location and \p ptr
`static int`	`cuMemGetAddressRange(long[] pbase, SizeTPointer psize, long dptr)`
`static int`	`cuMemGetAddressRange(LongBuffer pbase, SizeTPointer psize, long dptr)`
`static int`	`cuMemGetAddressRange(LongPointer pbase, SizeTPointer psize, long dptr)`	\brief Get information on memory allocations Returns the base address in \p pbase and size in \p psize of the allocation by ::cuMemAlloc() or ::cuMemAllocPitch() that contains the input pointer \p dptr.
`static int`	`cuMemGetAllocationGranularity(SizeTPointer granularity, CUmemAllocationProp prop, int option)`	\brief Calculates either the minimal or recommended granularity Calculates either the minimal or recommended granularity for a given allocation specification and returns it in granularity.
`static int`	`cuMemGetAllocationPropertiesFromHandle(CUmemAllocationProp prop, long handle)`	\brief Retrieve the contents of the property structure defining properties for this handle
`static int`	`cuMemGetInfo(SizeTPointer _free, SizeTPointer total)`	\brief Gets free and total memory Returns in \p free and \p total respectively, the free and total amount of memory available for allocation by the CUDA context, in bytes.
`static int`	`cuMemHostAlloc(Pointer pp, long bytesize, int Flags)`
`static int`	`cuMemHostAlloc(PointerPointer pp, long bytesize, int Flags)`	\brief Allocates page-locked host memory Allocates \p bytesize bytes of host memory that is page-locked and accessible to the device.
`static int`	`cuMemHostGetDevicePointer(long[] pdptr, Pointer p, int Flags)`
`static int`	`cuMemHostGetDevicePointer(LongBuffer pdptr, Pointer p, int Flags)`
`static int`	`cuMemHostGetDevicePointer(LongPointer pdptr, Pointer p, int Flags)`	\brief Passes back device pointer of mapped pinned memory Passes back the device pointer \p pdptr corresponding to the mapped, pinned host buffer \p p allocated by ::cuMemHostAlloc.
`static int`	`cuMemHostGetFlags(int[] pFlags, Pointer p)`
`static int`	`cuMemHostGetFlags(IntBuffer pFlags, Pointer p)`
`static int`	`cuMemHostGetFlags(IntPointer pFlags, Pointer p)`	\brief Passes back flags that were used for a pinned allocation Passes back the flags \p pFlags that were specified when allocating the pinned host buffer \p p allocated by ::cuMemHostAlloc.
`static int`	`cuMemHostRegister(Pointer p, long bytesize, int Flags)`	\brief Registers an existing host memory range for use by CUDA Page-locks the memory range specified by \p p and \p bytesize and maps it for the device(s) as specified by \p Flags.
`static int`	`cuMemHostUnregister(Pointer p)`	\brief Unregisters a memory range that was registered with cuMemHostRegister.
`static int`	`cuMemImportFromShareableHandle(long[] handle, Pointer osHandle, int shHandleType)`
`static int`	`cuMemImportFromShareableHandle(LongBuffer handle, Pointer osHandle, int shHandleType)`
`static int`	`cuMemImportFromShareableHandle(LongPointer handle, Pointer osHandle, int shHandleType)`	\brief Imports an allocation from a requested shareable handle type.
`static int`	`cuMemMap(long ptr, long size, long offset, long handle, long flags)`	\brief Maps an allocation handle to a reserved virtual address range.
`static int`	`cuMemPrefetchAsync(long devPtr, long count, int dstDevice, CUstream_st hStream)`	\brief Prefetches memory to the specified destination device Prefetches memory to the specified destination device.
`static int`	`cuMemRelease(long handle)`	\brief Release a memory handle representing a memory allocation which was previously allocated through cuMemCreate.
`static int`	`cuMemSetAccess(long ptr, long size, CUmemAccessDesc desc, long count)`	\brief Set the access flags for each location specified in \p desc for the given virtual address range Given the virtual address range via \p ptr and \p size, and the locations in the array given by \p desc and \p count, set the access flags for the target locations.
`static int`	`cuMemsetD16(long dstDevice, short us, long N)`	\brief Initializes device memory Sets the memory range of \p N 16-bit values to the specified value \p us.
`static int`	`cuMemsetD16Async(long dstDevice, short us, long N, CUstream_st hStream)`	\brief Sets device memory Sets the memory range of \p N 16-bit values to the specified value \p us.
`static int`	`cuMemsetD2D16(long dstDevice, long dstPitch, short us, long Width, long Height)`	\brief Initializes device memory Sets the 2D memory range of \p Width 16-bit values to the specified value \p us.
`static int`	`cuMemsetD2D16Async(long dstDevice, long dstPitch, short us, long Width, long Height, CUstream_st hStream)`	\brief Sets device memory Sets the 2D memory range of \p Width 16-bit values to the specified value \p us.
`static int`	`cuMemsetD2D32(long dstDevice, long dstPitch, int ui, long Width, long Height)`	\brief Initializes device memory Sets the 2D memory range of \p Width 32-bit values to the specified value \p ui.
`static int`	`cuMemsetD2D32Async(long dstDevice, long dstPitch, int ui, long Width, long Height, CUstream_st hStream)`	\brief Sets device memory Sets the 2D memory range of \p Width 32-bit values to the specified value \p ui.
`static int`	`cuMemsetD2D8(long dstDevice, long dstPitch, byte uc, long Width, long Height)`	\brief Initializes device memory Sets the 2D memory range of \p Width 8-bit values to the specified value \p uc.
`static int`	`cuMemsetD2D8Async(long dstDevice, long dstPitch, byte uc, long Width, long Height, CUstream_st hStream)`	\brief Sets device memory Sets the 2D memory range of \p Width 8-bit values to the specified value \p uc.
`static int`	`cuMemsetD32(long dstDevice, int ui, long N)`	\brief Initializes device memory Sets the memory range of \p N 32-bit values to the specified value \p ui.
`static int`	`cuMemsetD32Async(long dstDevice, int ui, long N, CUstream_st hStream)`	\brief Sets device memory Sets the memory range of \p N 32-bit values to the specified value \p ui.
`static int`	`cuMemsetD8(long dstDevice, byte uc, long N)`	\brief Initializes device memory Sets the memory range of \p N 8-bit values to the specified value \p uc.
`static int`	`cuMemsetD8Async(long dstDevice, byte uc, long N, CUstream_st hStream)`	\brief Sets device memory Sets the memory range of \p N 8-bit values to the specified value \p uc.
`static int`	`cuMemUnmap(long ptr, long size)`	\brief Unmap the backing memory of a given address range.
`static int`	`cuMipmappedArrayCreate(CUmipmappedArray_st pHandle, CUDA_ARRAY3D_DESCRIPTOR pMipmappedArrayDesc, int numMipmapLevels)`	\brief Creates a CUDA mipmapped array Creates a CUDA mipmapped array according to the ::CUDA_ARRAY3D_DESCRIPTOR structure \p pMipmappedArrayDesc and returns a handle to the new CUDA mipmapped array in \p *pHandle.
`static int`	`cuMipmappedArrayDestroy(CUmipmappedArray_st hMipmappedArray)`	\brief Destroys a CUDA mipmapped array Destroys the CUDA mipmapped array \p hMipmappedArray.
`static int`	`cuMipmappedArrayGetLevel(CUarray_st pLevelArray, CUmipmappedArray_st hMipmappedArray, int level)`	\brief Gets a mipmap level of a CUDA mipmapped array Returns in \p *pLevelArray a CUDA array that represents a single mipmap level of the CUDA mipmapped array \p hMipmappedArray.
`static int`	`cuModuleGetFunction(CUfunc_st hfunc, CUmod_st hmod, String name)`
`static int`	`cuModuleGetFunction(CUfunc_st hfunc, CUmod_st hmod, BytePointer name)`	\brief Returns a function handle Returns in \p *hfunc the handle of the function of name \p name located in module \p hmod.
`static int`	`cuModuleGetGlobal(long[] dptr, SizeTPointer bytes, CUmod_st hmod, String name)`
`static int`	`cuModuleGetGlobal(long[] dptr, SizeTPointer bytes, CUmod_st hmod, BytePointer name)`
`static int`	`cuModuleGetGlobal(LongBuffer dptr, SizeTPointer bytes, CUmod_st hmod, String name)`
`static int`	`cuModuleGetGlobal(LongBuffer dptr, SizeTPointer bytes, CUmod_st hmod, BytePointer name)`
`static int`	`cuModuleGetGlobal(LongPointer dptr, SizeTPointer bytes, CUmod_st hmod, String name)`
`static int`	`cuModuleGetGlobal(LongPointer dptr, SizeTPointer bytes, CUmod_st hmod, BytePointer name)`	\brief Returns a global pointer from a module Returns in \p dptr and \p bytes the base pointer and size of the global of name \p name located in module \p hmod.
`static int`	`cuModuleGetSurfRef(CUsurfref_st pSurfRef, CUmod_st hmod, String name)`
`static int`	`cuModuleGetSurfRef(CUsurfref_st pSurfRef, CUmod_st hmod, BytePointer name)`	\brief Returns a handle to a surface reference Returns in \p *pSurfRef the handle of the surface reference of name \p name in the module \p hmod.
`static int`	`cuModuleGetTexRef(CUtexref_st pTexRef, CUmod_st hmod, String name)`
`static int`	`cuModuleGetTexRef(CUtexref_st pTexRef, CUmod_st hmod, BytePointer name)`	\brief Returns a handle to a texture reference Returns in \p *pTexRef the handle of the texture reference of name \p name in the module \p hmod.
`static int`	`cuModuleLoad(CUmod_st module, String fname)`
`static int`	`cuModuleLoad(CUmod_st module, BytePointer fname)`	\brief Loads a compute module Takes a filename \p fname and loads the corresponding module \p module into the current context.
`static int`	`cuModuleLoadData(CUmod_st module, Pointer image)`	\brief Load a module's data Takes a pointer \p image and loads the corresponding module \p module into the current context.
`static int`	`cuModuleLoadDataEx(CUmod_st module, Pointer image, int numOptions, int[] options, Pointer optionValues)`
`static int`	`cuModuleLoadDataEx(CUmod_st module, Pointer image, int numOptions, IntBuffer options, Pointer optionValues)`
`static int`	`cuModuleLoadDataEx(CUmod_st module, Pointer image, int numOptions, IntPointer options, Pointer optionValues)`
`static int`	`cuModuleLoadDataEx(CUmod_st module, Pointer image, int numOptions, IntPointer options, PointerPointer optionValues)`	\brief Load a module's data with options Takes a pointer \p image and loads the corresponding module \p module into the current context.
`static int`	`cuModuleLoadFatBinary(CUmod_st module, Pointer fatCubin)`	\brief Load a module's data Takes a pointer \p fatCubin and loads the corresponding module \p module into the current context.
`static int`	`cuModuleUnload(CUmod_st hmod)`	\brief Unloads a module Unloads a module \p hmod from the current context.
`static int`	`cuOccupancyMaxActiveBlocksPerMultiprocessor(int[] numBlocks, CUfunc_st func, int blockSize, long dynamicSMemSize)`
`static int`	`cuOccupancyMaxActiveBlocksPerMultiprocessor(IntBuffer numBlocks, CUfunc_st func, int blockSize, long dynamicSMemSize)`
`static int`	`cuOccupancyMaxActiveBlocksPerMultiprocessor(IntPointer numBlocks, CUfunc_st func, int blockSize, long dynamicSMemSize)`	\brief Returns occupancy of a function Returns in \p *numBlocks the number of the maximum active blocks per streaming multiprocessor.
`static int`	`cuOccupancyMaxActiveBlocksPerMultiprocessorWithFlags(int[] numBlocks, CUfunc_st func, int blockSize, long dynamicSMemSize, int flags)`
`static int`	`cuOccupancyMaxActiveBlocksPerMultiprocessorWithFlags(IntBuffer numBlocks, CUfunc_st func, int blockSize, long dynamicSMemSize, int flags)`
`static int`	`cuOccupancyMaxActiveBlocksPerMultiprocessorWithFlags(IntPointer numBlocks, CUfunc_st func, int blockSize, long dynamicSMemSize, int flags)`	\brief Returns occupancy of a function Returns in \p *numBlocks the number of the maximum active blocks per streaming multiprocessor.
`static int`	`cuOccupancyMaxPotentialBlockSize(int[] minGridSize, int[] blockSize, CUfunc_st func, CUoccupancyB2DSize blockSizeToDynamicSMemSize, long dynamicSMemSize, int blockSizeLimit)`
`static int`	`cuOccupancyMaxPotentialBlockSize(IntBuffer minGridSize, IntBuffer blockSize, CUfunc_st func, CUoccupancyB2DSize blockSizeToDynamicSMemSize, long dynamicSMemSize, int blockSizeLimit)`
`static int`	`cuOccupancyMaxPotentialBlockSize(IntPointer minGridSize, IntPointer blockSize, CUfunc_st func, CUoccupancyB2DSize blockSizeToDynamicSMemSize, long dynamicSMemSize, int blockSizeLimit)`	\brief Suggest a launch configuration with reasonable occupancy Returns in \p blockSize a reasonable block size that can achieve the maximum occupancy (or, the maximum number of active warps with the fewest blocks per multiprocessor), and in \p minGridSize the minimum grid size to achieve the maximum occupancy.
`static int`	`cuOccupancyMaxPotentialBlockSizeWithFlags(int[] minGridSize, int[] blockSize, CUfunc_st func, CUoccupancyB2DSize blockSizeToDynamicSMemSize, long dynamicSMemSize, int blockSizeLimit, int flags)`
`static int`	`cuOccupancyMaxPotentialBlockSizeWithFlags(IntBuffer minGridSize, IntBuffer blockSize, CUfunc_st func, CUoccupancyB2DSize blockSizeToDynamicSMemSize, long dynamicSMemSize, int blockSizeLimit, int flags)`
`static int`	`cuOccupancyMaxPotentialBlockSizeWithFlags(IntPointer minGridSize, IntPointer blockSize, CUfunc_st func, CUoccupancyB2DSize blockSizeToDynamicSMemSize, long dynamicSMemSize, int blockSizeLimit, int flags)`	\brief Suggest a launch configuration with reasonable occupancy An extended version of ::cuOccupancyMaxPotentialBlockSize.
`static int`	`cuParamSetf(CUfunc_st hfunc, int offset, float value)`	Deprecated. Sets a floating-point parameter that will be specified the next time the kernel corresponding to \p hfunc will be invoked.
`static int`	`cuParamSeti(CUfunc_st hfunc, int offset, int value)`	Deprecated. Sets an integer parameter that will be specified the next time the kernel corresponding to \p hfunc will be invoked.
`static int`	`cuParamSetSize(CUfunc_st hfunc, int numbytes)`	Deprecated. Sets through \p numbytes the total size in bytes needed by the function parameters of the kernel corresponding to \p hfunc.
`static int`	`cuParamSetTexRef(CUfunc_st hfunc, int texunit, CUtexref_st hTexRef)`	Deprecated. Makes the CUDA array or linear memory bound to the texture reference \p hTexRef available to a device program as a texture.
`static int`	`cuParamSetv(CUfunc_st hfunc, int offset, Pointer ptr, int numbytes)`	Deprecated. Copies an arbitrary amount of data (specified in \p numbytes) from \p ptr into the parameter space of the kernel corresponding to \p hfunc.
`static int`	`cuPointerGetAttribute(Pointer data, int attribute, long ptr)`	\brief Returns information about a pointer The supported attributes are: - ::CU_POINTER_ATTRIBUTE_CONTEXT: Returns in \p *data the ::CUcontext in which \p ptr was allocated or registered.
`static int`	`cuPointerGetAttributes(int numAttributes, int[] attributes, Pointer data, long ptr)`
`static int`	`cuPointerGetAttributes(int numAttributes, IntBuffer attributes, Pointer data, long ptr)`
`static int`	`cuPointerGetAttributes(int numAttributes, IntPointer attributes, Pointer data, long ptr)`
`static int`	`cuPointerGetAttributes(int numAttributes, IntPointer attributes, PointerPointer data, long ptr)`	\brief Returns information about a pointer.
`static int`	`cuPointerSetAttribute(Pointer value, int attribute, long ptr)`	\brief Set attributes on a previously allocated memory region The supported attributes are: - ::CU_POINTER_ATTRIBUTE_SYNC_MEMOPS: A boolean attribute that can either be set (1) or unset (0).
`static int`	`cuSignalExternalSemaphoresAsync(CUextSemaphore_st extSemArray, CUDA_EXTERNAL_SEMAPHORE_SIGNAL_PARAMS paramsArray, int numExtSems, CUstream_st stream)`	\brief Signals a set of external semaphore objects Enqueues a signal operation on a set of externally allocated semaphore object in the specified stream.
`static int`	`cuStreamAddCallback(CUstream_st hStream, CUstreamCallback callback, Pointer userData, int flags)`	\brief Add a callback to a compute stream \note This function is slated for eventual deprecation and removal.
`static int`	`cuStreamAttachMemAsync(CUstream_st hStream, long dptr, long length, int flags)`	\brief Attach memory to a stream asynchronously Enqueues an operation in \p hStream to specify stream association of \p length bytes of memory starting from \p dptr.
`static int`	`cuStreamBatchMemOp(CUstream_st stream, int count, CUstreamBatchMemOpParams paramArray, int flags)`	\brief Batch operations to synchronize the stream via memory operations This is a batch version of ::cuStreamWaitValue32() and ::cuStreamWriteValue32().
`static int`	`cuStreamBeginCapture(CUstream_st hStream, int mode)`	\brief Begins graph capture on a stream Begin graph capture on \p hStream.
`static int`	`cuStreamCreate(CUstream_st phStream, int Flags)`	\brief Create a stream Creates a stream and returns a handle in \p phStream.
`static int`	`cuStreamCreateWithPriority(CUstream_st phStream, int flags, int priority)`	\brief Create a stream with the given priority Creates a stream with the specified priority and returns a handle in \p phStream.
`static int`	`cuStreamDestroy(CUstream_st hStream)`	\brief Destroys a stream Destroys the stream specified by \p hStream.
`static int`	`cuStreamEndCapture(CUstream_st hStream, CUgraph_st phGraph)`	\brief Ends capture on a stream, returning the captured graph End capture on \p hStream, returning the captured graph via \p phGraph.
`static int`	`cuStreamGetCaptureInfo(CUstream_st hStream, int[] captureStatus, int[] id)`
`static int`	`cuStreamGetCaptureInfo(CUstream_st hStream, IntBuffer captureStatus, IntBuffer id)`
`static int`	`cuStreamGetCaptureInfo(CUstream_st hStream, IntPointer captureStatus, IntPointer id)`	\brief Query capture status of a stream Query the capture status of a stream and and get an id for the capture sequence, which is unique over the lifetime of the process.
`static int`	`cuStreamGetCtx(CUstream_st hStream, CUctx_st pctx)`	\brief Query the context associated with a stream Returns the CUDA context that the stream is associated with.
`static int`	`cuStreamGetFlags(CUstream_st hStream, int[] flags)`
`static int`	`cuStreamGetFlags(CUstream_st hStream, IntBuffer flags)`
`static int`	`cuStreamGetFlags(CUstream_st hStream, IntPointer flags)`	\brief Query the flags of a given stream Query the flags of a stream created using ::cuStreamCreate or ::cuStreamCreateWithPriority and return the flags in \p flags.
`static int`	`cuStreamGetPriority(CUstream_st hStream, int[] priority)`
`static int`	`cuStreamGetPriority(CUstream_st hStream, IntBuffer priority)`
`static int`	`cuStreamGetPriority(CUstream_st hStream, IntPointer priority)`	\brief Query the priority of a given stream Query the priority of a stream created using ::cuStreamCreate or ::cuStreamCreateWithPriority and return the priority in \p priority.
`static int`	`cuStreamIsCapturing(CUstream_st hStream, int[] captureStatus)`
`static int`	`cuStreamIsCapturing(CUstream_st hStream, IntBuffer captureStatus)`
`static int`	`cuStreamIsCapturing(CUstream_st hStream, IntPointer captureStatus)`	\brief Returns a stream's capture status Return the capture status of \p hStream via \p captureStatus.
`static int`	`cuStreamQuery(CUstream_st hStream)`	\brief Determine status of a compute stream Returns ::CUDA_SUCCESS if all operations in the stream specified by \p hStream have completed, or ::CUDA_ERROR_NOT_READY if not.
`static int`	`cuStreamSynchronize(CUstream_st hStream)`	\brief Wait until a stream's tasks are completed Waits until the device has completed all operations in the stream specified by \p hStream.
`static int`	`cuStreamWaitEvent(CUstream_st hStream, CUevent_st hEvent, int Flags)`	\brief Make a compute stream wait on an event Makes all future work submitted to \p hStream wait for all work captured in \p hEvent.
`static int`	`cuStreamWaitValue32(CUstream_st stream, long addr, int value, int flags)`	\brief Wait on a memory location Enqueues a synchronization of the stream on the given memory location.
`static int`	`cuStreamWaitValue64(CUstream_st stream, long addr, int value, int flags)`	\brief Wait on a memory location Enqueues a synchronization of the stream on the given memory location.
`static int`	`cuStreamWriteValue32(CUstream_st stream, long addr, int value, int flags)`	\brief Write a value to memory Write a value to memory.
`static int`	`cuStreamWriteValue64(CUstream_st stream, long addr, int value, int flags)`	\brief Write a value to memory Write a value to memory.
`static int`	`cuSurfObjectCreate(long[] pSurfObject, CUDA_RESOURCE_DESC pResDesc)`
`static int`	`cuSurfObjectCreate(LongBuffer pSurfObject, CUDA_RESOURCE_DESC pResDesc)`
`static int`	`cuSurfObjectCreate(LongPointer pSurfObject, CUDA_RESOURCE_DESC pResDesc)`	\brief Creates a surface object Creates a surface object and returns it in \p pSurfObject.
`static int`	`cuSurfObjectDestroy(long surfObject)`	\brief Destroys a surface object Destroys the surface object specified by \p surfObject.
`static int`	`cuSurfObjectGetResourceDesc(CUDA_RESOURCE_DESC pResDesc, long surfObject)`	\brief Returns a surface object's resource descriptor Returns the resource descriptor for the surface object specified by \p surfObject.
`static int`	`cuSurfRefGetArray(CUarray_st phArray, CUsurfref_st hSurfRef)`	Deprecated. Returns in \p *phArray the CUDA array bound to the surface reference \p hSurfRef, or returns ::CUDA_ERROR_INVALID_VALUE if the surface reference is not bound to any CUDA array.
`static int`	`cuSurfRefSetArray(CUsurfref_st hSurfRef, CUarray_st hArray, int Flags)`	Deprecated. Sets the CUDA array \p hArray to be read and written by the surface reference \p hSurfRef.
`static int`	`cuTexObjectCreate(long[] pTexObject, CUDA_RESOURCE_DESC pResDesc, CUDA_TEXTURE_DESC pTexDesc, CUDA_RESOURCE_VIEW_DESC pResViewDesc)`
`static int`	`cuTexObjectCreate(LongBuffer pTexObject, CUDA_RESOURCE_DESC pResDesc, CUDA_TEXTURE_DESC pTexDesc, CUDA_RESOURCE_VIEW_DESC pResViewDesc)`
`static int`	`cuTexObjectCreate(LongPointer pTexObject, CUDA_RESOURCE_DESC pResDesc, CUDA_TEXTURE_DESC pTexDesc, CUDA_RESOURCE_VIEW_DESC pResViewDesc)`	\brief Creates a texture object Creates a texture object and returns it in \p pTexObject.
`static int`	`cuTexObjectDestroy(long texObject)`	\brief Destroys a texture object Destroys the texture object specified by \p texObject.
`static int`	`cuTexObjectGetResourceDesc(CUDA_RESOURCE_DESC pResDesc, long texObject)`	\brief Returns a texture object's resource descriptor Returns the resource descriptor for the texture object specified by \p texObject.
`static int`	`cuTexObjectGetResourceViewDesc(CUDA_RESOURCE_VIEW_DESC pResViewDesc, long texObject)`	\brief Returns a texture object's resource view descriptor Returns the resource view descriptor for the texture object specified by \p texObject.
`static int`	`cuTexObjectGetTextureDesc(CUDA_TEXTURE_DESC pTexDesc, long texObject)`	\brief Returns a texture object's texture descriptor Returns the texture descriptor for the texture object specified by \p texObject.
`static int`	`cuTexRefCreate(CUtexref_st pTexRef)`	Deprecated. Creates a texture reference and returns its handle in \p *pTexRef.
`static int`	`cuTexRefDestroy(CUtexref_st hTexRef)`	Deprecated. Destroys the texture reference specified by \p hTexRef.
`static int`	`cuTexRefGetAddress(long[] pdptr, CUtexref_st hTexRef)`
`static int`	`cuTexRefGetAddress(LongBuffer pdptr, CUtexref_st hTexRef)`
`static int`	`cuTexRefGetAddress(LongPointer pdptr, CUtexref_st hTexRef)`	Deprecated. Returns in \p *pdptr the base address bound to the texture reference \p hTexRef, or returns ::CUDA_ERROR_INVALID_VALUE if the texture reference is not bound to any device memory range.
`static int`	`cuTexRefGetAddressMode(int[] pam, CUtexref_st hTexRef, int dim)`
`static int`	`cuTexRefGetAddressMode(IntBuffer pam, CUtexref_st hTexRef, int dim)`
`static int`	`cuTexRefGetAddressMode(IntPointer pam, CUtexref_st hTexRef, int dim)`	Deprecated. Returns in \p *pam the addressing mode corresponding to the dimension \p dim of the texture reference \p hTexRef.
`static int`	`cuTexRefGetArray(CUarray_st phArray, CUtexref_st hTexRef)`	Deprecated. Returns in \p *phArray the CUDA array bound to the texture reference \p hTexRef, or returns ::CUDA_ERROR_INVALID_VALUE if the texture reference is not bound to any CUDA array.
`static int`	`cuTexRefGetBorderColor(float[] pBorderColor, CUtexref_st hTexRef)`
`static int`	`cuTexRefGetBorderColor(FloatBuffer pBorderColor, CUtexref_st hTexRef)`
`static int`	`cuTexRefGetBorderColor(FloatPointer pBorderColor, CUtexref_st hTexRef)`	Deprecated. Returns in \p pBorderColor, values of the RGBA color used by the texture reference \p hTexRef.
`static int`	`cuTexRefGetFilterMode(int[] pfm, CUtexref_st hTexRef)`
`static int`	`cuTexRefGetFilterMode(IntBuffer pfm, CUtexref_st hTexRef)`
`static int`	`cuTexRefGetFilterMode(IntPointer pfm, CUtexref_st hTexRef)`	Deprecated. Returns in \p *pfm the filtering mode of the texture reference \p hTexRef.
`static int`	`cuTexRefGetFlags(int[] pFlags, CUtexref_st hTexRef)`
`static int`	`cuTexRefGetFlags(IntBuffer pFlags, CUtexref_st hTexRef)`
`static int`	`cuTexRefGetFlags(IntPointer pFlags, CUtexref_st hTexRef)`	Deprecated. Returns in \p *pFlags the flags of the texture reference \p hTexRef.
`static int`	`cuTexRefGetFormat(int[] pFormat, int[] pNumChannels, CUtexref_st hTexRef)`
`static int`	`cuTexRefGetFormat(IntBuffer pFormat, IntBuffer pNumChannels, CUtexref_st hTexRef)`
`static int`	`cuTexRefGetFormat(IntPointer pFormat, IntPointer pNumChannels, CUtexref_st hTexRef)`	Deprecated. Returns in \p pFormat and \p pNumChannels the format and number of components of the CUDA array bound to the texture reference \p hTexRef.
`static int`	`cuTexRefGetMaxAnisotropy(int[] pmaxAniso, CUtexref_st hTexRef)`
`static int`	`cuTexRefGetMaxAnisotropy(IntBuffer pmaxAniso, CUtexref_st hTexRef)`
`static int`	`cuTexRefGetMaxAnisotropy(IntPointer pmaxAniso, CUtexref_st hTexRef)`	Deprecated. Returns the maximum anisotropy in \p pmaxAniso that's used when reading memory through the texture reference \p hTexRef.
`static int`	`cuTexRefGetMipmapFilterMode(int[] pfm, CUtexref_st hTexRef)`
`static int`	`cuTexRefGetMipmapFilterMode(IntBuffer pfm, CUtexref_st hTexRef)`
`static int`	`cuTexRefGetMipmapFilterMode(IntPointer pfm, CUtexref_st hTexRef)`	Deprecated. Returns the mipmap filtering mode in \p pfm that's used when reading memory through the texture reference \p hTexRef.
`static int`	`cuTexRefGetMipmapLevelBias(float[] pbias, CUtexref_st hTexRef)`
`static int`	`cuTexRefGetMipmapLevelBias(FloatBuffer pbias, CUtexref_st hTexRef)`
`static int`	`cuTexRefGetMipmapLevelBias(FloatPointer pbias, CUtexref_st hTexRef)`	Deprecated. Returns the mipmap level bias in \p pBias that's added to the specified mipmap level when reading memory through the texture reference \p hTexRef.
`static int`	`cuTexRefGetMipmapLevelClamp(float[] pminMipmapLevelClamp, float[] pmaxMipmapLevelClamp, CUtexref_st hTexRef)`
`static int`	`cuTexRefGetMipmapLevelClamp(FloatBuffer pminMipmapLevelClamp, FloatBuffer pmaxMipmapLevelClamp, CUtexref_st hTexRef)`
`static int`	`cuTexRefGetMipmapLevelClamp(FloatPointer pminMipmapLevelClamp, FloatPointer pmaxMipmapLevelClamp, CUtexref_st hTexRef)`	Deprecated. Returns the min/max mipmap level clamps in \p pminMipmapLevelClamp and \p pmaxMipmapLevelClamp that's used when reading memory through the texture reference \p hTexRef.
`static int`	`cuTexRefGetMipmappedArray(CUmipmappedArray_st phMipmappedArray, CUtexref_st hTexRef)`	Deprecated. Returns in \p *phMipmappedArray the CUDA mipmapped array bound to the texture reference \p hTexRef, or returns ::CUDA_ERROR_INVALID_VALUE if the texture reference is not bound to any CUDA mipmapped array.
`static int`	`cuTexRefSetAddress(SizeTPointer ByteOffset, CUtexref_st hTexRef, long dptr, long bytes)`	Deprecated. Binds a linear address range to the texture reference \p hTexRef.
`static int`	`cuTexRefSetAddress2D(CUtexref_st hTexRef, CUDA_ARRAY_DESCRIPTOR desc, long dptr, long Pitch)`	Deprecated. Binds a linear address range to the texture reference \p hTexRef.
`static int`	`cuTexRefSetAddressMode(CUtexref_st hTexRef, int dim, int am)`	Deprecated. Specifies the addressing mode \p am for the given dimension \p dim of the texture reference \p hTexRef.
`static int`	`cuTexRefSetArray(CUtexref_st hTexRef, CUarray_st hArray, int Flags)`	Deprecated. Binds the CUDA array \p hArray to the texture reference \p hTexRef.
`static int`	`cuTexRefSetBorderColor(CUtexref_st hTexRef, float[] pBorderColor)`
`static int`	`cuTexRefSetBorderColor(CUtexref_st hTexRef, FloatBuffer pBorderColor)`
`static int`	`cuTexRefSetBorderColor(CUtexref_st hTexRef, FloatPointer pBorderColor)`	Deprecated. Specifies the value of the RGBA color via the \p pBorderColor to the texture reference \p hTexRef.
`static int`	`cuTexRefSetFilterMode(CUtexref_st hTexRef, int fm)`	Deprecated. Specifies the filtering mode \p fm to be used when reading memory through the texture reference \p hTexRef.
`static int`	`cuTexRefSetFlags(CUtexref_st hTexRef, int Flags)`	Deprecated. Specifies optional flags via \p Flags to specify the behavior of data returned through the texture reference \p hTexRef.
`static int`	`cuTexRefSetFormat(CUtexref_st hTexRef, int fmt, int NumPackedComponents)`	Deprecated. Specifies the format of the data to be read by the texture reference \p hTexRef.
`static int`	`cuTexRefSetMaxAnisotropy(CUtexref_st hTexRef, int maxAniso)`	Deprecated. Specifies the maximum anisotropy \p maxAniso to be used when reading memory through the texture reference \p hTexRef.
`static int`	`cuTexRefSetMipmapFilterMode(CUtexref_st hTexRef, int fm)`	Deprecated. Specifies the mipmap filtering mode \p fm to be used when reading memory through the texture reference \p hTexRef.
`static int`	`cuTexRefSetMipmapLevelBias(CUtexref_st hTexRef, float bias)`	Deprecated. Specifies the mipmap level bias \p bias to be added to the specified mipmap level when reading memory through the texture reference \p hTexRef.
`static int`	`cuTexRefSetMipmapLevelClamp(CUtexref_st hTexRef, float minMipmapLevelClamp, float maxMipmapLevelClamp)`	Deprecated. Specifies the min/max mipmap level clamps, \p minMipmapLevelClamp and \p maxMipmapLevelClamp respectively, to be used when reading memory through the texture reference \p hTexRef.
`static int`	`cuTexRefSetMipmappedArray(CUtexref_st hTexRef, CUmipmappedArray_st hMipmappedArray, int Flags)`	Deprecated. Binds the CUDA mipmapped array \p hMipmappedArray to the texture reference \p hTexRef.
`static int`	`cuThreadExchangeStreamCaptureMode(int[] mode)`
`static int`	`cuThreadExchangeStreamCaptureMode(IntBuffer mode)`
`static int`	`cuThreadExchangeStreamCaptureMode(IntPointer mode)`	\brief Swaps the stream capture interaction mode for a thread Sets the calling thread's stream capture interaction mode to the value contained in \p mode, and overwrites \p mode with the previous mode for the thread.
`static int`	`cuWaitExternalSemaphoresAsync(CUextSemaphore_st extSemArray, CUDA_EXTERNAL_SEMAPHORE_WAIT_PARAMS paramsArray, int numExtSems, CUstream_st stream)`	\brief Waits on a set of external semaphore objects Enqueues a wait operation on a set of externally allocated semaphore object in the specified stream.
`static char1`	`make_char1(byte x)`	* * *
`static char2`	`make_char2(byte x, byte y)`
`static char3`	`make_char3(byte x, byte y, byte z)`
`static char4`	`make_char4(byte x, byte y, byte z, byte w)`
`static float2`	`make_cuComplex(float x, float y)`
`static cudaExtent`	`make_cudaExtent(long w, long h, long d)`	\brief Returns a cudaExtent based on input parameters Returns a ::cudaExtent based on the specified input parameters \p w, \p h, and \p d.
`static cudaPitchedPtr`	`make_cudaPitchedPtr(Pointer d, long p, long xsz, long ysz)`	\brief Returns a cudaPitchedPtr based on input parameters Returns a ::cudaPitchedPtr based on the specified input parameters \p d, \p p, \p xsz, and \p ysz.
`static cudaPos`	`make_cudaPos(long x, long y, long z)`	\brief Returns a cudaPos based on input parameters Returns a ::cudaPos based on the specified input parameters \p x, \p y, and \p z.
`static double2`	`make_cuDoubleComplex(double r, double i)`
`static float2`	`make_cuFloatComplex(float r, float i)`
`static double1`	`make_double1(double x)`
`static double2`	`make_double2(double x, double y)`
`static double3`	`make_double3(double x, double y, double z)`
`static double4`	`make_double4(double x, double y, double z, double w)`
`static float1`	`make_float1(float x)`
`static float2`	`make_float2(float x, float y)`
`static float3`	`make_float3(float x, float y, float z)`
`static float4`	`make_float4(float x, float y, float z, float w)`
`static int1`	`make_int1(int x)`
`static int2`	`make_int2(int x, int y)`
`static int3`	`make_int3(int x, int y, int z)`
`static int4`	`make_int4(int x, int y, int z, int w)`
`static long1`	`make_long1(long x)`
`static long2`	`make_long2(long x, long y)`
`static long3`	`make_long3(long x, long y, long z)`
`static long4`	`make_long4(long x, long y, long z, long w)`
`static longlong1`	`make_longlong1(long x)`
`static longlong2`	`make_longlong2(long x, long y)`
`static longlong3`	`make_longlong3(long x, long y, long z)`
`static longlong4`	`make_longlong4(long x, long y, long z, long w)`
`static short1`	`make_short1(short x)`
`static short2`	`make_short2(short x, short y)`
`static short3`	`make_short3(short x, short y, short z)`
`static short4`	`make_short4(short x, short y, short z, short w)`
`static uchar1`	`make_uchar1(byte x)`
`static uchar2`	`make_uchar2(byte x, byte y)`
`static uchar3`	`make_uchar3(byte x, byte y, byte z)`
`static uchar4`	`make_uchar4(byte x, byte y, byte z, byte w)`
`static uint1`	`make_uint1(int x)`
`static uint2`	`make_uint2(int x, int y)`
`static uint3`	`make_uint3(int x, int y, int z)`
`static uint4`	`make_uint4(int x, int y, int z, int w)`
`static ulong1`	`make_ulong1(long x)`
`static ulong2`	`make_ulong2(long x, long y)`
`static ulong3`	`make_ulong3(long x, long y, long z)`
`static ulong4`	`make_ulong4(long x, long y, long z, long w)`
`static ulonglong1`	`make_ulonglong1(long x)`
`static ulonglong2`	`make_ulonglong2(long x, long y)`
`static ulonglong3`	`make_ulonglong3(long x, long y, long z)`
`static ulonglong4`	`make_ulonglong4(long x, long y, long z, long w)`
`static ushort1`	`make_ushort1(short x)`
`static ushort2`	`make_ushort2(short x, short y)`
`static ushort3`	`make_ushort3(short x, short y, short z)`
`static ushort4`	`make_ushort4(short x, short y, short z, short w)`

Methods inherited from class org.bytedeco.cuda.presets.cudart
map

Methods inherited from class java.lang.Object
clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

Field Detail
- __CUDA_API_VERSION
```
public static final int __CUDA_API_VERSION
```
  CUDA API versioning support
  
  See Also:
  
  Constant Field Values
- CUDA_VERSION
```
public static final int CUDA_VERSION
```
  CUDA API version number
  
  See Also:
  
  Constant Field Values
- CU_IPC_HANDLE_SIZE
```
public static final int CU_IPC_HANDLE_SIZE
```
  CUDA IPC handle size
  
  See Also:
  
  Constant Field Values
- CU_IPC_MEM_LAZY_ENABLE_PEER_ACCESS
```
public static final int CU_IPC_MEM_LAZY_ENABLE_PEER_ACCESS
```
  enum CUipcMem_flags
  
  See Also:
  
  Constant Field Values
- CU_MEM_ATTACH_GLOBAL
```
public static final int CU_MEM_ATTACH_GLOBAL
```
  enum CUmemAttach_flags
  
  See Also:
  
  Constant Field Values
- CU_MEM_ATTACH_HOST
```
public static final int CU_MEM_ATTACH_HOST
```
  enum CUmemAttach_flags
  
  See Also:
  
  Constant Field Values
- CU_MEM_ATTACH_SINGLE
```
public static final int CU_MEM_ATTACH_SINGLE
```
  enum CUmemAttach_flags
  
  See Also:
  
  Constant Field Values
- CU_CTX_SCHED_AUTO
```
public static final int CU_CTX_SCHED_AUTO
```
  enum CUctx_flags
  
  See Also:
  
  Constant Field Values
- CU_CTX_SCHED_SPIN
```
public static final int CU_CTX_SCHED_SPIN
```
  enum CUctx_flags
  
  See Also:
  
  Constant Field Values
- CU_CTX_SCHED_YIELD
```
public static final int CU_CTX_SCHED_YIELD
```
  enum CUctx_flags
  
  See Also:
  
  Constant Field Values
- CU_CTX_SCHED_BLOCKING_SYNC
```
public static final int CU_CTX_SCHED_BLOCKING_SYNC
```
  enum CUctx_flags
  
  See Also:
  
  Constant Field Values
- CU_CTX_BLOCKING_SYNC
```
public static final int CU_CTX_BLOCKING_SYNC
```
  enum CUctx_flags
  
  See Also:
  
  Constant Field Values
- CU_CTX_SCHED_MASK
```
public static final int CU_CTX_SCHED_MASK
```
  enum CUctx_flags
  
  See Also:
  
  Constant Field Values
- CU_CTX_MAP_HOST
```
public static final int CU_CTX_MAP_HOST
```
  enum CUctx_flags
  
  See Also:
  
  Constant Field Values
- CU_CTX_LMEM_RESIZE_TO_MAX
```
public static final int CU_CTX_LMEM_RESIZE_TO_MAX
```
  enum CUctx_flags
  
  See Also:
  
  Constant Field Values
- CU_CTX_FLAGS_MASK
```
public static final int CU_CTX_FLAGS_MASK
```
  enum CUctx_flags
  
  See Also:
  
  Constant Field Values
- CU_STREAM_DEFAULT
```
public static final int CU_STREAM_DEFAULT
```
  enum CUstream_flags
  
  See Also:
  
  Constant Field Values
- CU_STREAM_NON_BLOCKING
```
public static final int CU_STREAM_NON_BLOCKING
```
  enum CUstream_flags
  
  See Also:
  
  Constant Field Values
- CU_STREAM_LEGACY
```
public static final CUstream_st CU_STREAM_LEGACY
```
- CU_STREAM_PER_THREAD
```
public static final CUstream_st CU_STREAM_PER_THREAD
```
- CU_EVENT_DEFAULT
```
public static final int CU_EVENT_DEFAULT
```
  enum CUevent_flags
  
  See Also:
  
  Constant Field Values
- CU_EVENT_BLOCKING_SYNC
```
public static final int CU_EVENT_BLOCKING_SYNC
```
  enum CUevent_flags
  
  See Also:
  
  Constant Field Values
- CU_EVENT_DISABLE_TIMING
```
public static final int CU_EVENT_DISABLE_TIMING
```
  enum CUevent_flags
  
  See Also:
  
  Constant Field Values
- CU_EVENT_INTERPROCESS
```
public static final int CU_EVENT_INTERPROCESS
```
  enum CUevent_flags
  
  See Also:
  
  Constant Field Values
- CU_STREAM_WAIT_VALUE_GEQ
```
public static final int CU_STREAM_WAIT_VALUE_GEQ
```
  enum CUstreamWaitValue_flags
  
  See Also:
  
  Constant Field Values
- CU_STREAM_WAIT_VALUE_EQ
```
public static final int CU_STREAM_WAIT_VALUE_EQ
```
  enum CUstreamWaitValue_flags
  
  See Also:
  
  Constant Field Values
- CU_STREAM_WAIT_VALUE_AND
```
public static final int CU_STREAM_WAIT_VALUE_AND
```
  enum CUstreamWaitValue_flags
  
  See Also:
  
  Constant Field Values
- CU_STREAM_WAIT_VALUE_NOR
```
public static final int CU_STREAM_WAIT_VALUE_NOR
```
  enum CUstreamWaitValue_flags
  
  See Also:
  
  Constant Field Values
- CU_STREAM_WAIT_VALUE_FLUSH
```
public static final int CU_STREAM_WAIT_VALUE_FLUSH
```
  enum CUstreamWaitValue_flags
  
  See Also:
  
  Constant Field Values
- CU_STREAM_WRITE_VALUE_DEFAULT
```
public static final int CU_STREAM_WRITE_VALUE_DEFAULT
```
  enum CUstreamWriteValue_flags
  
  See Also:
  
  Constant Field Values
- CU_STREAM_WRITE_VALUE_NO_MEMORY_BARRIER
```
public static final int CU_STREAM_WRITE_VALUE_NO_MEMORY_BARRIER
```
  enum CUstreamWriteValue_flags
  
  See Also:
  
  Constant Field Values
- CU_STREAM_MEM_OP_WAIT_VALUE_32
```
public static final int CU_STREAM_MEM_OP_WAIT_VALUE_32
```
  enum CUstreamBatchMemOpType
  
  See Also:
  
  Constant Field Values
- CU_STREAM_MEM_OP_WRITE_VALUE_32
```
public static final int CU_STREAM_MEM_OP_WRITE_VALUE_32
```
  enum CUstreamBatchMemOpType
  
  See Also:
  
  Constant Field Values
- CU_STREAM_MEM_OP_WAIT_VALUE_64
```
public static final int CU_STREAM_MEM_OP_WAIT_VALUE_64
```
  enum CUstreamBatchMemOpType
  
  See Also:
  
  Constant Field Values
- CU_STREAM_MEM_OP_WRITE_VALUE_64
```
public static final int CU_STREAM_MEM_OP_WRITE_VALUE_64
```
  enum CUstreamBatchMemOpType
  
  See Also:
  
  Constant Field Values
- CU_STREAM_MEM_OP_FLUSH_REMOTE_WRITES
```
public static final int CU_STREAM_MEM_OP_FLUSH_REMOTE_WRITES
```
  enum CUstreamBatchMemOpType
  
  See Also:
  
  Constant Field Values
- CU_OCCUPANCY_DEFAULT
```
public static final int CU_OCCUPANCY_DEFAULT
```
  enum CUoccupancy_flags
  
  See Also:
  
  Constant Field Values
- CU_OCCUPANCY_DISABLE_CACHING_OVERRIDE
```
public static final int CU_OCCUPANCY_DISABLE_CACHING_OVERRIDE
```
  enum CUoccupancy_flags
  
  See Also:
  
  Constant Field Values
- CU_AD_FORMAT_UNSIGNED_INT8
```
public static final int CU_AD_FORMAT_UNSIGNED_INT8
```
  enum CUarray_format
  
  See Also:
  
  Constant Field Values
- CU_AD_FORMAT_UNSIGNED_INT16
```
public static final int CU_AD_FORMAT_UNSIGNED_INT16
```
  enum CUarray_format
  
  See Also:
  
  Constant Field Values
- CU_AD_FORMAT_UNSIGNED_INT32
```
public static final int CU_AD_FORMAT_UNSIGNED_INT32
```
  enum CUarray_format
  
  See Also:
  
  Constant Field Values
- CU_AD_FORMAT_SIGNED_INT8
```
public static final int CU_AD_FORMAT_SIGNED_INT8
```
  enum CUarray_format
  
  See Also:
  
  Constant Field Values
- CU_AD_FORMAT_SIGNED_INT16
```
public static final int CU_AD_FORMAT_SIGNED_INT16
```
  enum CUarray_format
  
  See Also:
  
  Constant Field Values
- CU_AD_FORMAT_SIGNED_INT32
```
public static final int CU_AD_FORMAT_SIGNED_INT32
```
  enum CUarray_format
  
  See Also:
  
  Constant Field Values
- CU_AD_FORMAT_HALF
```
public static final int CU_AD_FORMAT_HALF
```
  enum CUarray_format
  
  See Also:
  
  Constant Field Values
- CU_AD_FORMAT_FLOAT
```
public static final int CU_AD_FORMAT_FLOAT
```
  enum CUarray_format
  
  See Also:
  
  Constant Field Values
- CU_TR_ADDRESS_MODE_WRAP
```
public static final int CU_TR_ADDRESS_MODE_WRAP
```
  enum CUaddress_mode
  
  See Also:
  
  Constant Field Values
- CU_TR_ADDRESS_MODE_CLAMP
```
public static final int CU_TR_ADDRESS_MODE_CLAMP
```
  enum CUaddress_mode
  
  See Also:
  
  Constant Field Values
- CU_TR_ADDRESS_MODE_MIRROR
```
public static final int CU_TR_ADDRESS_MODE_MIRROR
```
  enum CUaddress_mode
  
  See Also:
  
  Constant Field Values
- CU_TR_ADDRESS_MODE_BORDER
```
public static final int CU_TR_ADDRESS_MODE_BORDER
```
  enum CUaddress_mode
  
  See Also:
  
  Constant Field Values
- CU_TR_FILTER_MODE_POINT
```
public static final int CU_TR_FILTER_MODE_POINT
```
  enum CUfilter_mode
  
  See Also:
  
  Constant Field Values
- CU_TR_FILTER_MODE_LINEAR
```
public static final int CU_TR_FILTER_MODE_LINEAR
```
  enum CUfilter_mode
  
  See Also:
  
  Constant Field Values
- CU_DEVICE_ATTRIBUTE_MAX_THREADS_PER_BLOCK
```
public static final int CU_DEVICE_ATTRIBUTE_MAX_THREADS_PER_BLOCK
```
  enum CUdevice_attribute
  
  See Also:
  
  Constant Field Values
- CU_DEVICE_ATTRIBUTE_MAX_BLOCK_DIM_X
```
public static final int CU_DEVICE_ATTRIBUTE_MAX_BLOCK_DIM_X
```
  enum CUdevice_attribute
  
  See Also:
  
  Constant Field Values
- CU_DEVICE_ATTRIBUTE_MAX_BLOCK_DIM_Y
```
public static final int CU_DEVICE_ATTRIBUTE_MAX_BLOCK_DIM_Y
```
  enum CUdevice_attribute
  
  See Also:
  
  Constant Field Values
- CU_DEVICE_ATTRIBUTE_MAX_BLOCK_DIM_Z
```
public static final int CU_DEVICE_ATTRIBUTE_MAX_BLOCK_DIM_Z
```
  enum CUdevice_attribute
  
  See Also:
  
  Constant Field Values
- CU_DEVICE_ATTRIBUTE_MAX_GRID_DIM_X
```
public static final int CU_DEVICE_ATTRIBUTE_MAX_GRID_DIM_X
```
  enum CUdevice_attribute
  
  See Also:
  
  Constant Field Values
- CU_DEVICE_ATTRIBUTE_MAX_GRID_DIM_Y
```
public static final int CU_DEVICE_ATTRIBUTE_MAX_GRID_DIM_Y
```
  enum CUdevice_attribute
  
  See Also:
  
  Constant Field Values
- CU_DEVICE_ATTRIBUTE_MAX_GRID_DIM_Z
```
public static final int CU_DEVICE_ATTRIBUTE_MAX_GRID_DIM_Z
```
  enum CUdevice_attribute
  
  See Also:
  
  Constant Field Values
- CU_DEVICE_ATTRIBUTE_MAX_SHARED_MEMORY_PER_BLOCK
```
public static final int CU_DEVICE_ATTRIBUTE_MAX_SHARED_MEMORY_PER_BLOCK
```
  enum CUdevice_attribute
  
  See Also:
  
  Constant Field Values
- CU_DEVICE_ATTRIBUTE_SHARED_MEMORY_PER_BLOCK
```
public static final int CU_DEVICE_ATTRIBUTE_SHARED_MEMORY_PER_BLOCK
```
  enum CUdevice_attribute
  
  See Also:
  
  Constant Field Values
- CU_DEVICE_ATTRIBUTE_TOTAL_CONSTANT_MEMORY
```
public static final int CU_DEVICE_ATTRIBUTE_TOTAL_CONSTANT_MEMORY
```
  enum CUdevice_attribute
  
  See Also:
  
  Constant Field Values
- CU_DEVICE_ATTRIBUTE_WARP_SIZE
```
public static final int CU_DEVICE_ATTRIBUTE_WARP_SIZE
```
  enum CUdevice_attribute
  
  See Also:
  
  Constant Field Values
- CU_DEVICE_ATTRIBUTE_MAX_PITCH
```
public static final int CU_DEVICE_ATTRIBUTE_MAX_PITCH
```
  enum CUdevice_attribute
  
  See Also:
  
  Constant Field Values
- CU_DEVICE_ATTRIBUTE_MAX_REGISTERS_PER_BLOCK
```
public static final int CU_DEVICE_ATTRIBUTE_MAX_REGISTERS_PER_BLOCK
```
  enum CUdevice_attribute
  
  See Also:
  
  Constant Field Values
- CU_DEVICE_ATTRIBUTE_REGISTERS_PER_BLOCK
```
public static final int CU_DEVICE_ATTRIBUTE_REGISTERS_PER_BLOCK
```
  enum CUdevice_attribute
  
  See Also:
  
  Constant Field Values
- CU_DEVICE_ATTRIBUTE_CLOCK_RATE
```
public static final int CU_DEVICE_ATTRIBUTE_CLOCK_RATE
```
  enum CUdevice_attribute
  
  See Also:
  
  Constant Field Values
- CU_DEVICE_ATTRIBUTE_TEXTURE_ALIGNMENT
```
public static final int CU_DEVICE_ATTRIBUTE_TEXTURE_ALIGNMENT
```
  enum CUdevice_attribute
  
  See Also:
  
  Constant Field Values
- CU_DEVICE_ATTRIBUTE_GPU_OVERLAP
```
public static final int CU_DEVICE_ATTRIBUTE_GPU_OVERLAP
```
  enum CUdevice_attribute
  
  See Also:
  
  Constant Field Values
- CU_DEVICE_ATTRIBUTE_MULTIPROCESSOR_COUNT
```
public static final int CU_DEVICE_ATTRIBUTE_MULTIPROCESSOR_COUNT
```
  enum CUdevice_attribute
  
  See Also:
  
  Constant Field Values
- CU_DEVICE_ATTRIBUTE_KERNEL_EXEC_TIMEOUT
```
public static final int CU_DEVICE_ATTRIBUTE_KERNEL_EXEC_TIMEOUT
```
  enum CUdevice_attribute
  
  See Also:
  
  Constant Field Values
- CU_DEVICE_ATTRIBUTE_INTEGRATED
```
public static final int CU_DEVICE_ATTRIBUTE_INTEGRATED
```
  enum CUdevice_attribute
  
  See Also:
  
  Constant Field Values
- CU_DEVICE_ATTRIBUTE_CAN_MAP_HOST_MEMORY
```
public static final int CU_DEVICE_ATTRIBUTE_CAN_MAP_HOST_MEMORY
```
  enum CUdevice_attribute
  
  See Also:
  
  Constant Field Values
- CU_DEVICE_ATTRIBUTE_COMPUTE_MODE
```
public static final int CU_DEVICE_ATTRIBUTE_COMPUTE_MODE
```
  enum CUdevice_attribute
  
  See Also:
  
  Constant Field Values
- CU_DEVICE_ATTRIBUTE_MAXIMUM_TEXTURE1D_WIDTH
```
public static final int CU_DEVICE_ATTRIBUTE_MAXIMUM_TEXTURE1D_WIDTH
```
  enum CUdevice_attribute
  
  See Also:
  
  Constant Field Values
- CU_DEVICE_ATTRIBUTE_MAXIMUM_TEXTURE2D_WIDTH
```
public static final int CU_DEVICE_ATTRIBUTE_MAXIMUM_TEXTURE2D_WIDTH
```
  enum CUdevice_attribute
  
  See Also:
  
  Constant Field Values
- CU_DEVICE_ATTRIBUTE_MAXIMUM_TEXTURE2D_HEIGHT
```
public static final int CU_DEVICE_ATTRIBUTE_MAXIMUM_TEXTURE2D_HEIGHT
```
  enum CUdevice_attribute
  
  See Also:
  
  Constant Field Values
- CU_DEVICE_ATTRIBUTE_MAXIMUM_TEXTURE3D_WIDTH
```
public static final int CU_DEVICE_ATTRIBUTE_MAXIMUM_TEXTURE3D_WIDTH
```
  enum CUdevice_attribute
  
  See Also:
  
  Constant Field Values
- CU_DEVICE_ATTRIBUTE_MAXIMUM_TEXTURE3D_HEIGHT
```
public static final int CU_DEVICE_ATTRIBUTE_MAXIMUM_TEXTURE3D_HEIGHT
```
  enum CUdevice_attribute
  
  See Also:
  
  Constant Field Values
- CU_DEVICE_ATTRIBUTE_MAXIMUM_TEXTURE3D_DEPTH
```
public static final int CU_DEVICE_ATTRIBUTE_MAXIMUM_TEXTURE3D_DEPTH
```
  enum CUdevice_attribute
  
  See Also:
  
  Constant Field Values
- CU_DEVICE_ATTRIBUTE_MAXIMUM_TEXTURE2D_LAYERED_WIDTH
```
public static final int CU_DEVICE_ATTRIBUTE_MAXIMUM_TEXTURE2D_LAYERED_WIDTH
```
  enum CUdevice_attribute
  
  See Also:
  
  Constant Field Values
- CU_DEVICE_ATTRIBUTE_MAXIMUM_TEXTURE2D_LAYERED_HEIGHT
```
public static final int CU_DEVICE_ATTRIBUTE_MAXIMUM_TEXTURE2D_LAYERED_HEIGHT
```
  enum CUdevice_attribute
  
  See Also:
  
  Constant Field Values
- CU_DEVICE_ATTRIBUTE_MAXIMUM_TEXTURE2D_LAYERED_LAYERS
```
public static final int CU_DEVICE_ATTRIBUTE_MAXIMUM_TEXTURE2D_LAYERED_LAYERS
```
  enum CUdevice_attribute
  
  See Also:
  
  Constant Field Values
- CU_DEVICE_ATTRIBUTE_MAXIMUM_TEXTURE2D_ARRAY_WIDTH
```
public static final int CU_DEVICE_ATTRIBUTE_MAXIMUM_TEXTURE2D_ARRAY_WIDTH
```
  enum CUdevice_attribute
  
  See Also:
  
  Constant Field Values
- CU_DEVICE_ATTRIBUTE_MAXIMUM_TEXTURE2D_ARRAY_HEIGHT
```
public static final int CU_DEVICE_ATTRIBUTE_MAXIMUM_TEXTURE2D_ARRAY_HEIGHT
```
  enum CUdevice_attribute
  
  See Also:
  
  Constant Field Values
- CU_DEVICE_ATTRIBUTE_MAXIMUM_TEXTURE2D_ARRAY_NUMSLICES
```
public static final int CU_DEVICE_ATTRIBUTE_MAXIMUM_TEXTURE2D_ARRAY_NUMSLICES
```
  enum CUdevice_attribute
  
  See Also:
  
  Constant Field Values
- CU_DEVICE_ATTRIBUTE_SURFACE_ALIGNMENT
```
public static final int CU_DEVICE_ATTRIBUTE_SURFACE_ALIGNMENT
```
  enum CUdevice_attribute
  
  See Also:
  
  Constant Field Values
- CU_DEVICE_ATTRIBUTE_CONCURRENT_KERNELS
```
public static final int CU_DEVICE_ATTRIBUTE_CONCURRENT_KERNELS
```
  enum CUdevice_attribute
  
  See Also:
  
  Constant Field Values
- CU_DEVICE_ATTRIBUTE_ECC_ENABLED
```
public static final int CU_DEVICE_ATTRIBUTE_ECC_ENABLED
```
  enum CUdevice_attribute
  
  See Also:
  
  Constant Field Values
- CU_DEVICE_ATTRIBUTE_PCI_BUS_ID
```
public static final int CU_DEVICE_ATTRIBUTE_PCI_BUS_ID
```
  enum CUdevice_attribute
  
  See Also:
  
  Constant Field Values
- CU_DEVICE_ATTRIBUTE_PCI_DEVICE_ID
```
public static final int CU_DEVICE_ATTRIBUTE_PCI_DEVICE_ID
```
  enum CUdevice_attribute
  
  See Also:
  
  Constant Field Values
- CU_DEVICE_ATTRIBUTE_TCC_DRIVER
```
public static final int CU_DEVICE_ATTRIBUTE_TCC_DRIVER
```
  enum CUdevice_attribute
  
  See Also:
  
  Constant Field Values
- CU_DEVICE_ATTRIBUTE_MEMORY_CLOCK_RATE
```
public static final int CU_DEVICE_ATTRIBUTE_MEMORY_CLOCK_RATE
```
  enum CUdevice_attribute
  
  See Also:
  
  Constant Field Values
- CU_DEVICE_ATTRIBUTE_GLOBAL_MEMORY_BUS_WIDTH
```
public static final int CU_DEVICE_ATTRIBUTE_GLOBAL_MEMORY_BUS_WIDTH
```
  enum CUdevice_attribute
  
  See Also:
  
  Constant Field Values
- CU_DEVICE_ATTRIBUTE_L2_CACHE_SIZE
```
public static final int CU_DEVICE_ATTRIBUTE_L2_CACHE_SIZE
```
  enum CUdevice_attribute
  
  See Also:
  
  Constant Field Values
- CU_DEVICE_ATTRIBUTE_MAX_THREADS_PER_MULTIPROCESSOR
```
public static final int CU_DEVICE_ATTRIBUTE_MAX_THREADS_PER_MULTIPROCESSOR
```
  enum CUdevice_attribute
  
  See Also:
  
  Constant Field Values
- CU_DEVICE_ATTRIBUTE_ASYNC_ENGINE_COUNT
```
public static final int CU_DEVICE_ATTRIBUTE_ASYNC_ENGINE_COUNT
```
  enum CUdevice_attribute
  
  See Also:
  
  Constant Field Values
- CU_DEVICE_ATTRIBUTE_UNIFIED_ADDRESSING
```
public static final int CU_DEVICE_ATTRIBUTE_UNIFIED_ADDRESSING
```
  enum CUdevice_attribute
  
  See Also:
  
  Constant Field Values
- CU_DEVICE_ATTRIBUTE_MAXIMUM_TEXTURE1D_LAYERED_WIDTH
```
public static final int CU_DEVICE_ATTRIBUTE_MAXIMUM_TEXTURE1D_LAYERED_WIDTH
```
  enum CUdevice_attribute
  
  See Also:
  
  Constant Field Values
- CU_DEVICE_ATTRIBUTE_MAXIMUM_TEXTURE1D_LAYERED_LAYERS
```
public static final int CU_DEVICE_ATTRIBUTE_MAXIMUM_TEXTURE1D_LAYERED_LAYERS
```
  enum CUdevice_attribute
  
  See Also:
  
  Constant Field Values
- CU_DEVICE_ATTRIBUTE_CAN_TEX2D_GATHER
```
public static final int CU_DEVICE_ATTRIBUTE_CAN_TEX2D_GATHER
```
  enum CUdevice_attribute
  
  See Also:
  
  Constant Field Values
- CU_DEVICE_ATTRIBUTE_MAXIMUM_TEXTURE2D_GATHER_WIDTH
```
public static final int CU_DEVICE_ATTRIBUTE_MAXIMUM_TEXTURE2D_GATHER_WIDTH
```
  enum CUdevice_attribute
  
  See Also:
  
  Constant Field Values
- CU_DEVICE_ATTRIBUTE_MAXIMUM_TEXTURE2D_GATHER_HEIGHT
```
public static final int CU_DEVICE_ATTRIBUTE_MAXIMUM_TEXTURE2D_GATHER_HEIGHT
```
  enum CUdevice_attribute
  
  See Also:
  
  Constant Field Values
- CU_DEVICE_ATTRIBUTE_MAXIMUM_TEXTURE3D_WIDTH_ALTERNATE
```
public static final int CU_DEVICE_ATTRIBUTE_MAXIMUM_TEXTURE3D_WIDTH_ALTERNATE
```
  enum CUdevice_attribute
  
  See Also:
  
  Constant Field Values
- CU_DEVICE_ATTRIBUTE_MAXIMUM_TEXTURE3D_HEIGHT_ALTERNATE
```
public static final int CU_DEVICE_ATTRIBUTE_MAXIMUM_TEXTURE3D_HEIGHT_ALTERNATE
```
  enum CUdevice_attribute
  
  See Also:
  
  Constant Field Values
- CU_DEVICE_ATTRIBUTE_MAXIMUM_TEXTURE3D_DEPTH_ALTERNATE
```
public static final int CU_DEVICE_ATTRIBUTE_MAXIMUM_TEXTURE3D_DEPTH_ALTERNATE
```
  enum CUdevice_attribute
  
  See Also:
  
  Constant Field Values
- CU_DEVICE_ATTRIBUTE_PCI_DOMAIN_ID
```
public static final int CU_DEVICE_ATTRIBUTE_PCI_DOMAIN_ID
```
  enum CUdevice_attribute
  
  See Also:
  
  Constant Field Values
- CU_DEVICE_ATTRIBUTE_TEXTURE_PITCH_ALIGNMENT
```
public static final int CU_DEVICE_ATTRIBUTE_TEXTURE_PITCH_ALIGNMENT
```
  enum CUdevice_attribute
  
  See Also:
  
  Constant Field Values
- CU_DEVICE_ATTRIBUTE_MAXIMUM_TEXTURECUBEMAP_WIDTH
```
public static final int CU_DEVICE_ATTRIBUTE_MAXIMUM_TEXTURECUBEMAP_WIDTH
```
  enum CUdevice_attribute
  
  See Also:
  
  Constant Field Values
- CU_DEVICE_ATTRIBUTE_MAXIMUM_TEXTURECUBEMAP_LAYERED_WIDTH
```
public static final int CU_DEVICE_ATTRIBUTE_MAXIMUM_TEXTURECUBEMAP_LAYERED_WIDTH
```
  enum CUdevice_attribute
  
  See Also:
  
  Constant Field Values
- CU_DEVICE_ATTRIBUTE_MAXIMUM_TEXTURECUBEMAP_LAYERED_LAYERS
```
public static final int CU_DEVICE_ATTRIBUTE_MAXIMUM_TEXTURECUBEMAP_LAYERED_LAYERS
```
  enum CUdevice_attribute
  
  See Also:
  
  Constant Field Values
- CU_DEVICE_ATTRIBUTE_MAXIMUM_SURFACE1D_WIDTH
```
public static final int CU_DEVICE_ATTRIBUTE_MAXIMUM_SURFACE1D_WIDTH
```
  enum CUdevice_attribute
  
  See Also:
  
  Constant Field Values
- CU_DEVICE_ATTRIBUTE_MAXIMUM_SURFACE2D_WIDTH
```
public static final int CU_DEVICE_ATTRIBUTE_MAXIMUM_SURFACE2D_WIDTH
```
  enum CUdevice_attribute
  
  See Also:
  
  Constant Field Values
- CU_DEVICE_ATTRIBUTE_MAXIMUM_SURFACE2D_HEIGHT
```
public static final int CU_DEVICE_ATTRIBUTE_MAXIMUM_SURFACE2D_HEIGHT
```
  enum CUdevice_attribute
  
  See Also:
  
  Constant Field Values
- CU_DEVICE_ATTRIBUTE_MAXIMUM_SURFACE3D_WIDTH
```
public static final int CU_DEVICE_ATTRIBUTE_MAXIMUM_SURFACE3D_WIDTH
```
  enum CUdevice_attribute
  
  See Also:
  
  Constant Field Values
- CU_DEVICE_ATTRIBUTE_MAXIMUM_SURFACE3D_HEIGHT
```
public static final int CU_DEVICE_ATTRIBUTE_MAXIMUM_SURFACE3D_HEIGHT
```
  enum CUdevice_attribute
  
  See Also:
  
  Constant Field Values
- CU_DEVICE_ATTRIBUTE_MAXIMUM_SURFACE3D_DEPTH
```
public static final int CU_DEVICE_ATTRIBUTE_MAXIMUM_SURFACE3D_DEPTH
```
  enum CUdevice_attribute
  
  See Also:
  
  Constant Field Values
- CU_DEVICE_ATTRIBUTE_MAXIMUM_SURFACE1D_LAYERED_WIDTH
```
public static final int CU_DEVICE_ATTRIBUTE_MAXIMUM_SURFACE1D_LAYERED_WIDTH
```
  enum CUdevice_attribute
  
  See Also:
  
  Constant Field Values
- CU_DEVICE_ATTRIBUTE_MAXIMUM_SURFACE1D_LAYERED_LAYERS
```
public static final int CU_DEVICE_ATTRIBUTE_MAXIMUM_SURFACE1D_LAYERED_LAYERS
```
  enum CUdevice_attribute
  
  See Also:
  
  Constant Field Values
- CU_DEVICE_ATTRIBUTE_MAXIMUM_SURFACE2D_LAYERED_WIDTH
```
public static final int CU_DEVICE_ATTRIBUTE_MAXIMUM_SURFACE2D_LAYERED_WIDTH
```
  enum CUdevice_attribute
  
  See Also:
  
  Constant Field Values
- CU_DEVICE_ATTRIBUTE_MAXIMUM_SURFACE2D_LAYERED_HEIGHT
```
public static final int CU_DEVICE_ATTRIBUTE_MAXIMUM_SURFACE2D_LAYERED_HEIGHT
```
  enum CUdevice_attribute
  
  See Also:
  
  Constant Field Values
- CU_DEVICE_ATTRIBUTE_MAXIMUM_SURFACE2D_LAYERED_LAYERS
```
public static final int CU_DEVICE_ATTRIBUTE_MAXIMUM_SURFACE2D_LAYERED_LAYERS
```
  enum CUdevice_attribute
  
  See Also:
  
  Constant Field Values
- CU_DEVICE_ATTRIBUTE_MAXIMUM_SURFACECUBEMAP_WIDTH
```
public static final int CU_DEVICE_ATTRIBUTE_MAXIMUM_SURFACECUBEMAP_WIDTH
```
  enum CUdevice_attribute
  
  See Also:
  
  Constant Field Values
- CU_DEVICE_ATTRIBUTE_MAXIMUM_SURFACECUBEMAP_LAYERED_WIDTH
```
public static final int CU_DEVICE_ATTRIBUTE_MAXIMUM_SURFACECUBEMAP_LAYERED_WIDTH
```
  enum CUdevice_attribute
  
  See Also:
  
  Constant Field Values
- CU_DEVICE_ATTRIBUTE_MAXIMUM_SURFACECUBEMAP_LAYERED_LAYERS
```
public static final int CU_DEVICE_ATTRIBUTE_MAXIMUM_SURFACECUBEMAP_LAYERED_LAYERS
```
  enum CUdevice_attribute
  
  See Also:
  
  Constant Field Values
- CU_DEVICE_ATTRIBUTE_MAXIMUM_TEXTURE1D_LINEAR_WIDTH
```
public static final int CU_DEVICE_ATTRIBUTE_MAXIMUM_TEXTURE1D_LINEAR_WIDTH
```
  enum CUdevice_attribute
  
  See Also:
  
  Constant Field Values
- CU_DEVICE_ATTRIBUTE_MAXIMUM_TEXTURE2D_LINEAR_WIDTH
```
public static final int CU_DEVICE_ATTRIBUTE_MAXIMUM_TEXTURE2D_LINEAR_WIDTH
```
  enum CUdevice_attribute
  
  See Also:
  
  Constant Field Values
- CU_DEVICE_ATTRIBUTE_MAXIMUM_TEXTURE2D_LINEAR_HEIGHT
```
public static final int CU_DEVICE_ATTRIBUTE_MAXIMUM_TEXTURE2D_LINEAR_HEIGHT
```
  enum CUdevice_attribute
  
  See Also:
  
  Constant Field Values
- CU_DEVICE_ATTRIBUTE_MAXIMUM_TEXTURE2D_LINEAR_PITCH
```
public static final int CU_DEVICE_ATTRIBUTE_MAXIMUM_TEXTURE2D_LINEAR_PITCH
```
  enum CUdevice_attribute
  
  See Also:
  
  Constant Field Values
- CU_DEVICE_ATTRIBUTE_MAXIMUM_TEXTURE2D_MIPMAPPED_WIDTH
```
public static final int CU_DEVICE_ATTRIBUTE_MAXIMUM_TEXTURE2D_MIPMAPPED_WIDTH
```
  enum CUdevice_attribute
  
  See Also:
  
  Constant Field Values
- CU_DEVICE_ATTRIBUTE_MAXIMUM_TEXTURE2D_MIPMAPPED_HEIGHT
```
public static final int CU_DEVICE_ATTRIBUTE_MAXIMUM_TEXTURE2D_MIPMAPPED_HEIGHT
```
  enum CUdevice_attribute
  
  See Also:
  
  Constant Field Values
- CU_DEVICE_ATTRIBUTE_COMPUTE_CAPABILITY_MAJOR
```
public static final int CU_DEVICE_ATTRIBUTE_COMPUTE_CAPABILITY_MAJOR
```
  enum CUdevice_attribute
  
  See Also:
  
  Constant Field Values
- CU_DEVICE_ATTRIBUTE_COMPUTE_CAPABILITY_MINOR
```
public static final int CU_DEVICE_ATTRIBUTE_COMPUTE_CAPABILITY_MINOR
```
  enum CUdevice_attribute
  
  See Also:
  
  Constant Field Values
- CU_DEVICE_ATTRIBUTE_MAXIMUM_TEXTURE1D_MIPMAPPED_WIDTH
```
public static final int CU_DEVICE_ATTRIBUTE_MAXIMUM_TEXTURE1D_MIPMAPPED_WIDTH
```
  enum CUdevice_attribute
  
  See Also:
  
  Constant Field Values
- CU_DEVICE_ATTRIBUTE_STREAM_PRIORITIES_SUPPORTED
```
public static final int CU_DEVICE_ATTRIBUTE_STREAM_PRIORITIES_SUPPORTED
```
  enum CUdevice_attribute
  
  See Also:
  
  Constant Field Values
- CU_DEVICE_ATTRIBUTE_GLOBAL_L1_CACHE_SUPPORTED
```
public static final int CU_DEVICE_ATTRIBUTE_GLOBAL_L1_CACHE_SUPPORTED
```
  enum CUdevice_attribute
  
  See Also:
  
  Constant Field Values
- CU_DEVICE_ATTRIBUTE_LOCAL_L1_CACHE_SUPPORTED
```
public static final int CU_DEVICE_ATTRIBUTE_LOCAL_L1_CACHE_SUPPORTED
```
  enum CUdevice_attribute
  
  See Also:
  
  Constant Field Values
- CU_DEVICE_ATTRIBUTE_MAX_SHARED_MEMORY_PER_MULTIPROCESSOR
```
public static final int CU_DEVICE_ATTRIBUTE_MAX_SHARED_MEMORY_PER_MULTIPROCESSOR
```
  enum CUdevice_attribute
  
  See Also:
  
  Constant Field Values
- CU_DEVICE_ATTRIBUTE_MAX_REGISTERS_PER_MULTIPROCESSOR
```
public static final int CU_DEVICE_ATTRIBUTE_MAX_REGISTERS_PER_MULTIPROCESSOR
```
  enum CUdevice_attribute
  
  See Also:
  
  Constant Field Values
- CU_DEVICE_ATTRIBUTE_MANAGED_MEMORY
```
public static final int CU_DEVICE_ATTRIBUTE_MANAGED_MEMORY
```
  enum CUdevice_attribute
  
  See Also:
  
  Constant Field Values
- CU_DEVICE_ATTRIBUTE_MULTI_GPU_BOARD
```
public static final int CU_DEVICE_ATTRIBUTE_MULTI_GPU_BOARD
```
  enum CUdevice_attribute
  
  See Also:
  
  Constant Field Values
- CU_DEVICE_ATTRIBUTE_MULTI_GPU_BOARD_GROUP_ID
```
public static final int CU_DEVICE_ATTRIBUTE_MULTI_GPU_BOARD_GROUP_ID
```
  enum CUdevice_attribute
  
  See Also:
  
  Constant Field Values
- CU_DEVICE_ATTRIBUTE_HOST_NATIVE_ATOMIC_SUPPORTED
```
public static final int CU_DEVICE_ATTRIBUTE_HOST_NATIVE_ATOMIC_SUPPORTED
```
  enum CUdevice_attribute
  
  See Also:
  
  Constant Field Values
- CU_DEVICE_ATTRIBUTE_SINGLE_TO_DOUBLE_PRECISION_PERF_RATIO
```
public static final int CU_DEVICE_ATTRIBUTE_SINGLE_TO_DOUBLE_PRECISION_PERF_RATIO
```
  enum CUdevice_attribute
  
  See Also:
  
  Constant Field Values
- CU_DEVICE_ATTRIBUTE_PAGEABLE_MEMORY_ACCESS
```
public static final int CU_DEVICE_ATTRIBUTE_PAGEABLE_MEMORY_ACCESS
```
  enum CUdevice_attribute
  
  See Also:
  
  Constant Field Values
- CU_DEVICE_ATTRIBUTE_CONCURRENT_MANAGED_ACCESS
```
public static final int CU_DEVICE_ATTRIBUTE_CONCURRENT_MANAGED_ACCESS
```
  enum CUdevice_attribute
  
  See Also:
  
  Constant Field Values
- CU_DEVICE_ATTRIBUTE_COMPUTE_PREEMPTION_SUPPORTED
```
public static final int CU_DEVICE_ATTRIBUTE_COMPUTE_PREEMPTION_SUPPORTED
```
  enum CUdevice_attribute
  
  See Also:
  
  Constant Field Values
- CU_DEVICE_ATTRIBUTE_CAN_USE_HOST_POINTER_FOR_REGISTERED_MEM
```
public static final int CU_DEVICE_ATTRIBUTE_CAN_USE_HOST_POINTER_FOR_REGISTERED_MEM
```
  enum CUdevice_attribute
  
  See Also:
  
  Constant Field Values
- CU_DEVICE_ATTRIBUTE_CAN_USE_STREAM_MEM_OPS
```
public static final int CU_DEVICE_ATTRIBUTE_CAN_USE_STREAM_MEM_OPS
```
  enum CUdevice_attribute
  
  See Also:
  
  Constant Field Values
- CU_DEVICE_ATTRIBUTE_CAN_USE_64_BIT_STREAM_MEM_OPS
```
public static final int CU_DEVICE_ATTRIBUTE_CAN_USE_64_BIT_STREAM_MEM_OPS
```
  enum CUdevice_attribute
  
  See Also:
  
  Constant Field Values
- CU_DEVICE_ATTRIBUTE_CAN_USE_STREAM_WAIT_VALUE_NOR
```
public static final int CU_DEVICE_ATTRIBUTE_CAN_USE_STREAM_WAIT_VALUE_NOR
```
  enum CUdevice_attribute
  
  See Also:
  
  Constant Field Values
- CU_DEVICE_ATTRIBUTE_COOPERATIVE_LAUNCH
```
public static final int CU_DEVICE_ATTRIBUTE_COOPERATIVE_LAUNCH
```
  enum CUdevice_attribute
  
  See Also:
  
  Constant Field Values
- CU_DEVICE_ATTRIBUTE_COOPERATIVE_MULTI_DEVICE_LAUNCH
```
public static final int CU_DEVICE_ATTRIBUTE_COOPERATIVE_MULTI_DEVICE_LAUNCH
```
  enum CUdevice_attribute
  
  See Also:
  
  Constant Field Values
- CU_DEVICE_ATTRIBUTE_MAX_SHARED_MEMORY_PER_BLOCK_OPTIN
```
public static final int CU_DEVICE_ATTRIBUTE_MAX_SHARED_MEMORY_PER_BLOCK_OPTIN
```
  enum CUdevice_attribute
  
  See Also:
  
  Constant Field Values
- CU_DEVICE_ATTRIBUTE_CAN_FLUSH_REMOTE_WRITES
```
public static final int CU_DEVICE_ATTRIBUTE_CAN_FLUSH_REMOTE_WRITES
```
  enum CUdevice_attribute
  
  See Also:
  
  Constant Field Values
- CU_DEVICE_ATTRIBUTE_HOST_REGISTER_SUPPORTED
```
public static final int CU_DEVICE_ATTRIBUTE_HOST_REGISTER_SUPPORTED
```
  enum CUdevice_attribute
  
  See Also:
  
  Constant Field Values
- CU_DEVICE_ATTRIBUTE_PAGEABLE_MEMORY_ACCESS_USES_HOST_PAGE_TABLES
```
public static final int CU_DEVICE_ATTRIBUTE_PAGEABLE_MEMORY_ACCESS_USES_HOST_PAGE_TABLES
```
  enum CUdevice_attribute
  
  See Also:
  
  Constant Field Values
- CU_DEVICE_ATTRIBUTE_DIRECT_MANAGED_MEM_ACCESS_FROM_HOST
```
public static final int CU_DEVICE_ATTRIBUTE_DIRECT_MANAGED_MEM_ACCESS_FROM_HOST
```
  enum CUdevice_attribute
  
  See Also:
  
  Constant Field Values
- CU_DEVICE_ATTRIBUTE_VIRTUAL_ADDRESS_MANAGEMENT_SUPPORTED
```
public static final int CU_DEVICE_ATTRIBUTE_VIRTUAL_ADDRESS_MANAGEMENT_SUPPORTED
```
  enum CUdevice_attribute
  
  See Also:
  
  Constant Field Values
- CU_DEVICE_ATTRIBUTE_HANDLE_TYPE_POSIX_FILE_DESCRIPTOR_SUPPORTED
```
public static final int CU_DEVICE_ATTRIBUTE_HANDLE_TYPE_POSIX_FILE_DESCRIPTOR_SUPPORTED
```
  enum CUdevice_attribute
  
  See Also:
  
  Constant Field Values
- CU_DEVICE_ATTRIBUTE_HANDLE_TYPE_WIN32_HANDLE_SUPPORTED
```
public static final int CU_DEVICE_ATTRIBUTE_HANDLE_TYPE_WIN32_HANDLE_SUPPORTED
```
  enum CUdevice_attribute
  
  See Also:
  
  Constant Field Values
- CU_DEVICE_ATTRIBUTE_HANDLE_TYPE_WIN32_KMT_HANDLE_SUPPORTED
```
public static final int CU_DEVICE_ATTRIBUTE_HANDLE_TYPE_WIN32_KMT_HANDLE_SUPPORTED
```
  enum CUdevice_attribute
  
  See Also:
  
  Constant Field Values
- CU_DEVICE_ATTRIBUTE_MAX
```
public static final int CU_DEVICE_ATTRIBUTE_MAX
```
  enum CUdevice_attribute
  
  See Also:
  
  Constant Field Values
- CU_POINTER_ATTRIBUTE_CONTEXT
```
public static final int CU_POINTER_ATTRIBUTE_CONTEXT
```
  enum CUpointer_attribute
  
  See Also:
  
  Constant Field Values
- CU_POINTER_ATTRIBUTE_MEMORY_TYPE
```
public static final int CU_POINTER_ATTRIBUTE_MEMORY_TYPE
```
  enum CUpointer_attribute
  
  See Also:
  
  Constant Field Values
- CU_POINTER_ATTRIBUTE_DEVICE_POINTER
```
public static final int CU_POINTER_ATTRIBUTE_DEVICE_POINTER
```
  enum CUpointer_attribute
  
  See Also:
  
  Constant Field Values
- CU_POINTER_ATTRIBUTE_HOST_POINTER
```
public static final int CU_POINTER_ATTRIBUTE_HOST_POINTER
```
  enum CUpointer_attribute
  
  See Also:
  
  Constant Field Values
- CU_POINTER_ATTRIBUTE_P2P_TOKENS
```
public static final int CU_POINTER_ATTRIBUTE_P2P_TOKENS
```
  enum CUpointer_attribute
  
  See Also:
  
  Constant Field Values
- CU_POINTER_ATTRIBUTE_SYNC_MEMOPS
```
public static final int CU_POINTER_ATTRIBUTE_SYNC_MEMOPS
```
  enum CUpointer_attribute
  
  See Also:
  
  Constant Field Values
- CU_POINTER_ATTRIBUTE_BUFFER_ID
```
public static final int CU_POINTER_ATTRIBUTE_BUFFER_ID
```
  enum CUpointer_attribute
  
  See Also:
  
  Constant Field Values
- CU_POINTER_ATTRIBUTE_IS_MANAGED
```
public static final int CU_POINTER_ATTRIBUTE_IS_MANAGED
```
  enum CUpointer_attribute
  
  See Also:
  
  Constant Field Values
- CU_POINTER_ATTRIBUTE_DEVICE_ORDINAL
```
public static final int CU_POINTER_ATTRIBUTE_DEVICE_ORDINAL
```
  enum CUpointer_attribute
  
  See Also:
  
  Constant Field Values
- CU_POINTER_ATTRIBUTE_IS_LEGACY_CUDA_IPC_CAPABLE
```
public static final int CU_POINTER_ATTRIBUTE_IS_LEGACY_CUDA_IPC_CAPABLE
```
  enum CUpointer_attribute
  
  See Also:
  
  Constant Field Values
- CU_POINTER_ATTRIBUTE_RANGE_START_ADDR
```
public static final int CU_POINTER_ATTRIBUTE_RANGE_START_ADDR
```
  enum CUpointer_attribute
  
  See Also:
  
  Constant Field Values
- CU_POINTER_ATTRIBUTE_RANGE_SIZE
```
public static final int CU_POINTER_ATTRIBUTE_RANGE_SIZE
```
  enum CUpointer_attribute
  
  See Also:
  
  Constant Field Values
- CU_POINTER_ATTRIBUTE_MAPPED
```
public static final int CU_POINTER_ATTRIBUTE_MAPPED
```
  enum CUpointer_attribute
  
  See Also:
  
  Constant Field Values
- CU_POINTER_ATTRIBUTE_ALLOWED_HANDLE_TYPES
```
public static final int CU_POINTER_ATTRIBUTE_ALLOWED_HANDLE_TYPES
```
  enum CUpointer_attribute
  
  See Also:
  
  Constant Field Values
- CU_FUNC_ATTRIBUTE_MAX_THREADS_PER_BLOCK
```
public static final int CU_FUNC_ATTRIBUTE_MAX_THREADS_PER_BLOCK
```
  enum CUfunction_attribute
  
  See Also:
  
  Constant Field Values
- CU_FUNC_ATTRIBUTE_SHARED_SIZE_BYTES
```
public static final int CU_FUNC_ATTRIBUTE_SHARED_SIZE_BYTES
```
  enum CUfunction_attribute
  
  See Also:
  
  Constant Field Values
- CU_FUNC_ATTRIBUTE_CONST_SIZE_BYTES
```
public static final int CU_FUNC_ATTRIBUTE_CONST_SIZE_BYTES
```
  enum CUfunction_attribute
  
  See Also:
  
  Constant Field Values
- CU_FUNC_ATTRIBUTE_LOCAL_SIZE_BYTES
```
public static final int CU_FUNC_ATTRIBUTE_LOCAL_SIZE_BYTES
```
  enum CUfunction_attribute
  
  See Also:
  
  Constant Field Values
- CU_FUNC_ATTRIBUTE_NUM_REGS
```
public static final int CU_FUNC_ATTRIBUTE_NUM_REGS
```
  enum CUfunction_attribute
  
  See Also:
  
  Constant Field Values
- CU_FUNC_ATTRIBUTE_PTX_VERSION
```
public static final int CU_FUNC_ATTRIBUTE_PTX_VERSION
```
  enum CUfunction_attribute
  
  See Also:
  
  Constant Field Values
- CU_FUNC_ATTRIBUTE_BINARY_VERSION
```
public static final int CU_FUNC_ATTRIBUTE_BINARY_VERSION
```
  enum CUfunction_attribute
  
  See Also:
  
  Constant Field Values
- CU_FUNC_ATTRIBUTE_CACHE_MODE_CA
```
public static final int CU_FUNC_ATTRIBUTE_CACHE_MODE_CA
```
  enum CUfunction_attribute
  
  See Also:
  
  Constant Field Values
- CU_FUNC_ATTRIBUTE_MAX_DYNAMIC_SHARED_SIZE_BYTES
```
public static final int CU_FUNC_ATTRIBUTE_MAX_DYNAMIC_SHARED_SIZE_BYTES
```
  enum CUfunction_attribute
  
  See Also:
  
  Constant Field Values
- CU_FUNC_ATTRIBUTE_PREFERRED_SHARED_MEMORY_CARVEOUT
```
public static final int CU_FUNC_ATTRIBUTE_PREFERRED_SHARED_MEMORY_CARVEOUT
```
  enum CUfunction_attribute
  
  See Also:
  
  Constant Field Values
- CU_FUNC_ATTRIBUTE_MAX
```
public static final int CU_FUNC_ATTRIBUTE_MAX
```
  enum CUfunction_attribute
  
  See Also:
  
  Constant Field Values
- CU_FUNC_CACHE_PREFER_NONE
```
public static final int CU_FUNC_CACHE_PREFER_NONE
```
  enum CUfunc_cache
  
  See Also:
  
  Constant Field Values
- CU_FUNC_CACHE_PREFER_SHARED
```
public static final int CU_FUNC_CACHE_PREFER_SHARED
```
  enum CUfunc_cache
  
  See Also:
  
  Constant Field Values
- CU_FUNC_CACHE_PREFER_L1
```
public static final int CU_FUNC_CACHE_PREFER_L1
```
  enum CUfunc_cache
  
  See Also:
  
  Constant Field Values
- CU_FUNC_CACHE_PREFER_EQUAL
```
public static final int CU_FUNC_CACHE_PREFER_EQUAL
```
  enum CUfunc_cache
  
  See Also:
  
  Constant Field Values
- CU_SHARED_MEM_CONFIG_DEFAULT_BANK_SIZE
```
public static final int CU_SHARED_MEM_CONFIG_DEFAULT_BANK_SIZE
```
  enum CUsharedconfig
  
  See Also:
  
  Constant Field Values
- CU_SHARED_MEM_CONFIG_FOUR_BYTE_BANK_SIZE
```
public static final int CU_SHARED_MEM_CONFIG_FOUR_BYTE_BANK_SIZE
```
  enum CUsharedconfig
  
  See Also:
  
  Constant Field Values
- CU_SHARED_MEM_CONFIG_EIGHT_BYTE_BANK_SIZE
```
public static final int CU_SHARED_MEM_CONFIG_EIGHT_BYTE_BANK_SIZE
```
  enum CUsharedconfig
  
  See Also:
  
  Constant Field Values
- CU_SHAREDMEM_CARVEOUT_DEFAULT
```
public static final int CU_SHAREDMEM_CARVEOUT_DEFAULT
```
  enum CUshared_carveout
  
  See Also:
  
  Constant Field Values
- CU_SHAREDMEM_CARVEOUT_MAX_SHARED
```
public static final int CU_SHAREDMEM_CARVEOUT_MAX_SHARED
```
  enum CUshared_carveout
  
  See Also:
  
  Constant Field Values
- CU_SHAREDMEM_CARVEOUT_MAX_L1
```
public static final int CU_SHAREDMEM_CARVEOUT_MAX_L1
```
  enum CUshared_carveout
  
  See Also:
  
  Constant Field Values
- CU_MEMORYTYPE_HOST
```
public static final int CU_MEMORYTYPE_HOST
```
  enum CUmemorytype
  
  See Also:
  
  Constant Field Values
- CU_MEMORYTYPE_DEVICE
```
public static final int CU_MEMORYTYPE_DEVICE
```
  enum CUmemorytype
  
  See Also:
  
  Constant Field Values
- CU_MEMORYTYPE_ARRAY
```
public static final int CU_MEMORYTYPE_ARRAY
```
  enum CUmemorytype
  
  See Also:
  
  Constant Field Values
- CU_MEMORYTYPE_UNIFIED
```
public static final int CU_MEMORYTYPE_UNIFIED
```
  enum CUmemorytype
  
  See Also:
  
  Constant Field Values
- CU_COMPUTEMODE_DEFAULT
```
public static final int CU_COMPUTEMODE_DEFAULT
```
  enum CUcomputemode
  
  See Also:
  
  Constant Field Values
- CU_COMPUTEMODE_PROHIBITED
```
public static final int CU_COMPUTEMODE_PROHIBITED
```
  enum CUcomputemode
  
  See Also:
  
  Constant Field Values
- CU_COMPUTEMODE_EXCLUSIVE_PROCESS
```
public static final int CU_COMPUTEMODE_EXCLUSIVE_PROCESS
```
  enum CUcomputemode
  
  See Also:
  
  Constant Field Values
- CU_MEM_ADVISE_SET_READ_MOSTLY
```
public static final int CU_MEM_ADVISE_SET_READ_MOSTLY
```
  enum CUmem_advise
  
  See Also:
  
  Constant Field Values
- CU_MEM_ADVISE_UNSET_READ_MOSTLY
```
public static final int CU_MEM_ADVISE_UNSET_READ_MOSTLY
```
  enum CUmem_advise
  
  See Also:
  
  Constant Field Values
- CU_MEM_ADVISE_SET_PREFERRED_LOCATION
```
public static final int CU_MEM_ADVISE_SET_PREFERRED_LOCATION
```
  enum CUmem_advise
  
  See Also:
  
  Constant Field Values
- CU_MEM_ADVISE_UNSET_PREFERRED_LOCATION
```
public static final int CU_MEM_ADVISE_UNSET_PREFERRED_LOCATION
```
  enum CUmem_advise
  
  See Also:
  
  Constant Field Values
- CU_MEM_ADVISE_SET_ACCESSED_BY
```
public static final int CU_MEM_ADVISE_SET_ACCESSED_BY
```
  enum CUmem_advise
  
  See Also:
  
  Constant Field Values
- CU_MEM_ADVISE_UNSET_ACCESSED_BY
```
public static final int CU_MEM_ADVISE_UNSET_ACCESSED_BY
```
  enum CUmem_advise
  
  See Also:
  
  Constant Field Values
- CU_MEM_RANGE_ATTRIBUTE_READ_MOSTLY
```
public static final int CU_MEM_RANGE_ATTRIBUTE_READ_MOSTLY
```
  enum CUmem_range_attribute
  
  See Also:
  
  Constant Field Values
- CU_MEM_RANGE_ATTRIBUTE_PREFERRED_LOCATION
```
public static final int CU_MEM_RANGE_ATTRIBUTE_PREFERRED_LOCATION
```
  enum CUmem_range_attribute
  
  See Also:
  
  Constant Field Values
- CU_MEM_RANGE_ATTRIBUTE_ACCESSED_BY
```
public static final int CU_MEM_RANGE_ATTRIBUTE_ACCESSED_BY
```
  enum CUmem_range_attribute
  
  See Also:
  
  Constant Field Values
- CU_MEM_RANGE_ATTRIBUTE_LAST_PREFETCH_LOCATION
```
public static final int CU_MEM_RANGE_ATTRIBUTE_LAST_PREFETCH_LOCATION
```
  enum CUmem_range_attribute
  
  See Also:
  
  Constant Field Values
- CU_JIT_MAX_REGISTERS
```
public static final int CU_JIT_MAX_REGISTERS
```
  enum CUjit_option
  
  See Also:
  
  Constant Field Values
- CU_JIT_THREADS_PER_BLOCK
```
public static final int CU_JIT_THREADS_PER_BLOCK
```
  enum CUjit_option
  
  See Also:
  
  Constant Field Values
- CU_JIT_WALL_TIME
```
public static final int CU_JIT_WALL_TIME
```
  enum CUjit_option
  
  See Also:
  
  Constant Field Values
- CU_JIT_INFO_LOG_BUFFER
```
public static final int CU_JIT_INFO_LOG_BUFFER
```
  enum CUjit_option
  
  See Also:
  
  Constant Field Values
- CU_JIT_INFO_LOG_BUFFER_SIZE_BYTES
```
public static final int CU_JIT_INFO_LOG_BUFFER_SIZE_BYTES
```
  enum CUjit_option
  
  See Also:
  
  Constant Field Values
- CU_JIT_ERROR_LOG_BUFFER
```
public static final int CU_JIT_ERROR_LOG_BUFFER
```
  enum CUjit_option
  
  See Also:
  
  Constant Field Values
- CU_JIT_ERROR_LOG_BUFFER_SIZE_BYTES
```
public static final int CU_JIT_ERROR_LOG_BUFFER_SIZE_BYTES
```
  enum CUjit_option
  
  See Also:
  
  Constant Field Values
- CU_JIT_OPTIMIZATION_LEVEL
```
public static final int CU_JIT_OPTIMIZATION_LEVEL
```
  enum CUjit_option
  
  See Also:
  
  Constant Field Values
- CU_JIT_TARGET_FROM_CUCONTEXT
```
public static final int CU_JIT_TARGET_FROM_CUCONTEXT
```
  enum CUjit_option
  
  See Also:
  
  Constant Field Values
- CU_JIT_TARGET
```
public static final int CU_JIT_TARGET
```
  enum CUjit_option
  
  See Also:
  
  Constant Field Values
- CU_JIT_FALLBACK_STRATEGY
```
public static final int CU_JIT_FALLBACK_STRATEGY
```
  enum CUjit_option
  
  See Also:
  
  Constant Field Values
- CU_JIT_GENERATE_DEBUG_INFO
```
public static final int CU_JIT_GENERATE_DEBUG_INFO
```
  enum CUjit_option
  
  See Also:
  
  Constant Field Values
- CU_JIT_LOG_VERBOSE
```
public static final int CU_JIT_LOG_VERBOSE
```
  enum CUjit_option
  
  See Also:
  
  Constant Field Values
- CU_JIT_GENERATE_LINE_INFO
```
public static final int CU_JIT_GENERATE_LINE_INFO
```
  enum CUjit_option
  
  See Also:
  
  Constant Field Values
- CU_JIT_CACHE_MODE
```
public static final int CU_JIT_CACHE_MODE
```
  enum CUjit_option
  
  See Also:
  
  Constant Field Values
- CU_JIT_NEW_SM3X_OPT
```
public static final int CU_JIT_NEW_SM3X_OPT
```
  enum CUjit_option
  
  See Also:
  
  Constant Field Values
- CU_JIT_FAST_COMPILE
```
public static final int CU_JIT_FAST_COMPILE
```
  enum CUjit_option
  
  See Also:
  
  Constant Field Values
- CU_JIT_GLOBAL_SYMBOL_NAMES
```
public static final int CU_JIT_GLOBAL_SYMBOL_NAMES
```
  enum CUjit_option
  
  See Also:
  
  Constant Field Values
- CU_JIT_GLOBAL_SYMBOL_ADDRESSES
```
public static final int CU_JIT_GLOBAL_SYMBOL_ADDRESSES
```
  enum CUjit_option
  
  See Also:
  
  Constant Field Values
- CU_JIT_GLOBAL_SYMBOL_COUNT
```
public static final int CU_JIT_GLOBAL_SYMBOL_COUNT
```
  enum CUjit_option
  
  See Also:
  
  Constant Field Values
- CU_JIT_NUM_OPTIONS
```
public static final int CU_JIT_NUM_OPTIONS
```
  enum CUjit_option
  
  See Also:
  
  Constant Field Values
- CU_TARGET_COMPUTE_20
```
public static final int CU_TARGET_COMPUTE_20
```
  enum CUjit_target
  
  See Also:
  
  Constant Field Values
- CU_TARGET_COMPUTE_21
```
public static final int CU_TARGET_COMPUTE_21
```
  enum CUjit_target
  
  See Also:
  
  Constant Field Values
- CU_TARGET_COMPUTE_30
```
public static final int CU_TARGET_COMPUTE_30
```
  enum CUjit_target
  
  See Also:
  
  Constant Field Values
- CU_TARGET_COMPUTE_32
```
public static final int CU_TARGET_COMPUTE_32
```
  enum CUjit_target
  
  See Also:
  
  Constant Field Values
- CU_TARGET_COMPUTE_35
```
public static final int CU_TARGET_COMPUTE_35
```
  enum CUjit_target
  
  See Also:
  
  Constant Field Values
- CU_TARGET_COMPUTE_37
```
public static final int CU_TARGET_COMPUTE_37
```
  enum CUjit_target
  
  See Also:
  
  Constant Field Values
- CU_TARGET_COMPUTE_50
```
public static final int CU_TARGET_COMPUTE_50
```
  enum CUjit_target
  
  See Also:
  
  Constant Field Values
- CU_TARGET_COMPUTE_52
```
public static final int CU_TARGET_COMPUTE_52
```
  enum CUjit_target
  
  See Also:
  
  Constant Field Values
- CU_TARGET_COMPUTE_53
```
public static final int CU_TARGET_COMPUTE_53
```
  enum CUjit_target
  
  See Also:
  
  Constant Field Values
- CU_TARGET_COMPUTE_60
```
public static final int CU_TARGET_COMPUTE_60
```
  enum CUjit_target
  
  See Also:
  
  Constant Field Values
- CU_TARGET_COMPUTE_61
```
public static final int CU_TARGET_COMPUTE_61
```
  enum CUjit_target
  
  See Also:
  
  Constant Field Values
- CU_TARGET_COMPUTE_62
```
public static final int CU_TARGET_COMPUTE_62
```
  enum CUjit_target
  
  See Also:
  
  Constant Field Values
- CU_TARGET_COMPUTE_70
```
public static final int CU_TARGET_COMPUTE_70
```
  enum CUjit_target
  
  See Also:
  
  Constant Field Values
- CU_TARGET_COMPUTE_72
```
public static final int CU_TARGET_COMPUTE_72
```
  enum CUjit_target
  
  See Also:
  
  Constant Field Values
- CU_TARGET_COMPUTE_75
```
public static final int CU_TARGET_COMPUTE_75
```
  enum CUjit_target
  
  See Also:
  
  Constant Field Values
- CU_PREFER_PTX
```
public static final int CU_PREFER_PTX
```
  enum CUjit_fallback
  
  See Also:
  
  Constant Field Values
- CU_PREFER_BINARY
```
public static final int CU_PREFER_BINARY
```
  enum CUjit_fallback
  
  See Also:
  
  Constant Field Values
- CU_JIT_CACHE_OPTION_NONE
```
public static final int CU_JIT_CACHE_OPTION_NONE
```
  enum CUjit_cacheMode
  
  See Also:
  
  Constant Field Values
- CU_JIT_CACHE_OPTION_CG
```
public static final int CU_JIT_CACHE_OPTION_CG
```
  enum CUjit_cacheMode
  
  See Also:
  
  Constant Field Values
- CU_JIT_CACHE_OPTION_CA
```
public static final int CU_JIT_CACHE_OPTION_CA
```
  enum CUjit_cacheMode
  
  See Also:
  
  Constant Field Values
- CU_JIT_INPUT_CUBIN
```
public static final int CU_JIT_INPUT_CUBIN
```
  enum CUjitInputType
  
  See Also:
  
  Constant Field Values
- CU_JIT_INPUT_PTX
```
public static final int CU_JIT_INPUT_PTX
```
  enum CUjitInputType
  
  See Also:
  
  Constant Field Values
- CU_JIT_INPUT_FATBINARY
```
public static final int CU_JIT_INPUT_FATBINARY
```
  enum CUjitInputType
  
  See Also:
  
  Constant Field Values
- CU_JIT_INPUT_OBJECT
```
public static final int CU_JIT_INPUT_OBJECT
```
  enum CUjitInputType
  
  See Also:
  
  Constant Field Values
- CU_JIT_INPUT_LIBRARY
```
public static final int CU_JIT_INPUT_LIBRARY
```
  enum CUjitInputType
  
  See Also:
  
  Constant Field Values
- CU_JIT_NUM_INPUT_TYPES
```
public static final int CU_JIT_NUM_INPUT_TYPES
```
  enum CUjitInputType
  
  See Also:
  
  Constant Field Values
- CU_GRAPHICS_REGISTER_FLAGS_NONE
```
public static final int CU_GRAPHICS_REGISTER_FLAGS_NONE
```
  enum CUgraphicsRegisterFlags
  
  See Also:
  
  Constant Field Values
- CU_GRAPHICS_REGISTER_FLAGS_READ_ONLY
```
public static final int CU_GRAPHICS_REGISTER_FLAGS_READ_ONLY
```
  enum CUgraphicsRegisterFlags
  
  See Also:
  
  Constant Field Values
- CU_GRAPHICS_REGISTER_FLAGS_WRITE_DISCARD
```
public static final int CU_GRAPHICS_REGISTER_FLAGS_WRITE_DISCARD
```
  enum CUgraphicsRegisterFlags
  
  See Also:
  
  Constant Field Values
- CU_GRAPHICS_REGISTER_FLAGS_SURFACE_LDST
```
public static final int CU_GRAPHICS_REGISTER_FLAGS_SURFACE_LDST
```
  enum CUgraphicsRegisterFlags
  
  See Also:
  
  Constant Field Values
- CU_GRAPHICS_REGISTER_FLAGS_TEXTURE_GATHER
```
public static final int CU_GRAPHICS_REGISTER_FLAGS_TEXTURE_GATHER
```
  enum CUgraphicsRegisterFlags
  
  See Also:
  
  Constant Field Values
- CU_GRAPHICS_MAP_RESOURCE_FLAGS_NONE
```
public static final int CU_GRAPHICS_MAP_RESOURCE_FLAGS_NONE
```
  enum CUgraphicsMapResourceFlags
  
  See Also:
  
  Constant Field Values
- CU_GRAPHICS_MAP_RESOURCE_FLAGS_READ_ONLY
```
public static final int CU_GRAPHICS_MAP_RESOURCE_FLAGS_READ_ONLY
```
  enum CUgraphicsMapResourceFlags
  
  See Also:
  
  Constant Field Values
- CU_GRAPHICS_MAP_RESOURCE_FLAGS_WRITE_DISCARD
```
public static final int CU_GRAPHICS_MAP_RESOURCE_FLAGS_WRITE_DISCARD
```
  enum CUgraphicsMapResourceFlags
  
  See Also:
  
  Constant Field Values
- CU_CUBEMAP_FACE_POSITIVE_X
```
public static final int CU_CUBEMAP_FACE_POSITIVE_X
```
  enum CUarray_cubemap_face
  
  See Also:
  
  Constant Field Values
- CU_CUBEMAP_FACE_NEGATIVE_X
```
public static final int CU_CUBEMAP_FACE_NEGATIVE_X
```
  enum CUarray_cubemap_face
  
  See Also:
  
  Constant Field Values
- CU_CUBEMAP_FACE_POSITIVE_Y
```
public static final int CU_CUBEMAP_FACE_POSITIVE_Y
```
  enum CUarray_cubemap_face
  
  See Also:
  
  Constant Field Values
- CU_CUBEMAP_FACE_NEGATIVE_Y
```
public static final int CU_CUBEMAP_FACE_NEGATIVE_Y
```
  enum CUarray_cubemap_face
  
  See Also:
  
  Constant Field Values
- CU_CUBEMAP_FACE_POSITIVE_Z
```
public static final int CU_CUBEMAP_FACE_POSITIVE_Z
```
  enum CUarray_cubemap_face
  
  See Also:
  
  Constant Field Values
- CU_CUBEMAP_FACE_NEGATIVE_Z
```
public static final int CU_CUBEMAP_FACE_NEGATIVE_Z
```
  enum CUarray_cubemap_face
  
  See Also:
  
  Constant Field Values
- CU_LIMIT_STACK_SIZE
```
public static final int CU_LIMIT_STACK_SIZE
```
  enum CUlimit
  
  See Also:
  
  Constant Field Values
- CU_LIMIT_PRINTF_FIFO_SIZE
```
public static final int CU_LIMIT_PRINTF_FIFO_SIZE
```
  enum CUlimit
  
  See Also:
  
  Constant Field Values
- CU_LIMIT_MALLOC_HEAP_SIZE
```
public static final int CU_LIMIT_MALLOC_HEAP_SIZE
```
  enum CUlimit
  
  See Also:
  
  Constant Field Values
- CU_LIMIT_DEV_RUNTIME_SYNC_DEPTH
```
public static final int CU_LIMIT_DEV_RUNTIME_SYNC_DEPTH
```
  enum CUlimit
  
  See Also:
  
  Constant Field Values
- CU_LIMIT_DEV_RUNTIME_PENDING_LAUNCH_COUNT
```
public static final int CU_LIMIT_DEV_RUNTIME_PENDING_LAUNCH_COUNT
```
  enum CUlimit
  
  See Also:
  
  Constant Field Values
- CU_LIMIT_MAX_L2_FETCH_GRANULARITY
```
public static final int CU_LIMIT_MAX_L2_FETCH_GRANULARITY
```
  enum CUlimit
  
  See Also:
  
  Constant Field Values
- CU_LIMIT_MAX
```
public static final int CU_LIMIT_MAX
```
  enum CUlimit
  
  See Also:
  
  Constant Field Values
- CU_RESOURCE_TYPE_ARRAY
```
public static final int CU_RESOURCE_TYPE_ARRAY
```
  enum CUresourcetype
  
  See Also:
  
  Constant Field Values
- CU_RESOURCE_TYPE_MIPMAPPED_ARRAY
```
public static final int CU_RESOURCE_TYPE_MIPMAPPED_ARRAY
```
  enum CUresourcetype
  
  See Also:
  
  Constant Field Values
- CU_RESOURCE_TYPE_LINEAR
```
public static final int CU_RESOURCE_TYPE_LINEAR
```
  enum CUresourcetype
  
  See Also:
  
  Constant Field Values
- CU_RESOURCE_TYPE_PITCH2D
```
public static final int CU_RESOURCE_TYPE_PITCH2D
```
  enum CUresourcetype
  
  See Also:
  
  Constant Field Values
- CU_GRAPH_NODE_TYPE_KERNEL
```
public static final int CU_GRAPH_NODE_TYPE_KERNEL
```
  enum CUgraphNodeType
  
  See Also:
  
  Constant Field Values
- CU_GRAPH_NODE_TYPE_MEMCPY
```
public static final int CU_GRAPH_NODE_TYPE_MEMCPY
```
  enum CUgraphNodeType
  
  See Also:
  
  Constant Field Values
- CU_GRAPH_NODE_TYPE_MEMSET
```
public static final int CU_GRAPH_NODE_TYPE_MEMSET
```
  enum CUgraphNodeType
  
  See Also:
  
  Constant Field Values
- CU_GRAPH_NODE_TYPE_HOST
```
public static final int CU_GRAPH_NODE_TYPE_HOST
```
  enum CUgraphNodeType
  
  See Also:
  
  Constant Field Values
- CU_GRAPH_NODE_TYPE_GRAPH
```
public static final int CU_GRAPH_NODE_TYPE_GRAPH
```
  enum CUgraphNodeType
  
  See Also:
  
  Constant Field Values
- CU_GRAPH_NODE_TYPE_EMPTY
```
public static final int CU_GRAPH_NODE_TYPE_EMPTY
```
  enum CUgraphNodeType
  
  See Also:
  
  Constant Field Values
- CU_GRAPH_NODE_TYPE_COUNT
```
public static final int CU_GRAPH_NODE_TYPE_COUNT
```
  enum CUgraphNodeType
  
  See Also:
  
  Constant Field Values
- CU_STREAM_CAPTURE_STATUS_NONE
```
public static final int CU_STREAM_CAPTURE_STATUS_NONE
```
  enum CUstreamCaptureStatus
  
  See Also:
  
  Constant Field Values
- CU_STREAM_CAPTURE_STATUS_ACTIVE
```
public static final int CU_STREAM_CAPTURE_STATUS_ACTIVE
```
  enum CUstreamCaptureStatus
  
  See Also:
  
  Constant Field Values
- CU_STREAM_CAPTURE_STATUS_INVALIDATED
```
public static final int CU_STREAM_CAPTURE_STATUS_INVALIDATED
```
  enum CUstreamCaptureStatus
  
  See Also:
  
  Constant Field Values
- CU_STREAM_CAPTURE_MODE_GLOBAL
```
public static final int CU_STREAM_CAPTURE_MODE_GLOBAL
```
  enum CUstreamCaptureMode
  
  See Also:
  
  Constant Field Values
- CU_STREAM_CAPTURE_MODE_THREAD_LOCAL
```
public static final int CU_STREAM_CAPTURE_MODE_THREAD_LOCAL
```
  enum CUstreamCaptureMode
  
  See Also:
  
  Constant Field Values
- CU_STREAM_CAPTURE_MODE_RELAXED
```
public static final int CU_STREAM_CAPTURE_MODE_RELAXED
```
  enum CUstreamCaptureMode
  
  See Also:
  
  Constant Field Values
- CUDA_SUCCESS
```
public static final int CUDA_SUCCESS
```
  enum CUresult
  
  See Also:
  
  Constant Field Values
- CUDA_ERROR_INVALID_VALUE
```
public static final int CUDA_ERROR_INVALID_VALUE
```
  enum CUresult
  
  See Also:
  
  Constant Field Values
- CUDA_ERROR_OUT_OF_MEMORY
```
public static final int CUDA_ERROR_OUT_OF_MEMORY
```
  enum CUresult
  
  See Also:
  
  Constant Field Values
- CUDA_ERROR_NOT_INITIALIZED
```
public static final int CUDA_ERROR_NOT_INITIALIZED
```
  enum CUresult
  
  See Also:
  
  Constant Field Values
- CUDA_ERROR_DEINITIALIZED
```
public static final int CUDA_ERROR_DEINITIALIZED
```
  enum CUresult
  
  See Also:
  
  Constant Field Values
- CUDA_ERROR_PROFILER_DISABLED
```
public static final int CUDA_ERROR_PROFILER_DISABLED
```
  enum CUresult
  
  See Also:
  
  Constant Field Values
- CUDA_ERROR_PROFILER_NOT_INITIALIZED
```
public static final int CUDA_ERROR_PROFILER_NOT_INITIALIZED
```
  enum CUresult
  
  See Also:
  
  Constant Field Values
- CUDA_ERROR_PROFILER_ALREADY_STARTED
```
public static final int CUDA_ERROR_PROFILER_ALREADY_STARTED
```
  enum CUresult
  
  See Also:
  
  Constant Field Values
- CUDA_ERROR_PROFILER_ALREADY_STOPPED
```
public static final int CUDA_ERROR_PROFILER_ALREADY_STOPPED
```
  enum CUresult
  
  See Also:
  
  Constant Field Values
- CUDA_ERROR_NO_DEVICE
```
public static final int CUDA_ERROR_NO_DEVICE
```
  enum CUresult
  
  See Also:
  
  Constant Field Values
- CUDA_ERROR_INVALID_DEVICE
```
public static final int CUDA_ERROR_INVALID_DEVICE
```
  enum CUresult
  
  See Also:
  
  Constant Field Values
- CUDA_ERROR_INVALID_IMAGE
```
public static final int CUDA_ERROR_INVALID_IMAGE
```
  enum CUresult
  
  See Also:
  
  Constant Field Values
- CUDA_ERROR_INVALID_CONTEXT
```
public static final int CUDA_ERROR_INVALID_CONTEXT
```
  enum CUresult
  
  See Also:
  
  Constant Field Values
- CUDA_ERROR_CONTEXT_ALREADY_CURRENT
```
public static final int CUDA_ERROR_CONTEXT_ALREADY_CURRENT
```
  enum CUresult
  
  See Also:
  
  Constant Field Values
- CUDA_ERROR_MAP_FAILED
```
public static final int CUDA_ERROR_MAP_FAILED
```
  enum CUresult
  
  See Also:
  
  Constant Field Values
- CUDA_ERROR_UNMAP_FAILED
```
public static final int CUDA_ERROR_UNMAP_FAILED
```
  enum CUresult
  
  See Also:
  
  Constant Field Values
- CUDA_ERROR_ARRAY_IS_MAPPED
```
public static final int CUDA_ERROR_ARRAY_IS_MAPPED
```
  enum CUresult
  
  See Also:
  
  Constant Field Values
- CUDA_ERROR_ALREADY_MAPPED
```
public static final int CUDA_ERROR_ALREADY_MAPPED
```
  enum CUresult
  
  See Also:
  
  Constant Field Values
- CUDA_ERROR_NO_BINARY_FOR_GPU
```
public static final int CUDA_ERROR_NO_BINARY_FOR_GPU
```
  enum CUresult
  
  See Also:
  
  Constant Field Values
- CUDA_ERROR_ALREADY_ACQUIRED
```
public static final int CUDA_ERROR_ALREADY_ACQUIRED
```
  enum CUresult
  
  See Also:
  
  Constant Field Values
- CUDA_ERROR_NOT_MAPPED
```
public static final int CUDA_ERROR_NOT_MAPPED
```
  enum CUresult
  
  See Also:
  
  Constant Field Values
- CUDA_ERROR_NOT_MAPPED_AS_ARRAY
```
public static final int CUDA_ERROR_NOT_MAPPED_AS_ARRAY
```
  enum CUresult
  
  See Also:
  
  Constant Field Values
- CUDA_ERROR_NOT_MAPPED_AS_POINTER
```
public static final int CUDA_ERROR_NOT_MAPPED_AS_POINTER
```
  enum CUresult
  
  See Also:
  
  Constant Field Values
- CUDA_ERROR_ECC_UNCORRECTABLE
```
public static final int CUDA_ERROR_ECC_UNCORRECTABLE
```
  enum CUresult
  
  See Also:
  
  Constant Field Values
- CUDA_ERROR_UNSUPPORTED_LIMIT
```
public static final int CUDA_ERROR_UNSUPPORTED_LIMIT
```
  enum CUresult
  
  See Also:
  
  Constant Field Values
- CUDA_ERROR_CONTEXT_ALREADY_IN_USE
```
public static final int CUDA_ERROR_CONTEXT_ALREADY_IN_USE
```
  enum CUresult
  
  See Also:
  
  Constant Field Values
- CUDA_ERROR_PEER_ACCESS_UNSUPPORTED
```
public static final int CUDA_ERROR_PEER_ACCESS_UNSUPPORTED
```
  enum CUresult
  
  See Also:
  
  Constant Field Values
- CUDA_ERROR_INVALID_PTX
```
public static final int CUDA_ERROR_INVALID_PTX
```
  enum CUresult
  
  See Also:
  
  Constant Field Values
- CUDA_ERROR_INVALID_GRAPHICS_CONTEXT
```
public static final int CUDA_ERROR_INVALID_GRAPHICS_CONTEXT
```
  enum CUresult
  
  See Also:
  
  Constant Field Values
- CUDA_ERROR_NVLINK_UNCORRECTABLE
```
public static final int CUDA_ERROR_NVLINK_UNCORRECTABLE
```
  enum CUresult
  
  See Also:
  
  Constant Field Values
- CUDA_ERROR_JIT_COMPILER_NOT_FOUND
```
public static final int CUDA_ERROR_JIT_COMPILER_NOT_FOUND
```
  enum CUresult
  
  See Also:
  
  Constant Field Values
- CUDA_ERROR_INVALID_SOURCE
```
public static final int CUDA_ERROR_INVALID_SOURCE
```
  enum CUresult
  
  See Also:
  
  Constant Field Values
- CUDA_ERROR_FILE_NOT_FOUND
```
public static final int CUDA_ERROR_FILE_NOT_FOUND
```
  enum CUresult
  
  See Also:
  
  Constant Field Values
- CUDA_ERROR_SHARED_OBJECT_SYMBOL_NOT_FOUND
```
public static final int CUDA_ERROR_SHARED_OBJECT_SYMBOL_NOT_FOUND
```
  enum CUresult
  
  See Also:
  
  Constant Field Values
- CUDA_ERROR_SHARED_OBJECT_INIT_FAILED
```
public static final int CUDA_ERROR_SHARED_OBJECT_INIT_FAILED
```
  enum CUresult
  
  See Also:
  
  Constant Field Values
- CUDA_ERROR_OPERATING_SYSTEM
```
public static final int CUDA_ERROR_OPERATING_SYSTEM
```
  enum CUresult
  
  See Also:
  
  Constant Field Values
- CUDA_ERROR_INVALID_HANDLE
```
public static final int CUDA_ERROR_INVALID_HANDLE
```
  enum CUresult
  
  See Also:
  
  Constant Field Values
- CUDA_ERROR_ILLEGAL_STATE
```
public static final int CUDA_ERROR_ILLEGAL_STATE
```
  enum CUresult
  
  See Also:
  
  Constant Field Values
- CUDA_ERROR_NOT_FOUND
```
public static final int CUDA_ERROR_NOT_FOUND
```
  enum CUresult
  
  See Also:
  
  Constant Field Values
- CUDA_ERROR_NOT_READY
```
public static final int CUDA_ERROR_NOT_READY
```
  enum CUresult
  
  See Also:
  
  Constant Field Values
- CUDA_ERROR_ILLEGAL_ADDRESS
```
public static final int CUDA_ERROR_ILLEGAL_ADDRESS
```
  enum CUresult
  
  See Also:
  
  Constant Field Values
- CUDA_ERROR_LAUNCH_OUT_OF_RESOURCES
```
public static final int CUDA_ERROR_LAUNCH_OUT_OF_RESOURCES
```
  enum CUresult
  
  See Also:
  
  Constant Field Values
- CUDA_ERROR_LAUNCH_TIMEOUT
```
public static final int CUDA_ERROR_LAUNCH_TIMEOUT
```
  enum CUresult
  
  See Also:
  
  Constant Field Values
- CUDA_ERROR_LAUNCH_INCOMPATIBLE_TEXTURING
```
public static final int CUDA_ERROR_LAUNCH_INCOMPATIBLE_TEXTURING
```
  enum CUresult
  
  See Also:
  
  Constant Field Values
- CUDA_ERROR_PEER_ACCESS_ALREADY_ENABLED
```
public static final int CUDA_ERROR_PEER_ACCESS_ALREADY_ENABLED
```
  enum CUresult
  
  See Also:
  
  Constant Field Values
- CUDA_ERROR_PEER_ACCESS_NOT_ENABLED
```
public static final int CUDA_ERROR_PEER_ACCESS_NOT_ENABLED
```
  enum CUresult
  
  See Also:
  
  Constant Field Values
- CUDA_ERROR_PRIMARY_CONTEXT_ACTIVE
```
public static final int CUDA_ERROR_PRIMARY_CONTEXT_ACTIVE
```
  enum CUresult
  
  See Also:
  
  Constant Field Values
- CUDA_ERROR_CONTEXT_IS_DESTROYED
```
public static final int CUDA_ERROR_CONTEXT_IS_DESTROYED
```
  enum CUresult
  
  See Also:
  
  Constant Field Values
- CUDA_ERROR_ASSERT
```
public static final int CUDA_ERROR_ASSERT
```
  enum CUresult
  
  See Also:
  
  Constant Field Values
- CUDA_ERROR_TOO_MANY_PEERS
```
public static final int CUDA_ERROR_TOO_MANY_PEERS
```
  enum CUresult
  
  See Also:
  
  Constant Field Values
- CUDA_ERROR_HOST_MEMORY_ALREADY_REGISTERED
```
public static final int CUDA_ERROR_HOST_MEMORY_ALREADY_REGISTERED
```
  enum CUresult
  
  See Also:
  
  Constant Field Values
- CUDA_ERROR_HOST_MEMORY_NOT_REGISTERED
```
public static final int CUDA_ERROR_HOST_MEMORY_NOT_REGISTERED
```
  enum CUresult
  
  See Also:
  
  Constant Field Values
- CUDA_ERROR_HARDWARE_STACK_ERROR
```
public static final int CUDA_ERROR_HARDWARE_STACK_ERROR
```
  enum CUresult
  
  See Also:
  
  Constant Field Values
- CUDA_ERROR_ILLEGAL_INSTRUCTION
```
public static final int CUDA_ERROR_ILLEGAL_INSTRUCTION
```
  enum CUresult
  
  See Also:
  
  Constant Field Values
- CUDA_ERROR_MISALIGNED_ADDRESS
```
public static final int CUDA_ERROR_MISALIGNED_ADDRESS
```
  enum CUresult
  
  See Also:
  
  Constant Field Values
- CUDA_ERROR_INVALID_ADDRESS_SPACE
```
public static final int CUDA_ERROR_INVALID_ADDRESS_SPACE
```
  enum CUresult
  
  See Also:
  
  Constant Field Values
- CUDA_ERROR_INVALID_PC
```
public static final int CUDA_ERROR_INVALID_PC
```
  enum CUresult
  
  See Also:
  
  Constant Field Values
- CUDA_ERROR_LAUNCH_FAILED
```
public static final int CUDA_ERROR_LAUNCH_FAILED
```
  enum CUresult
  
  See Also:
  
  Constant Field Values
- CUDA_ERROR_COOPERATIVE_LAUNCH_TOO_LARGE
```
public static final int CUDA_ERROR_COOPERATIVE_LAUNCH_TOO_LARGE
```
  enum CUresult
  
  See Also:
  
  Constant Field Values
- CUDA_ERROR_NOT_PERMITTED
```
public static final int CUDA_ERROR_NOT_PERMITTED
```
  enum CUresult
  
  See Also:
  
  Constant Field Values
- CUDA_ERROR_NOT_SUPPORTED
```
public static final int CUDA_ERROR_NOT_SUPPORTED
```
  enum CUresult
  
  See Also:
  
  Constant Field Values
- CUDA_ERROR_SYSTEM_NOT_READY
```
public static final int CUDA_ERROR_SYSTEM_NOT_READY
```
  enum CUresult
  
  See Also:
  
  Constant Field Values
- CUDA_ERROR_SYSTEM_DRIVER_MISMATCH
```
public static final int CUDA_ERROR_SYSTEM_DRIVER_MISMATCH
```
  enum CUresult
  
  See Also:
  
  Constant Field Values
- CUDA_ERROR_COMPAT_NOT_SUPPORTED_ON_DEVICE
```
public static final int CUDA_ERROR_COMPAT_NOT_SUPPORTED_ON_DEVICE
```
  enum CUresult
  
  See Also:
  
  Constant Field Values
- CUDA_ERROR_STREAM_CAPTURE_UNSUPPORTED
```
public static final int CUDA_ERROR_STREAM_CAPTURE_UNSUPPORTED
```
  enum CUresult
  
  See Also:
  
  Constant Field Values
- CUDA_ERROR_STREAM_CAPTURE_INVALIDATED
```
public static final int CUDA_ERROR_STREAM_CAPTURE_INVALIDATED
```
  enum CUresult
  
  See Also:
  
  Constant Field Values
- CUDA_ERROR_STREAM_CAPTURE_MERGE
```
public static final int CUDA_ERROR_STREAM_CAPTURE_MERGE
```
  enum CUresult
  
  See Also:
  
  Constant Field Values
- CUDA_ERROR_STREAM_CAPTURE_UNMATCHED
```
public static final int CUDA_ERROR_STREAM_CAPTURE_UNMATCHED
```
  enum CUresult
  
  See Also:
  
  Constant Field Values
- CUDA_ERROR_STREAM_CAPTURE_UNJOINED
```
public static final int CUDA_ERROR_STREAM_CAPTURE_UNJOINED
```
  enum CUresult
  
  See Also:
  
  Constant Field Values
- CUDA_ERROR_STREAM_CAPTURE_ISOLATION
```
public static final int CUDA_ERROR_STREAM_CAPTURE_ISOLATION
```
  enum CUresult
  
  See Also:
  
  Constant Field Values
- CUDA_ERROR_STREAM_CAPTURE_IMPLICIT
```
public static final int CUDA_ERROR_STREAM_CAPTURE_IMPLICIT
```
  enum CUresult
  
  See Also:
  
  Constant Field Values
- CUDA_ERROR_CAPTURED_EVENT
```
public static final int CUDA_ERROR_CAPTURED_EVENT
```
  enum CUresult
  
  See Also:
  
  Constant Field Values
- CUDA_ERROR_STREAM_CAPTURE_WRONG_THREAD
```
public static final int CUDA_ERROR_STREAM_CAPTURE_WRONG_THREAD
```
  enum CUresult
  
  See Also:
  
  Constant Field Values
- CUDA_ERROR_TIMEOUT
```
public static final int CUDA_ERROR_TIMEOUT
```
  enum CUresult
  
  See Also:
  
  Constant Field Values
- CUDA_ERROR_GRAPH_EXEC_UPDATE_FAILURE
```
public static final int CUDA_ERROR_GRAPH_EXEC_UPDATE_FAILURE
```
  enum CUresult
  
  See Also:
  
  Constant Field Values
- CUDA_ERROR_UNKNOWN
```
public static final int CUDA_ERROR_UNKNOWN
```
  enum CUresult
  
  See Also:
  
  Constant Field Values
- CU_DEVICE_P2P_ATTRIBUTE_PERFORMANCE_RANK
```
public static final int CU_DEVICE_P2P_ATTRIBUTE_PERFORMANCE_RANK
```
  enum CUdevice_P2PAttribute
  
  See Also:
  
  Constant Field Values
- CU_DEVICE_P2P_ATTRIBUTE_ACCESS_SUPPORTED
```
public static final int CU_DEVICE_P2P_ATTRIBUTE_ACCESS_SUPPORTED
```
  enum CUdevice_P2PAttribute
  
  See Also:
  
  Constant Field Values
- CU_DEVICE_P2P_ATTRIBUTE_NATIVE_ATOMIC_SUPPORTED
```
public static final int CU_DEVICE_P2P_ATTRIBUTE_NATIVE_ATOMIC_SUPPORTED
```
  enum CUdevice_P2PAttribute
  
  See Also:
  
  Constant Field Values
- CU_DEVICE_P2P_ATTRIBUTE_ACCESS_ACCESS_SUPPORTED
```
public static final int CU_DEVICE_P2P_ATTRIBUTE_ACCESS_ACCESS_SUPPORTED
```
  enum CUdevice_P2PAttribute
  
  See Also:
  
  Constant Field Values
- CU_DEVICE_P2P_ATTRIBUTE_CUDA_ARRAY_ACCESS_SUPPORTED
```
public static final int CU_DEVICE_P2P_ATTRIBUTE_CUDA_ARRAY_ACCESS_SUPPORTED
```
  enum CUdevice_P2PAttribute
  
  See Also:
  
  Constant Field Values
- CU_MEMHOSTALLOC_PORTABLE
```
public static final int CU_MEMHOSTALLOC_PORTABLE
```
  If set, host memory is portable between CUDA contexts. Flag for ::cuMemHostAlloc()
  
  See Also:
  
  Constant Field Values
- CU_MEMHOSTALLOC_DEVICEMAP
```
public static final int CU_MEMHOSTALLOC_DEVICEMAP
```
  If set, host memory is mapped into CUDA address space and ::cuMemHostGetDevicePointer() may be called on the host pointer. Flag for ::cuMemHostAlloc()
  
  See Also:
  
  Constant Field Values
- CU_MEMHOSTALLOC_WRITECOMBINED
```
public static final int CU_MEMHOSTALLOC_WRITECOMBINED
```
  If set, host memory is allocated as write-combined - fast to write, faster to DMA, slow to read except via SSE4 streaming load instruction (MOVNTDQA). Flag for ::cuMemHostAlloc()
  
  See Also:
  
  Constant Field Values
- CU_MEMHOSTREGISTER_PORTABLE
```
public static final int CU_MEMHOSTREGISTER_PORTABLE
```
  If set, host memory is portable between CUDA contexts. Flag for ::cuMemHostRegister()
  
  See Also:
  
  Constant Field Values
- CU_MEMHOSTREGISTER_DEVICEMAP
```
public static final int CU_MEMHOSTREGISTER_DEVICEMAP
```
  If set, host memory is mapped into CUDA address space and ::cuMemHostGetDevicePointer() may be called on the host pointer. Flag for ::cuMemHostRegister()
  
  See Also:
  
  Constant Field Values
- CU_MEMHOSTREGISTER_IOMEMORY
```
public static final int CU_MEMHOSTREGISTER_IOMEMORY
```
  If set, the passed memory pointer is treated as pointing to some memory-mapped I/O space, e.g. belonging to a third-party PCIe device. On Windows the flag is a no-op. On Linux that memory is marked as non cache-coherent for the GPU and is expected to be physically contiguous. It may return CUDA_ERROR_NOT_PERMITTED if run as an unprivileged user, CUDA_ERROR_NOT_SUPPORTED on older Linux kernel versions. On all other platforms, it is not supported and CUDA_ERROR_NOT_SUPPORTED is returned. Flag for ::cuMemHostRegister()
  
  See Also:
  
  Constant Field Values
- CU_RES_VIEW_FORMAT_NONE
```
public static final int CU_RES_VIEW_FORMAT_NONE
```
  enum CUresourceViewFormat
  
  See Also:
  
  Constant Field Values
- CU_RES_VIEW_FORMAT_UINT_1X8
```
public static final int CU_RES_VIEW_FORMAT_UINT_1X8
```
  enum CUresourceViewFormat
  
  See Also:
  
  Constant Field Values
- CU_RES_VIEW_FORMAT_UINT_2X8
```
public static final int CU_RES_VIEW_FORMAT_UINT_2X8
```
  enum CUresourceViewFormat
  
  See Also:
  
  Constant Field Values
- CU_RES_VIEW_FORMAT_UINT_4X8
```
public static final int CU_RES_VIEW_FORMAT_UINT_4X8
```
  enum CUresourceViewFormat
  
  See Also:
  
  Constant Field Values
- CU_RES_VIEW_FORMAT_SINT_1X8
```
public static final int CU_RES_VIEW_FORMAT_SINT_1X8
```
  enum CUresourceViewFormat
  
  See Also:
  
  Constant Field Values
- CU_RES_VIEW_FORMAT_SINT_2X8
```
public static final int CU_RES_VIEW_FORMAT_SINT_2X8
```
  enum CUresourceViewFormat
  
  See Also:
  
  Constant Field Values
- CU_RES_VIEW_FORMAT_SINT_4X8
```
public static final int CU_RES_VIEW_FORMAT_SINT_4X8
```
  enum CUresourceViewFormat
  
  See Also:
  
  Constant Field Values
- CU_RES_VIEW_FORMAT_UINT_1X16
```
public static final int CU_RES_VIEW_FORMAT_UINT_1X16
```
  enum CUresourceViewFormat
  
  See Also:
  
  Constant Field Values
- CU_RES_VIEW_FORMAT_UINT_2X16
```
public static final int CU_RES_VIEW_FORMAT_UINT_2X16
```
  enum CUresourceViewFormat
  
  See Also:
  
  Constant Field Values
- CU_RES_VIEW_FORMAT_UINT_4X16
```
public static final int CU_RES_VIEW_FORMAT_UINT_4X16
```
  enum CUresourceViewFormat
  
  See Also:
  
  Constant Field Values
- CU_RES_VIEW_FORMAT_SINT_1X16
```
public static final int CU_RES_VIEW_FORMAT_SINT_1X16
```
  enum CUresourceViewFormat
  
  See Also:
  
  Constant Field Values
- CU_RES_VIEW_FORMAT_SINT_2X16
```
public static final int CU_RES_VIEW_FORMAT_SINT_2X16
```
  enum CUresourceViewFormat
  
  See Also:
  
  Constant Field Values
- CU_RES_VIEW_FORMAT_SINT_4X16
```
public static final int CU_RES_VIEW_FORMAT_SINT_4X16
```
  enum CUresourceViewFormat
  
  See Also:
  
  Constant Field Values
- CU_RES_VIEW_FORMAT_UINT_1X32
```
public static final int CU_RES_VIEW_FORMAT_UINT_1X32
```
  enum CUresourceViewFormat
  
  See Also:
  
  Constant Field Values
- CU_RES_VIEW_FORMAT_UINT_2X32
```
public static final int CU_RES_VIEW_FORMAT_UINT_2X32
```
  enum CUresourceViewFormat
  
  See Also:
  
  Constant Field Values
- CU_RES_VIEW_FORMAT_UINT_4X32
```
public static final int CU_RES_VIEW_FORMAT_UINT_4X32
```
  enum CUresourceViewFormat
  
  See Also:
  
  Constant Field Values
- CU_RES_VIEW_FORMAT_SINT_1X32
```
public static final int CU_RES_VIEW_FORMAT_SINT_1X32
```
  enum CUresourceViewFormat
  
  See Also:
  
  Constant Field Values
- CU_RES_VIEW_FORMAT_SINT_2X32
```
public static final int CU_RES_VIEW_FORMAT_SINT_2X32
```
  enum CUresourceViewFormat
  
  See Also:
  
  Constant Field Values
- CU_RES_VIEW_FORMAT_SINT_4X32
```
public static final int CU_RES_VIEW_FORMAT_SINT_4X32
```
  enum CUresourceViewFormat
  
  See Also:
  
  Constant Field Values
- CU_RES_VIEW_FORMAT_FLOAT_1X16
```
public static final int CU_RES_VIEW_FORMAT_FLOAT_1X16
```
  enum CUresourceViewFormat
  
  See Also:
  
  Constant Field Values
- CU_RES_VIEW_FORMAT_FLOAT_2X16
```
public static final int CU_RES_VIEW_FORMAT_FLOAT_2X16
```
  enum CUresourceViewFormat
  
  See Also:
  
  Constant Field Values
- CU_RES_VIEW_FORMAT_FLOAT_4X16
```
public static final int CU_RES_VIEW_FORMAT_FLOAT_4X16
```
  enum CUresourceViewFormat
  
  See Also:
  
  Constant Field Values
- CU_RES_VIEW_FORMAT_FLOAT_1X32
```
public static final int CU_RES_VIEW_FORMAT_FLOAT_1X32
```
  enum CUresourceViewFormat
  
  See Also:
  
  Constant Field Values
- CU_RES_VIEW_FORMAT_FLOAT_2X32
```
public static final int CU_RES_VIEW_FORMAT_FLOAT_2X32
```
  enum CUresourceViewFormat
  
  See Also:
  
  Constant Field Values
- CU_RES_VIEW_FORMAT_FLOAT_4X32
```
public static final int CU_RES_VIEW_FORMAT_FLOAT_4X32
```
  enum CUresourceViewFormat
  
  See Also:
  
  Constant Field Values
- CU_RES_VIEW_FORMAT_UNSIGNED_BC1
```
public static final int CU_RES_VIEW_FORMAT_UNSIGNED_BC1
```
  enum CUresourceViewFormat
  
  See Also:
  
  Constant Field Values
- CU_RES_VIEW_FORMAT_UNSIGNED_BC2
```
public static final int CU_RES_VIEW_FORMAT_UNSIGNED_BC2
```
  enum CUresourceViewFormat
  
  See Also:
  
  Constant Field Values
- CU_RES_VIEW_FORMAT_UNSIGNED_BC3
```
public static final int CU_RES_VIEW_FORMAT_UNSIGNED_BC3
```
  enum CUresourceViewFormat
  
  See Also:
  
  Constant Field Values
- CU_RES_VIEW_FORMAT_UNSIGNED_BC4
```
public static final int CU_RES_VIEW_FORMAT_UNSIGNED_BC4
```
  enum CUresourceViewFormat
  
  See Also:
  
  Constant Field Values
- CU_RES_VIEW_FORMAT_SIGNED_BC4
```
public static final int CU_RES_VIEW_FORMAT_SIGNED_BC4
```
  enum CUresourceViewFormat
  
  See Also:
  
  Constant Field Values
- CU_RES_VIEW_FORMAT_UNSIGNED_BC5
```
public static final int CU_RES_VIEW_FORMAT_UNSIGNED_BC5
```
  enum CUresourceViewFormat
  
  See Also:
  
  Constant Field Values
- CU_RES_VIEW_FORMAT_SIGNED_BC5
```
public static final int CU_RES_VIEW_FORMAT_SIGNED_BC5
```
  enum CUresourceViewFormat
  
  See Also:
  
  Constant Field Values
- CU_RES_VIEW_FORMAT_UNSIGNED_BC6H
```
public static final int CU_RES_VIEW_FORMAT_UNSIGNED_BC6H
```
  enum CUresourceViewFormat
  
  See Also:
  
  Constant Field Values
- CU_RES_VIEW_FORMAT_SIGNED_BC6H
```
public static final int CU_RES_VIEW_FORMAT_SIGNED_BC6H
```
  enum CUresourceViewFormat
  
  See Also:
  
  Constant Field Values
- CU_RES_VIEW_FORMAT_UNSIGNED_BC7
```
public static final int CU_RES_VIEW_FORMAT_UNSIGNED_BC7
```
  enum CUresourceViewFormat
  
  See Also:
  
  Constant Field Values
- CU_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_FD
```
public static final int CU_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_FD
```
  enum CUexternalMemoryHandleType
  
  See Also:
  
  Constant Field Values
- CU_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32
```
public static final int CU_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32
```
  enum CUexternalMemoryHandleType
  
  See Also:
  
  Constant Field Values
- CU_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_KMT
```
public static final int CU_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_KMT
```
  enum CUexternalMemoryHandleType
  
  See Also:
  
  Constant Field Values
- CU_EXTERNAL_MEMORY_HANDLE_TYPE_D3D12_HEAP
```
public static final int CU_EXTERNAL_MEMORY_HANDLE_TYPE_D3D12_HEAP
```
  enum CUexternalMemoryHandleType
  
  See Also:
  
  Constant Field Values
- CU_EXTERNAL_MEMORY_HANDLE_TYPE_D3D12_RESOURCE
```
public static final int CU_EXTERNAL_MEMORY_HANDLE_TYPE_D3D12_RESOURCE
```
  enum CUexternalMemoryHandleType
  
  See Also:
  
  Constant Field Values
- CU_EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_RESOURCE
```
public static final int CU_EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_RESOURCE
```
  enum CUexternalMemoryHandleType
  
  See Also:
  
  Constant Field Values
- CU_EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_RESOURCE_KMT
```
public static final int CU_EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_RESOURCE_KMT
```
  enum CUexternalMemoryHandleType
  
  See Also:
  
  Constant Field Values
- CU_EXTERNAL_MEMORY_HANDLE_TYPE_NVSCIBUF
```
public static final int CU_EXTERNAL_MEMORY_HANDLE_TYPE_NVSCIBUF
```
  enum CUexternalMemoryHandleType
  
  See Also:
  
  Constant Field Values
- CUDA_EXTERNAL_MEMORY_DEDICATED
```
public static final int CUDA_EXTERNAL_MEMORY_DEDICATED
```
  Indicates that the external memory object is a dedicated resource
  
  See Also:
  
  Constant Field Values
- CUDA_EXTERNAL_SEMAPHORE_SIGNAL_SKIP_NVSCIBUF_MEMSYNC
```
public static final int CUDA_EXTERNAL_SEMAPHORE_SIGNAL_SKIP_NVSCIBUF_MEMSYNC
```
  When the /p flags parameter of ::CUDA_EXTERNAL_SEMAPHORE_SIGNAL_PARAMS contains this flag, it indicates that signaling an external semaphore object should skip performing appropriate memory synchronization operations over all the external memory objects that are imported as ::CU_EXTERNAL_MEMORY_HANDLE_TYPE_NVSCIBUF, which otherwise are performed by default to ensure data coherency with other importers of the same NvSciBuf memory objects.
  
  See Also:
  
  Constant Field Values
- CUDA_EXTERNAL_SEMAPHORE_WAIT_SKIP_NVSCIBUF_MEMSYNC
```
public static final int CUDA_EXTERNAL_SEMAPHORE_WAIT_SKIP_NVSCIBUF_MEMSYNC
```
  When the /p flags parameter of ::CUDA_EXTERNAL_SEMAPHORE_WAIT_PARAMS contains this flag, it indicates that waiting on an external semaphore object should skip performing appropriate memory synchronization operations over all the external memory objects that are imported as ::CU_EXTERNAL_MEMORY_HANDLE_TYPE_NVSCIBUF, which otherwise are performed by default to ensure data coherency with other importers of the same NvSciBuf memory objects.
  
  See Also:
  
  Constant Field Values
- CUDA_NVSCISYNC_ATTR_SIGNAL
```
public static final int CUDA_NVSCISYNC_ATTR_SIGNAL
```
  When /p flags of ::cuDeviceGetNvSciSyncAttributes is set to this, it indicates that application needs signaler specific NvSciSyncAttr to be filled by ::cuDeviceGetNvSciSyncAttributes.
  
  See Also:
  
  Constant Field Values
- CUDA_NVSCISYNC_ATTR_WAIT
```
public static final int CUDA_NVSCISYNC_ATTR_WAIT
```
  When /p flags of ::cuDeviceGetNvSciSyncAttributes is set to this, it indicates that application needs waiter specific NvSciSyncAttr to be filled by ::cuDeviceGetNvSciSyncAttributes.
  
  See Also:
  
  Constant Field Values
- CU_EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_FD
```
public static final int CU_EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_FD
```
  enum CUexternalSemaphoreHandleType
  
  See Also:
  
  Constant Field Values
- CU_EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_WIN32
```
public static final int CU_EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_WIN32
```
  enum CUexternalSemaphoreHandleType
  
  See Also:
  
  Constant Field Values
- CU_EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_WIN32_KMT
```
public static final int CU_EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_WIN32_KMT
```
  enum CUexternalSemaphoreHandleType
  
  See Also:
  
  Constant Field Values
- CU_EXTERNAL_SEMAPHORE_HANDLE_TYPE_D3D12_FENCE
```
public static final int CU_EXTERNAL_SEMAPHORE_HANDLE_TYPE_D3D12_FENCE
```
  enum CUexternalSemaphoreHandleType
  
  See Also:
  
  Constant Field Values
- CU_EXTERNAL_SEMAPHORE_HANDLE_TYPE_D3D11_FENCE
```
public static final int CU_EXTERNAL_SEMAPHORE_HANDLE_TYPE_D3D11_FENCE
```
  enum CUexternalSemaphoreHandleType
  
  See Also:
  
  Constant Field Values
- CU_EXTERNAL_SEMAPHORE_HANDLE_TYPE_NVSCISYNC
```
public static final int CU_EXTERNAL_SEMAPHORE_HANDLE_TYPE_NVSCISYNC
```
  enum CUexternalSemaphoreHandleType
  
  See Also:
  
  Constant Field Values
- CU_EXTERNAL_SEMAPHORE_HANDLE_TYPE_D3D11_KEYED_MUTEX
```
public static final int CU_EXTERNAL_SEMAPHORE_HANDLE_TYPE_D3D11_KEYED_MUTEX
```
  enum CUexternalSemaphoreHandleType
  
  See Also:
  
  Constant Field Values
- CU_EXTERNAL_SEMAPHORE_HANDLE_TYPE_D3D11_KEYED_MUTEX_KMT
```
public static final int CU_EXTERNAL_SEMAPHORE_HANDLE_TYPE_D3D11_KEYED_MUTEX_KMT
```
  enum CUexternalSemaphoreHandleType
  
  See Also:
  
  Constant Field Values
- CU_MEM_HANDLE_TYPE_POSIX_FILE_DESCRIPTOR
```
public static final int CU_MEM_HANDLE_TYPE_POSIX_FILE_DESCRIPTOR
```
  enum CUmemAllocationHandleType
  
  See Also:
  
  Constant Field Values
- CU_MEM_HANDLE_TYPE_WIN32
```
public static final int CU_MEM_HANDLE_TYPE_WIN32
```
  enum CUmemAllocationHandleType
  
  See Also:
  
  Constant Field Values
- CU_MEM_HANDLE_TYPE_WIN32_KMT
```
public static final int CU_MEM_HANDLE_TYPE_WIN32_KMT
```
  enum CUmemAllocationHandleType
  
  See Also:
  
  Constant Field Values
- CU_MEM_HANDLE_TYPE_MAX
```
public static final int CU_MEM_HANDLE_TYPE_MAX
```
  enum CUmemAllocationHandleType
  
  See Also:
  
  Constant Field Values
- CU_MEM_ACCESS_FLAGS_PROT_NONE
```
public static final int CU_MEM_ACCESS_FLAGS_PROT_NONE
```
  enum CUmemAccess_flags
  
  See Also:
  
  Constant Field Values
- CU_MEM_ACCESS_FLAGS_PROT_READ
```
public static final int CU_MEM_ACCESS_FLAGS_PROT_READ
```
  enum CUmemAccess_flags
  
  See Also:
  
  Constant Field Values
- CU_MEM_ACCESS_FLAGS_PROT_READWRITE
```
public static final int CU_MEM_ACCESS_FLAGS_PROT_READWRITE
```
  enum CUmemAccess_flags
  
  See Also:
  
  Constant Field Values
- CU_MEM_ACCESS_FLAGS_PROT_MAX
```
public static final int CU_MEM_ACCESS_FLAGS_PROT_MAX
```
  enum CUmemAccess_flags
  
  See Also:
  
  Constant Field Values
- CU_MEM_LOCATION_TYPE_INVALID
```
public static final int CU_MEM_LOCATION_TYPE_INVALID
```
  enum CUmemLocationType
  
  See Also:
  
  Constant Field Values
- CU_MEM_LOCATION_TYPE_DEVICE
```
public static final int CU_MEM_LOCATION_TYPE_DEVICE
```
  enum CUmemLocationType
  
  See Also:
  
  Constant Field Values
- CU_MEM_LOCATION_TYPE_MAX
```
public static final int CU_MEM_LOCATION_TYPE_MAX
```
  enum CUmemLocationType
  
  See Also:
  
  Constant Field Values
- CU_MEM_ALLOCATION_TYPE_INVALID
```
public static final int CU_MEM_ALLOCATION_TYPE_INVALID
```
  enum CUmemAllocationType
  
  See Also:
  
  Constant Field Values
- CU_MEM_ALLOCATION_TYPE_PINNED
```
public static final int CU_MEM_ALLOCATION_TYPE_PINNED
```
  enum CUmemAllocationType
  
  See Also:
  
  Constant Field Values
- CU_MEM_ALLOCATION_TYPE_MAX
```
public static final int CU_MEM_ALLOCATION_TYPE_MAX
```
  enum CUmemAllocationType
  
  See Also:
  
  Constant Field Values
- CU_MEM_ALLOC_GRANULARITY_MINIMUM
```
public static final int CU_MEM_ALLOC_GRANULARITY_MINIMUM
```
  enum CUmemAllocationGranularity_flags
  
  See Also:
  
  Constant Field Values
- CU_MEM_ALLOC_GRANULARITY_RECOMMENDED
```
public static final int CU_MEM_ALLOC_GRANULARITY_RECOMMENDED
```
  enum CUmemAllocationGranularity_flags
  
  See Also:
  
  Constant Field Values
- CU_GRAPH_EXEC_UPDATE_SUCCESS
```
public static final int CU_GRAPH_EXEC_UPDATE_SUCCESS
```
  enum CUgraphExecUpdateResult
  
  See Also:
  
  Constant Field Values
- CU_GRAPH_EXEC_UPDATE_ERROR
```
public static final int CU_GRAPH_EXEC_UPDATE_ERROR
```
  enum CUgraphExecUpdateResult
  
  See Also:
  
  Constant Field Values
- CU_GRAPH_EXEC_UPDATE_ERROR_TOPOLOGY_CHANGED
```
public static final int CU_GRAPH_EXEC_UPDATE_ERROR_TOPOLOGY_CHANGED
```
  enum CUgraphExecUpdateResult
  
  See Also:
  
  Constant Field Values
- CU_GRAPH_EXEC_UPDATE_ERROR_NODE_TYPE_CHANGED
```
public static final int CU_GRAPH_EXEC_UPDATE_ERROR_NODE_TYPE_CHANGED
```
  enum CUgraphExecUpdateResult
  
  See Also:
  
  Constant Field Values
- CU_GRAPH_EXEC_UPDATE_ERROR_FUNCTION_CHANGED
```
public static final int CU_GRAPH_EXEC_UPDATE_ERROR_FUNCTION_CHANGED
```
  enum CUgraphExecUpdateResult
  
  See Also:
  
  Constant Field Values
- CU_GRAPH_EXEC_UPDATE_ERROR_PARAMETERS_CHANGED
```
public static final int CU_GRAPH_EXEC_UPDATE_ERROR_PARAMETERS_CHANGED
```
  enum CUgraphExecUpdateResult
  
  See Also:
  
  Constant Field Values
- CU_GRAPH_EXEC_UPDATE_ERROR_NOT_SUPPORTED
```
public static final int CU_GRAPH_EXEC_UPDATE_ERROR_NOT_SUPPORTED
```
  enum CUgraphExecUpdateResult
  
  See Also:
  
  Constant Field Values
- CUDA_COOPERATIVE_LAUNCH_MULTI_DEVICE_NO_PRE_LAUNCH_SYNC
```
public static final int CUDA_COOPERATIVE_LAUNCH_MULTI_DEVICE_NO_PRE_LAUNCH_SYNC
```
  If set, each kernel launched as part of ::cuLaunchCooperativeKernelMultiDevice only waits for prior work in the stream corresponding to that GPU to complete before the kernel begins execution.
  
  See Also:
  
  Constant Field Values
- CUDA_COOPERATIVE_LAUNCH_MULTI_DEVICE_NO_POST_LAUNCH_SYNC
```
public static final int CUDA_COOPERATIVE_LAUNCH_MULTI_DEVICE_NO_POST_LAUNCH_SYNC
```
  If set, any subsequent work pushed in a stream that participated in a call to ::cuLaunchCooperativeKernelMultiDevice will only wait for the kernel launched on the GPU corresponding to that stream to complete before it begins execution.
  
  See Also:
  
  Constant Field Values
- CUDA_ARRAY3D_LAYERED
```
public static final int CUDA_ARRAY3D_LAYERED
```
  If set, the CUDA array is a collection of layers, where each layer is either a 1D or a 2D array and the Depth member of CUDA_ARRAY3D_DESCRIPTOR specifies the number of layers, not the depth of a 3D array.
  
  See Also:
  
  Constant Field Values
- CUDA_ARRAY3D_2DARRAY
```
public static final int CUDA_ARRAY3D_2DARRAY
```
  Deprecated, use CUDA_ARRAY3D_LAYERED
  
  See Also:
  
  Constant Field Values
- CUDA_ARRAY3D_SURFACE_LDST
```
public static final int CUDA_ARRAY3D_SURFACE_LDST
```
  This flag must be set in order to bind a surface reference to the CUDA array
  
  See Also:
  
  Constant Field Values
- CUDA_ARRAY3D_CUBEMAP
```
public static final int CUDA_ARRAY3D_CUBEMAP
```
  If set, the CUDA array is a collection of six 2D arrays, representing faces of a cube. The width of such a CUDA array must be equal to its height, and Depth must be six. If ::CUDA_ARRAY3D_LAYERED flag is also set, then the CUDA array is a collection of cubemaps and Depth must be a multiple of six.
  
  See Also:
  
  Constant Field Values
- CUDA_ARRAY3D_TEXTURE_GATHER
```
public static final int CUDA_ARRAY3D_TEXTURE_GATHER
```
  This flag must be set in order to perform texture gather operations on a CUDA array.
  
  See Also:
  
  Constant Field Values
- CUDA_ARRAY3D_DEPTH_TEXTURE
```
public static final int CUDA_ARRAY3D_DEPTH_TEXTURE
```
  This flag if set indicates that the CUDA array is a DEPTH_TEXTURE.
  
  See Also:
  
  Constant Field Values
- CUDA_ARRAY3D_COLOR_ATTACHMENT
```
public static final int CUDA_ARRAY3D_COLOR_ATTACHMENT
```
  This flag indicates that the CUDA array may be bound as a color target in an external graphics API
  
  See Also:
  
  Constant Field Values
- CU_TRSA_OVERRIDE_FORMAT
```
public static final int CU_TRSA_OVERRIDE_FORMAT
```
  Override the texref format with a format inferred from the array. Flag for ::cuTexRefSetArray()
  
  See Also:
  
  Constant Field Values
- CU_TRSF_READ_AS_INTEGER
```
public static final int CU_TRSF_READ_AS_INTEGER
```
  Read the texture as integers rather than promoting the values to floats in the range [0,1]. Flag for ::cuTexRefSetFlags()
  
  See Also:
  
  Constant Field Values
- CU_TRSF_NORMALIZED_COORDINATES
```
public static final int CU_TRSF_NORMALIZED_COORDINATES
```
  Use normalized texture coordinates in the range [0,1) instead of [0,dim). Flag for ::cuTexRefSetFlags()
  
  See Also:
  
  Constant Field Values
- CU_TRSF_SRGB
```
public static final int CU_TRSF_SRGB
```
  Perform sRGB->linear conversion during texture read. Flag for ::cuTexRefSetFlags()
  
  See Also:
  
  Constant Field Values
- CU_LAUNCH_PARAM_END
```
public static final Pointer CU_LAUNCH_PARAM_END
```
- CU_LAUNCH_PARAM_BUFFER_POINTER
```
public static final Pointer CU_LAUNCH_PARAM_BUFFER_POINTER
```
- CU_LAUNCH_PARAM_BUFFER_SIZE
```
public static final Pointer CU_LAUNCH_PARAM_BUFFER_SIZE
```
- CU_PARAM_TR_DEFAULT
```
public static final int CU_PARAM_TR_DEFAULT
```
  For texture references loaded into the module, use default texunit from texture reference.
  
  See Also:
  
  Constant Field Values
- CU_DEVICE_CPU
```
public static final int CU_DEVICE_CPU
```
- CU_DEVICE_INVALID
```
public static final int CU_DEVICE_INVALID
```
- cudaRoundNearest
```
public static final int cudaRoundNearest
```
  enum cudaRoundMode
  
  See Also:
  
  Constant Field Values
- cudaRoundZero
```
public static final int cudaRoundZero
```
  enum cudaRoundMode
  
  See Also:
  
  Constant Field Values
- cudaRoundPosInf
```
public static final int cudaRoundPosInf
```
  enum cudaRoundMode
  
  See Also:
  
  Constant Field Values
- cudaRoundMinInf
```
public static final int cudaRoundMinInf
```
  enum cudaRoundMode
  
  See Also:
  
  Constant Field Values
- cudaHostAllocDefault
```
public static final int cudaHostAllocDefault
```
  Default page-locked allocation flag
  
  See Also:
  
  Constant Field Values
- cudaHostAllocPortable
```
public static final int cudaHostAllocPortable
```
  Pinned memory accessible by all CUDA contexts
  
  See Also:
  
  Constant Field Values
- cudaHostAllocMapped
```
public static final int cudaHostAllocMapped
```
  Map allocation into device space
  
  See Also:
  
  Constant Field Values
- cudaHostAllocWriteCombined
```
public static final int cudaHostAllocWriteCombined
```
  Write-combined memory
  
  See Also:
  
  Constant Field Values
- cudaHostRegisterDefault
```
public static final int cudaHostRegisterDefault
```
  Default host memory registration flag
  
  See Also:
  
  Constant Field Values
- cudaHostRegisterPortable
```
public static final int cudaHostRegisterPortable
```
  Pinned memory accessible by all CUDA contexts
  
  See Also:
  
  Constant Field Values
- cudaHostRegisterMapped
```
public static final int cudaHostRegisterMapped
```
  Map registered memory into device space
  
  See Also:
  
  Constant Field Values
- cudaHostRegisterIoMemory
```
public static final int cudaHostRegisterIoMemory
```
  Memory-mapped I/O space
  
  See Also:
  
  Constant Field Values
- cudaPeerAccessDefault
```
public static final int cudaPeerAccessDefault
```
  Default peer addressing enable flag
  
  See Also:
  
  Constant Field Values
- cudaStreamDefault
```
public static final int cudaStreamDefault
```
  Default stream flag
  
  See Also:
  
  Constant Field Values
- cudaStreamNonBlocking
```
public static final int cudaStreamNonBlocking
```
  Stream does not synchronize with stream 0 (the NULL stream)
  
  See Also:
  
  Constant Field Values
- cudaStreamLegacy
```
public static final CUstream_st cudaStreamLegacy
```
- cudaStreamPerThread
```
public static final CUstream_st cudaStreamPerThread
```
- cudaEventDefault
```
public static final int cudaEventDefault
```
  Default event flag
  
  See Also:
  
  Constant Field Values
- cudaEventBlockingSync
```
public static final int cudaEventBlockingSync
```
  Event uses blocking synchronization
  
  See Also:
  
  Constant Field Values
- cudaEventDisableTiming
```
public static final int cudaEventDisableTiming
```
  Event will not record timing data
  
  See Also:
  
  Constant Field Values
- cudaEventInterprocess
```
public static final int cudaEventInterprocess
```
  Event is suitable for interprocess use. cudaEventDisableTiming must be set
  
  See Also:
  
  Constant Field Values
- cudaDeviceScheduleAuto
```
public static final int cudaDeviceScheduleAuto
```
  Device flag - Automatic scheduling
  
  See Also:
  
  Constant Field Values
- cudaDeviceScheduleSpin
```
public static final int cudaDeviceScheduleSpin
```
  Device flag - Spin default scheduling
  
  See Also:
  
  Constant Field Values
- cudaDeviceScheduleYield
```
public static final int cudaDeviceScheduleYield
```
  Device flag - Yield default scheduling
  
  See Also:
  
  Constant Field Values
- cudaDeviceScheduleBlockingSync
```
public static final int cudaDeviceScheduleBlockingSync
```
  Device flag - Use blocking synchronization
  
  See Also:
  
  Constant Field Values
- cudaDeviceBlockingSync
```
public static final int cudaDeviceBlockingSync
```
  Deprecated.
  This flag was deprecated as of CUDA 4.0 and replaced with ::cudaDeviceScheduleBlockingSync.
  
  Device flag - Use blocking synchronization
  
  See Also:
  
  Constant Field Values
- cudaDeviceScheduleMask
```
public static final int cudaDeviceScheduleMask
```
  Device schedule flags mask
  
  See Also:
  
  Constant Field Values
- cudaDeviceMapHost
```
public static final int cudaDeviceMapHost
```
  Device flag - Support mapped pinned allocations
  
  See Also:
  
  Constant Field Values
- cudaDeviceLmemResizeToMax
```
public static final int cudaDeviceLmemResizeToMax
```
  Device flag - Keep local memory allocation after launch
  
  See Also:
  
  Constant Field Values
- cudaDeviceMask
```
public static final int cudaDeviceMask
```
  Device flags mask
  
  See Also:
  
  Constant Field Values
- cudaArrayDefault
```
public static final int cudaArrayDefault
```
  Default CUDA array allocation flag
  
  See Also:
  
  Constant Field Values
- cudaArrayLayered
```
public static final int cudaArrayLayered
```
  Must be set in cudaMalloc3DArray to create a layered CUDA array
  
  See Also:
  
  Constant Field Values
- cudaArraySurfaceLoadStore
```
public static final int cudaArraySurfaceLoadStore
```
  Must be set in cudaMallocArray or cudaMalloc3DArray in order to bind surfaces to the CUDA array
  
  See Also:
  
  Constant Field Values
- cudaArrayCubemap
```
public static final int cudaArrayCubemap
```
  Must be set in cudaMalloc3DArray to create a cubemap CUDA array
  
  See Also:
  
  Constant Field Values
- cudaArrayTextureGather
```
public static final int cudaArrayTextureGather
```
  Must be set in cudaMallocArray or cudaMalloc3DArray in order to perform texture gather operations on the CUDA array
  
  See Also:
  
  Constant Field Values
- cudaArrayColorAttachment
```
public static final int cudaArrayColorAttachment
```
  Must be set in cudaExternalMemoryGetMappedMipmappedArray if the mipmapped array is used as a color target in a graphics API
  
  See Also:
  
  Constant Field Values
- cudaIpcMemLazyEnablePeerAccess
```
public static final int cudaIpcMemLazyEnablePeerAccess
```
  Automatically enable peer access between remote devices as needed
  
  See Also:
  
  Constant Field Values
- cudaMemAttachGlobal
```
public static final int cudaMemAttachGlobal
```
  Memory can be accessed by any stream on any device
  
  See Also:
  
  Constant Field Values
- cudaMemAttachHost
```
public static final int cudaMemAttachHost
```
  Memory cannot be accessed by any stream on any device
  
  See Also:
  
  Constant Field Values
- cudaMemAttachSingle
```
public static final int cudaMemAttachSingle
```
  Memory can only be accessed by a single stream on the associated device
  
  See Also:
  
  Constant Field Values
- cudaOccupancyDefault
```
public static final int cudaOccupancyDefault
```
  Default behavior
  
  See Also:
  
  Constant Field Values
- cudaOccupancyDisableCachingOverride
```
public static final int cudaOccupancyDisableCachingOverride
```
  Assume global caching is enabled and cannot be automatically turned off
  
  See Also:
  
  Constant Field Values
- cudaCpuDeviceId
```
public static final int cudaCpuDeviceId
```
  Device id that represents the CPU
  
  See Also:
  
  Constant Field Values
- cudaInvalidDeviceId
```
public static final int cudaInvalidDeviceId
```
  Device id that represents an invalid device
  
  See Also:
  
  Constant Field Values
- cudaCooperativeLaunchMultiDeviceNoPreSync
```
public static final int cudaCooperativeLaunchMultiDeviceNoPreSync
```
  If set, each kernel launched as part of ::cudaLaunchCooperativeKernelMultiDevice only waits for prior work in the stream corresponding to that GPU to complete before the kernel begins execution.
  
  See Also:
  
  Constant Field Values
- cudaCooperativeLaunchMultiDeviceNoPostSync
```
public static final int cudaCooperativeLaunchMultiDeviceNoPostSync
```
  If set, any subsequent work pushed in a stream that participated in a call to ::cudaLaunchCooperativeKernelMultiDevice will only wait for the kernel launched on the GPU corresponding to that stream to complete before it begins execution.
  
  See Also:
  
  Constant Field Values
- cudaSuccess
```
public static final int cudaSuccess
```
  enum cudaError
  
  See Also:
  
  Constant Field Values
- cudaErrorInvalidValue
```
public static final int cudaErrorInvalidValue
```
  enum cudaError
  
  See Also:
  
  Constant Field Values
- cudaErrorMemoryAllocation
```
public static final int cudaErrorMemoryAllocation
```
  enum cudaError
  
  See Also:
  
  Constant Field Values
- cudaErrorInitializationError
```
public static final int cudaErrorInitializationError
```
  enum cudaError
  
  See Also:
  
  Constant Field Values
- cudaErrorCudartUnloading
```
public static final int cudaErrorCudartUnloading
```
  enum cudaError
  
  See Also:
  
  Constant Field Values
- cudaErrorProfilerDisabled
```
public static final int cudaErrorProfilerDisabled
```
  enum cudaError
  
  See Also:
  
  Constant Field Values
- cudaErrorProfilerNotInitialized
```
public static final int cudaErrorProfilerNotInitialized
```
  enum cudaError
  
  See Also:
  
  Constant Field Values
- cudaErrorProfilerAlreadyStarted
```
public static final int cudaErrorProfilerAlreadyStarted
```
  enum cudaError
  
  See Also:
  
  Constant Field Values
- cudaErrorProfilerAlreadyStopped
```
public static final int cudaErrorProfilerAlreadyStopped
```
  enum cudaError
  
  See Also:
  
  Constant Field Values
- cudaErrorInvalidConfiguration
```
public static final int cudaErrorInvalidConfiguration
```
  enum cudaError
  
  See Also:
  
  Constant Field Values
- cudaErrorInvalidPitchValue
```
public static final int cudaErrorInvalidPitchValue
```
  enum cudaError
  
  See Also:
  
  Constant Field Values
- cudaErrorInvalidSymbol
```
public static final int cudaErrorInvalidSymbol
```
  enum cudaError
  
  See Also:
  
  Constant Field Values
- cudaErrorInvalidHostPointer
```
public static final int cudaErrorInvalidHostPointer
```
  enum cudaError
  
  See Also:
  
  Constant Field Values
- cudaErrorInvalidDevicePointer
```
public static final int cudaErrorInvalidDevicePointer
```
  enum cudaError
  
  See Also:
  
  Constant Field Values
- cudaErrorInvalidTexture
```
public static final int cudaErrorInvalidTexture
```
  enum cudaError
  
  See Also:
  
  Constant Field Values
- cudaErrorInvalidTextureBinding
```
public static final int cudaErrorInvalidTextureBinding
```
  enum cudaError
  
  See Also:
  
  Constant Field Values
- cudaErrorInvalidChannelDescriptor
```
public static final int cudaErrorInvalidChannelDescriptor
```
  enum cudaError
  
  See Also:
  
  Constant Field Values
- cudaErrorInvalidMemcpyDirection
```
public static final int cudaErrorInvalidMemcpyDirection
```
  enum cudaError
  
  See Also:
  
  Constant Field Values
- cudaErrorAddressOfConstant
```
public static final int cudaErrorAddressOfConstant
```
  enum cudaError
  
  See Also:
  
  Constant Field Values
- cudaErrorTextureFetchFailed
```
public static final int cudaErrorTextureFetchFailed
```
  enum cudaError
  
  See Also:
  
  Constant Field Values
- cudaErrorTextureNotBound
```
public static final int cudaErrorTextureNotBound
```
  enum cudaError
  
  See Also:
  
  Constant Field Values
- cudaErrorSynchronizationError
```
public static final int cudaErrorSynchronizationError
```
  enum cudaError
  
  See Also:
  
  Constant Field Values
- cudaErrorInvalidFilterSetting
```
public static final int cudaErrorInvalidFilterSetting
```
  enum cudaError
  
  See Also:
  
  Constant Field Values
- cudaErrorInvalidNormSetting
```
public static final int cudaErrorInvalidNormSetting
```
  enum cudaError
  
  See Also:
  
  Constant Field Values
- cudaErrorMixedDeviceExecution
```
public static final int cudaErrorMixedDeviceExecution
```
  enum cudaError
  
  See Also:
  
  Constant Field Values
- cudaErrorNotYetImplemented
```
public static final int cudaErrorNotYetImplemented
```
  enum cudaError
  
  See Also:
  
  Constant Field Values
- cudaErrorMemoryValueTooLarge
```
public static final int cudaErrorMemoryValueTooLarge
```
  enum cudaError
  
  See Also:
  
  Constant Field Values
- cudaErrorInsufficientDriver
```
public static final int cudaErrorInsufficientDriver
```
  enum cudaError
  
  See Also:
  
  Constant Field Values
- cudaErrorInvalidSurface
```
public static final int cudaErrorInvalidSurface
```
  enum cudaError
  
  See Also:
  
  Constant Field Values
- cudaErrorDuplicateVariableName
```
public static final int cudaErrorDuplicateVariableName
```
  enum cudaError
  
  See Also:
  
  Constant Field Values
- cudaErrorDuplicateTextureName
```
public static final int cudaErrorDuplicateTextureName
```
  enum cudaError
  
  See Also:
  
  Constant Field Values
- cudaErrorDuplicateSurfaceName
```
public static final int cudaErrorDuplicateSurfaceName
```
  enum cudaError
  
  See Also:
  
  Constant Field Values
- cudaErrorDevicesUnavailable
```
public static final int cudaErrorDevicesUnavailable
```
  enum cudaError
  
  See Also:
  
  Constant Field Values
- cudaErrorIncompatibleDriverContext
```
public static final int cudaErrorIncompatibleDriverContext
```
  enum cudaError
  
  See Also:
  
  Constant Field Values
- cudaErrorMissingConfiguration
```
public static final int cudaErrorMissingConfiguration
```
  enum cudaError
  
  See Also:
  
  Constant Field Values
- cudaErrorPriorLaunchFailure
```
public static final int cudaErrorPriorLaunchFailure
```
  enum cudaError
  
  See Also:
  
  Constant Field Values
- cudaErrorLaunchMaxDepthExceeded
```
public static final int cudaErrorLaunchMaxDepthExceeded
```
  enum cudaError
  
  See Also:
  
  Constant Field Values
- cudaErrorLaunchFileScopedTex
```
public static final int cudaErrorLaunchFileScopedTex
```
  enum cudaError
  
  See Also:
  
  Constant Field Values
- cudaErrorLaunchFileScopedSurf
```
public static final int cudaErrorLaunchFileScopedSurf
```
  enum cudaError
  
  See Also:
  
  Constant Field Values
- cudaErrorSyncDepthExceeded
```
public static final int cudaErrorSyncDepthExceeded
```
  enum cudaError
  
  See Also:
  
  Constant Field Values
- cudaErrorLaunchPendingCountExceeded
```
public static final int cudaErrorLaunchPendingCountExceeded
```
  enum cudaError
  
  See Also:
  
  Constant Field Values
- cudaErrorInvalidDeviceFunction
```
public static final int cudaErrorInvalidDeviceFunction
```
  enum cudaError
  
  See Also:
  
  Constant Field Values
- cudaErrorNoDevice
```
public static final int cudaErrorNoDevice
```
  enum cudaError
  
  See Also:
  
  Constant Field Values
- cudaErrorInvalidDevice
```
public static final int cudaErrorInvalidDevice
```
  enum cudaError
  
  See Also:
  
  Constant Field Values
- cudaErrorStartupFailure
```
public static final int cudaErrorStartupFailure
```
  enum cudaError
  
  See Also:
  
  Constant Field Values
- cudaErrorInvalidKernelImage
```
public static final int cudaErrorInvalidKernelImage
```
  enum cudaError
  
  See Also:
  
  Constant Field Values
- cudaErrorDeviceUninitialized
```
public static final int cudaErrorDeviceUninitialized
```
  enum cudaError
  
  See Also:
  
  Constant Field Values
- cudaErrorMapBufferObjectFailed
```
public static final int cudaErrorMapBufferObjectFailed
```
  enum cudaError
  
  See Also:
  
  Constant Field Values
- cudaErrorUnmapBufferObjectFailed
```
public static final int cudaErrorUnmapBufferObjectFailed
```
  enum cudaError
  
  See Also:
  
  Constant Field Values
- cudaErrorArrayIsMapped
```
public static final int cudaErrorArrayIsMapped
```
  enum cudaError
  
  See Also:
  
  Constant Field Values
- cudaErrorAlreadyMapped
```
public static final int cudaErrorAlreadyMapped
```
  enum cudaError
  
  See Also:
  
  Constant Field Values
- cudaErrorNoKernelImageForDevice
```
public static final int cudaErrorNoKernelImageForDevice
```
  enum cudaError
  
  See Also:
  
  Constant Field Values
- cudaErrorAlreadyAcquired
```
public static final int cudaErrorAlreadyAcquired
```
  enum cudaError
  
  See Also:
  
  Constant Field Values
- cudaErrorNotMapped
```
public static final int cudaErrorNotMapped
```
  enum cudaError
  
  See Also:
  
  Constant Field Values
- cudaErrorNotMappedAsArray
```
public static final int cudaErrorNotMappedAsArray
```
  enum cudaError
  
  See Also:
  
  Constant Field Values
- cudaErrorNotMappedAsPointer
```
public static final int cudaErrorNotMappedAsPointer
```
  enum cudaError
  
  See Also:
  
  Constant Field Values
- cudaErrorECCUncorrectable
```
public static final int cudaErrorECCUncorrectable
```
  enum cudaError
  
  See Also:
  
  Constant Field Values
- cudaErrorUnsupportedLimit
```
public static final int cudaErrorUnsupportedLimit
```
  enum cudaError
  
  See Also:
  
  Constant Field Values
- cudaErrorDeviceAlreadyInUse
```
public static final int cudaErrorDeviceAlreadyInUse
```
  enum cudaError
  
  See Also:
  
  Constant Field Values
- cudaErrorPeerAccessUnsupported
```
public static final int cudaErrorPeerAccessUnsupported
```
  enum cudaError
  
  See Also:
  
  Constant Field Values
- cudaErrorInvalidPtx
```
public static final int cudaErrorInvalidPtx
```
  enum cudaError
  
  See Also:
  
  Constant Field Values
- cudaErrorInvalidGraphicsContext
```
public static final int cudaErrorInvalidGraphicsContext
```
  enum cudaError
  
  See Also:
  
  Constant Field Values
- cudaErrorNvlinkUncorrectable
```
public static final int cudaErrorNvlinkUncorrectable
```
  enum cudaError
  
  See Also:
  
  Constant Field Values
- cudaErrorJitCompilerNotFound
```
public static final int cudaErrorJitCompilerNotFound
```
  enum cudaError
  
  See Also:
  
  Constant Field Values
- cudaErrorInvalidSource
```
public static final int cudaErrorInvalidSource
```
  enum cudaError
  
  See Also:
  
  Constant Field Values
- cudaErrorFileNotFound
```
public static final int cudaErrorFileNotFound
```
  enum cudaError
  
  See Also:
  
  Constant Field Values
- cudaErrorSharedObjectSymbolNotFound
```
public static final int cudaErrorSharedObjectSymbolNotFound
```
  enum cudaError
  
  See Also:
  
  Constant Field Values
- cudaErrorSharedObjectInitFailed
```
public static final int cudaErrorSharedObjectInitFailed
```
  enum cudaError
  
  See Also:
  
  Constant Field Values
- cudaErrorOperatingSystem
```
public static final int cudaErrorOperatingSystem
```
  enum cudaError
  
  See Also:
  
  Constant Field Values
- cudaErrorInvalidResourceHandle
```
public static final int cudaErrorInvalidResourceHandle
```
  enum cudaError
  
  See Also:
  
  Constant Field Values
- cudaErrorIllegalState
```
public static final int cudaErrorIllegalState
```
  enum cudaError
  
  See Also:
  
  Constant Field Values
- cudaErrorSymbolNotFound
```
public static final int cudaErrorSymbolNotFound
```
  enum cudaError
  
  See Also:
  
  Constant Field Values
- cudaErrorNotReady
```
public static final int cudaErrorNotReady
```
  enum cudaError
  
  See Also:
  
  Constant Field Values
- cudaErrorIllegalAddress
```
public static final int cudaErrorIllegalAddress
```
  enum cudaError
  
  See Also:
  
  Constant Field Values
- cudaErrorLaunchOutOfResources
```
public static final int cudaErrorLaunchOutOfResources
```
  enum cudaError
  
  See Also:
  
  Constant Field Values
- cudaErrorLaunchTimeout
```
public static final int cudaErrorLaunchTimeout
```
  enum cudaError
  
  See Also:
  
  Constant Field Values
- cudaErrorLaunchIncompatibleTexturing
```
public static final int cudaErrorLaunchIncompatibleTexturing
```
  enum cudaError
  
  See Also:
  
  Constant Field Values
- cudaErrorPeerAccessAlreadyEnabled
```
public static final int cudaErrorPeerAccessAlreadyEnabled
```
  enum cudaError
  
  See Also:
  
  Constant Field Values
- cudaErrorPeerAccessNotEnabled
```
public static final int cudaErrorPeerAccessNotEnabled
```
  enum cudaError
  
  See Also:
  
  Constant Field Values
- cudaErrorSetOnActiveProcess
```
public static final int cudaErrorSetOnActiveProcess
```
  enum cudaError
  
  See Also:
  
  Constant Field Values
- cudaErrorContextIsDestroyed
```
public static final int cudaErrorContextIsDestroyed
```
  enum cudaError
  
  See Also:
  
  Constant Field Values
- cudaErrorAssert
```
public static final int cudaErrorAssert
```
  enum cudaError
  
  See Also:
  
  Constant Field Values
- cudaErrorTooManyPeers
```
public static final int cudaErrorTooManyPeers
```
  enum cudaError
  
  See Also:
  
  Constant Field Values
- cudaErrorHostMemoryAlreadyRegistered
```
public static final int cudaErrorHostMemoryAlreadyRegistered
```
  enum cudaError
  
  See Also:
  
  Constant Field Values
- cudaErrorHostMemoryNotRegistered
```
public static final int cudaErrorHostMemoryNotRegistered
```
  enum cudaError
  
  See Also:
  
  Constant Field Values
- cudaErrorHardwareStackError
```
public static final int cudaErrorHardwareStackError
```
  enum cudaError
  
  See Also:
  
  Constant Field Values
- cudaErrorIllegalInstruction
```
public static final int cudaErrorIllegalInstruction
```
  enum cudaError
  
  See Also:
  
  Constant Field Values
- cudaErrorMisalignedAddress
```
public static final int cudaErrorMisalignedAddress
```
  enum cudaError
  
  See Also:
  
  Constant Field Values
- cudaErrorInvalidAddressSpace
```
public static final int cudaErrorInvalidAddressSpace
```
  enum cudaError
  
  See Also:
  
  Constant Field Values
- cudaErrorInvalidPc
```
public static final int cudaErrorInvalidPc
```
  enum cudaError
  
  See Also:
  
  Constant Field Values
- cudaErrorLaunchFailure
```
public static final int cudaErrorLaunchFailure
```
  enum cudaError
  
  See Also:
  
  Constant Field Values
- cudaErrorCooperativeLaunchTooLarge
```
public static final int cudaErrorCooperativeLaunchTooLarge
```
  enum cudaError
  
  See Also:
  
  Constant Field Values
- cudaErrorNotPermitted
```
public static final int cudaErrorNotPermitted
```
  enum cudaError
  
  See Also:
  
  Constant Field Values
- cudaErrorNotSupported
```
public static final int cudaErrorNotSupported
```
  enum cudaError
  
  See Also:
  
  Constant Field Values
- cudaErrorSystemNotReady
```
public static final int cudaErrorSystemNotReady
```
  enum cudaError
  
  See Also:
  
  Constant Field Values
- cudaErrorSystemDriverMismatch
```
public static final int cudaErrorSystemDriverMismatch
```
  enum cudaError
  
  See Also:
  
  Constant Field Values
- cudaErrorCompatNotSupportedOnDevice
```
public static final int cudaErrorCompatNotSupportedOnDevice
```
  enum cudaError
  
  See Also:
  
  Constant Field Values
- cudaErrorStreamCaptureUnsupported
```
public static final int cudaErrorStreamCaptureUnsupported
```
  enum cudaError
  
  See Also:
  
  Constant Field Values
- cudaErrorStreamCaptureInvalidated
```
public static final int cudaErrorStreamCaptureInvalidated
```
  enum cudaError
  
  See Also:
  
  Constant Field Values
- cudaErrorStreamCaptureMerge
```
public static final int cudaErrorStreamCaptureMerge
```
  enum cudaError
  
  See Also:
  
  Constant Field Values
- cudaErrorStreamCaptureUnmatched
```
public static final int cudaErrorStreamCaptureUnmatched
```
  enum cudaError
  
  See Also:
  
  Constant Field Values
- cudaErrorStreamCaptureUnjoined
```
public static final int cudaErrorStreamCaptureUnjoined
```
  enum cudaError
  
  See Also:
  
  Constant Field Values
- cudaErrorStreamCaptureIsolation
```
public static final int cudaErrorStreamCaptureIsolation
```
  enum cudaError
  
  See Also:
  
  Constant Field Values
- cudaErrorStreamCaptureImplicit
```
public static final int cudaErrorStreamCaptureImplicit
```
  enum cudaError
  
  See Also:
  
  Constant Field Values
- cudaErrorCapturedEvent
```
public static final int cudaErrorCapturedEvent
```
  enum cudaError
  
  See Also:
  
  Constant Field Values
- cudaErrorStreamCaptureWrongThread
```
public static final int cudaErrorStreamCaptureWrongThread
```
  enum cudaError
  
  See Also:
  
  Constant Field Values
- cudaErrorTimeout
```
public static final int cudaErrorTimeout
```
  enum cudaError
  
  See Also:
  
  Constant Field Values
- cudaErrorGraphExecUpdateFailure
```
public static final int cudaErrorGraphExecUpdateFailure
```
  enum cudaError
  
  See Also:
  
  Constant Field Values
- cudaErrorUnknown
```
public static final int cudaErrorUnknown
```
  enum cudaError
  
  See Also:
  
  Constant Field Values
- cudaErrorApiFailureBase
```
public static final int cudaErrorApiFailureBase
```
  enum cudaError
  
  See Also:
  
  Constant Field Values
- cudaChannelFormatKindSigned
```
public static final int cudaChannelFormatKindSigned
```
  enum cudaChannelFormatKind
  
  See Also:
  
  Constant Field Values
- cudaChannelFormatKindUnsigned
```
public static final int cudaChannelFormatKindUnsigned
```
  enum cudaChannelFormatKind
  
  See Also:
  
  Constant Field Values
- cudaChannelFormatKindFloat
```
public static final int cudaChannelFormatKindFloat
```
  enum cudaChannelFormatKind
  
  See Also:
  
  Constant Field Values
- cudaChannelFormatKindNone
```
public static final int cudaChannelFormatKindNone
```
  enum cudaChannelFormatKind
  
  See Also:
  
  Constant Field Values
- cudaMemoryTypeUnregistered
```
public static final int cudaMemoryTypeUnregistered
```
  enum cudaMemoryType
  
  See Also:
  
  Constant Field Values
- cudaMemoryTypeHost
```
public static final int cudaMemoryTypeHost
```
  enum cudaMemoryType
  
  See Also:
  
  Constant Field Values
- cudaMemoryTypeDevice
```
public static final int cudaMemoryTypeDevice
```
  enum cudaMemoryType
  
  See Also:
  
  Constant Field Values
- cudaMemoryTypeManaged
```
public static final int cudaMemoryTypeManaged
```
  enum cudaMemoryType
  
  See Also:
  
  Constant Field Values
- cudaMemcpyHostToHost
```
public static final int cudaMemcpyHostToHost
```
  enum cudaMemcpyKind
  
  See Also:
  
  Constant Field Values
- cudaMemcpyHostToDevice
```
public static final int cudaMemcpyHostToDevice
```
  enum cudaMemcpyKind
  
  See Also:
  
  Constant Field Values
- cudaMemcpyDeviceToHost
```
public static final int cudaMemcpyDeviceToHost
```
  enum cudaMemcpyKind
  
  See Also:
  
  Constant Field Values
- cudaMemcpyDeviceToDevice
```
public static final int cudaMemcpyDeviceToDevice
```
  enum cudaMemcpyKind
  
  See Also:
  
  Constant Field Values
- cudaMemcpyDefault
```
public static final int cudaMemcpyDefault
```
  enum cudaMemcpyKind
  
  See Also:
  
  Constant Field Values
- cudaStreamCaptureStatusNone
```
public static final int cudaStreamCaptureStatusNone
```
  enum cudaStreamCaptureStatus
  
  See Also:
  
  Constant Field Values
- cudaStreamCaptureStatusActive
```
public static final int cudaStreamCaptureStatusActive
```
  enum cudaStreamCaptureStatus
  
  See Also:
  
  Constant Field Values
- cudaStreamCaptureStatusInvalidated
```
public static final int cudaStreamCaptureStatusInvalidated
```
  enum cudaStreamCaptureStatus
  
  See Also:
  
  Constant Field Values
- cudaStreamCaptureModeGlobal
```
public static final int cudaStreamCaptureModeGlobal
```
  enum cudaStreamCaptureMode
  
  See Also:
  
  Constant Field Values
- cudaStreamCaptureModeThreadLocal
```
public static final int cudaStreamCaptureModeThreadLocal
```
  enum cudaStreamCaptureMode
  
  See Also:
  
  Constant Field Values
- cudaStreamCaptureModeRelaxed
```
public static final int cudaStreamCaptureModeRelaxed
```
  enum cudaStreamCaptureMode
  
  See Also:
  
  Constant Field Values
- cudaGraphicsRegisterFlagsNone
```
public static final int cudaGraphicsRegisterFlagsNone
```
  enum cudaGraphicsRegisterFlags
  
  See Also:
  
  Constant Field Values
- cudaGraphicsRegisterFlagsReadOnly
```
public static final int cudaGraphicsRegisterFlagsReadOnly
```
  enum cudaGraphicsRegisterFlags
  
  See Also:
  
  Constant Field Values
- cudaGraphicsRegisterFlagsWriteDiscard
```
public static final int cudaGraphicsRegisterFlagsWriteDiscard
```
  enum cudaGraphicsRegisterFlags
  
  See Also:
  
  Constant Field Values
- cudaGraphicsRegisterFlagsSurfaceLoadStore
```
public static final int cudaGraphicsRegisterFlagsSurfaceLoadStore
```
  enum cudaGraphicsRegisterFlags
  
  See Also:
  
  Constant Field Values
- cudaGraphicsRegisterFlagsTextureGather
```
public static final int cudaGraphicsRegisterFlagsTextureGather
```
  enum cudaGraphicsRegisterFlags
  
  See Also:
  
  Constant Field Values
- cudaGraphicsMapFlagsNone
```
public static final int cudaGraphicsMapFlagsNone
```
  enum cudaGraphicsMapFlags
  
  See Also:
  
  Constant Field Values
- cudaGraphicsMapFlagsReadOnly
```
public static final int cudaGraphicsMapFlagsReadOnly
```
  enum cudaGraphicsMapFlags
  
  See Also:
  
  Constant Field Values
- cudaGraphicsMapFlagsWriteDiscard
```
public static final int cudaGraphicsMapFlagsWriteDiscard
```
  enum cudaGraphicsMapFlags
  
  See Also:
  
  Constant Field Values
- cudaGraphicsCubeFacePositiveX
```
public static final int cudaGraphicsCubeFacePositiveX
```
  enum cudaGraphicsCubeFace
  
  See Also:
  
  Constant Field Values
- cudaGraphicsCubeFaceNegativeX
```
public static final int cudaGraphicsCubeFaceNegativeX
```
  enum cudaGraphicsCubeFace
  
  See Also:
  
  Constant Field Values
- cudaGraphicsCubeFacePositiveY
```
public static final int cudaGraphicsCubeFacePositiveY
```
  enum cudaGraphicsCubeFace
  
  See Also:
  
  Constant Field Values
- cudaGraphicsCubeFaceNegativeY
```
public static final int cudaGraphicsCubeFaceNegativeY
```
  enum cudaGraphicsCubeFace
  
  See Also:
  
  Constant Field Values
- cudaGraphicsCubeFacePositiveZ
```
public static final int cudaGraphicsCubeFacePositiveZ
```
  enum cudaGraphicsCubeFace
  
  See Also:
  
  Constant Field Values
- cudaGraphicsCubeFaceNegativeZ
```
public static final int cudaGraphicsCubeFaceNegativeZ
```
  enum cudaGraphicsCubeFace
  
  See Also:
  
  Constant Field Values
- cudaResourceTypeArray
```
public static final int cudaResourceTypeArray
```
  enum cudaResourceType
  
  See Also:
  
  Constant Field Values
- cudaResourceTypeMipmappedArray
```
public static final int cudaResourceTypeMipmappedArray
```
  enum cudaResourceType
  
  See Also:
  
  Constant Field Values
- cudaResourceTypeLinear
```
public static final int cudaResourceTypeLinear
```
  enum cudaResourceType
  
  See Also:
  
  Constant Field Values
- cudaResourceTypePitch2D
```
public static final int cudaResourceTypePitch2D
```
  enum cudaResourceType
  
  See Also:
  
  Constant Field Values
- cudaResViewFormatNone
```
public static final int cudaResViewFormatNone
```
  enum cudaResourceViewFormat
  
  See Also:
  
  Constant Field Values
- cudaResViewFormatUnsignedChar1
```
public static final int cudaResViewFormatUnsignedChar1
```
  enum cudaResourceViewFormat
  
  See Also:
  
  Constant Field Values
- cudaResViewFormatUnsignedChar2
```
public static final int cudaResViewFormatUnsignedChar2
```
  enum cudaResourceViewFormat
  
  See Also:
  
  Constant Field Values
- cudaResViewFormatUnsignedChar4
```
public static final int cudaResViewFormatUnsignedChar4
```
  enum cudaResourceViewFormat
  
  See Also:
  
  Constant Field Values
- cudaResViewFormatSignedChar1
```
public static final int cudaResViewFormatSignedChar1
```
  enum cudaResourceViewFormat
  
  See Also:
  
  Constant Field Values
- cudaResViewFormatSignedChar2
```
public static final int cudaResViewFormatSignedChar2
```
  enum cudaResourceViewFormat
  
  See Also:
  
  Constant Field Values
- cudaResViewFormatSignedChar4
```
public static final int cudaResViewFormatSignedChar4
```
  enum cudaResourceViewFormat
  
  See Also:
  
  Constant Field Values
- cudaResViewFormatUnsignedShort1
```
public static final int cudaResViewFormatUnsignedShort1
```
  enum cudaResourceViewFormat
  
  See Also:
  
  Constant Field Values
- cudaResViewFormatUnsignedShort2
```
public static final int cudaResViewFormatUnsignedShort2
```
  enum cudaResourceViewFormat
  
  See Also:
  
  Constant Field Values
- cudaResViewFormatUnsignedShort4
```
public static final int cudaResViewFormatUnsignedShort4
```
  enum cudaResourceViewFormat
  
  See Also:
  
  Constant Field Values
- cudaResViewFormatSignedShort1
```
public static final int cudaResViewFormatSignedShort1
```
  enum cudaResourceViewFormat
  
  See Also:
  
  Constant Field Values
- cudaResViewFormatSignedShort2
```
public static final int cudaResViewFormatSignedShort2
```
  enum cudaResourceViewFormat
  
  See Also:
  
  Constant Field Values
- cudaResViewFormatSignedShort4
```
public static final int cudaResViewFormatSignedShort4
```
  enum cudaResourceViewFormat
  
  See Also:
  
  Constant Field Values
- cudaResViewFormatUnsignedInt1
```
public static final int cudaResViewFormatUnsignedInt1
```
  enum cudaResourceViewFormat
  
  See Also:
  
  Constant Field Values
- cudaResViewFormatUnsignedInt2
```
public static final int cudaResViewFormatUnsignedInt2
```
  enum cudaResourceViewFormat
  
  See Also:
  
  Constant Field Values
- cudaResViewFormatUnsignedInt4
```
public static final int cudaResViewFormatUnsignedInt4
```
  enum cudaResourceViewFormat
  
  See Also:
  
  Constant Field Values
- cudaResViewFormatSignedInt1
```
public static final int cudaResViewFormatSignedInt1
```
  enum cudaResourceViewFormat
  
  See Also:
  
  Constant Field Values
- cudaResViewFormatSignedInt2
```
public static final int cudaResViewFormatSignedInt2
```
  enum cudaResourceViewFormat
  
  See Also:
  
  Constant Field Values
- cudaResViewFormatSignedInt4
```
public static final int cudaResViewFormatSignedInt4
```
  enum cudaResourceViewFormat
  
  See Also:
  
  Constant Field Values
- cudaResViewFormatHalf1
```
public static final int cudaResViewFormatHalf1
```
  enum cudaResourceViewFormat
  
  See Also:
  
  Constant Field Values
- cudaResViewFormatHalf2
```
public static final int cudaResViewFormatHalf2
```
  enum cudaResourceViewFormat
  
  See Also:
  
  Constant Field Values
- cudaResViewFormatHalf4
```
public static final int cudaResViewFormatHalf4
```
  enum cudaResourceViewFormat
  
  See Also:
  
  Constant Field Values
- cudaResViewFormatFloat1
```
public static final int cudaResViewFormatFloat1
```
  enum cudaResourceViewFormat
  
  See Also:
  
  Constant Field Values
- cudaResViewFormatFloat2
```
public static final int cudaResViewFormatFloat2
```
  enum cudaResourceViewFormat
  
  See Also:
  
  Constant Field Values
- cudaResViewFormatFloat4
```
public static final int cudaResViewFormatFloat4
```
  enum cudaResourceViewFormat
  
  See Also:
  
  Constant Field Values
- cudaResViewFormatUnsignedBlockCompressed1
```
public static final int cudaResViewFormatUnsignedBlockCompressed1
```
  enum cudaResourceViewFormat
  
  See Also:
  
  Constant Field Values
- cudaResViewFormatUnsignedBlockCompressed2
```
public static final int cudaResViewFormatUnsignedBlockCompressed2
```
  enum cudaResourceViewFormat
  
  See Also:
  
  Constant Field Values
- cudaResViewFormatUnsignedBlockCompressed3
```
public static final int cudaResViewFormatUnsignedBlockCompressed3
```
  enum cudaResourceViewFormat
  
  See Also:
  
  Constant Field Values
- cudaResViewFormatUnsignedBlockCompressed4
```
public static final int cudaResViewFormatUnsignedBlockCompressed4
```
  enum cudaResourceViewFormat
  
  See Also:
  
  Constant Field Values
- cudaResViewFormatSignedBlockCompressed4
```
public static final int cudaResViewFormatSignedBlockCompressed4
```
  enum cudaResourceViewFormat
  
  See Also:
  
  Constant Field Values
- cudaResViewFormatUnsignedBlockCompressed5
```
public static final int cudaResViewFormatUnsignedBlockCompressed5
```
  enum cudaResourceViewFormat
  
  See Also:
  
  Constant Field Values
- cudaResViewFormatSignedBlockCompressed5
```
public static final int cudaResViewFormatSignedBlockCompressed5
```
  enum cudaResourceViewFormat
  
  See Also:
  
  Constant Field Values
- cudaResViewFormatUnsignedBlockCompressed6H
```
public static final int cudaResViewFormatUnsignedBlockCompressed6H
```
  enum cudaResourceViewFormat
  
  See Also:
  
  Constant Field Values
- cudaResViewFormatSignedBlockCompressed6H
```
public static final int cudaResViewFormatSignedBlockCompressed6H
```
  enum cudaResourceViewFormat
  
  See Also:
  
  Constant Field Values
- cudaResViewFormatUnsignedBlockCompressed7
```
public static final int cudaResViewFormatUnsignedBlockCompressed7
```
  enum cudaResourceViewFormat
  
  See Also:
  
  Constant Field Values
- cudaFuncAttributeMaxDynamicSharedMemorySize
```
public static final int cudaFuncAttributeMaxDynamicSharedMemorySize
```
  enum cudaFuncAttribute
  
  See Also:
  
  Constant Field Values
- cudaFuncAttributePreferredSharedMemoryCarveout
```
public static final int cudaFuncAttributePreferredSharedMemoryCarveout
```
  enum cudaFuncAttribute
  
  See Also:
  
  Constant Field Values
- cudaFuncAttributeMax
```
public static final int cudaFuncAttributeMax
```
  enum cudaFuncAttribute
  
  See Also:
  
  Constant Field Values
- cudaFuncCachePreferNone
```
public static final int cudaFuncCachePreferNone
```
  enum cudaFuncCache
  
  See Also:
  
  Constant Field Values
- cudaFuncCachePreferShared
```
public static final int cudaFuncCachePreferShared
```
  enum cudaFuncCache
  
  See Also:
  
  Constant Field Values
- cudaFuncCachePreferL1
```
public static final int cudaFuncCachePreferL1
```
  enum cudaFuncCache
  
  See Also:
  
  Constant Field Values
- cudaFuncCachePreferEqual
```
public static final int cudaFuncCachePreferEqual
```
  enum cudaFuncCache
  
  See Also:
  
  Constant Field Values
- cudaSharedMemBankSizeDefault
```
public static final int cudaSharedMemBankSizeDefault
```
  enum cudaSharedMemConfig
  
  See Also:
  
  Constant Field Values
- cudaSharedMemBankSizeFourByte
```
public static final int cudaSharedMemBankSizeFourByte
```
  enum cudaSharedMemConfig
  
  See Also:
  
  Constant Field Values
- cudaSharedMemBankSizeEightByte
```
public static final int cudaSharedMemBankSizeEightByte
```
  enum cudaSharedMemConfig
  
  See Also:
  
  Constant Field Values
- cudaSharedmemCarveoutDefault
```
public static final int cudaSharedmemCarveoutDefault
```
  enum cudaSharedCarveout
  
  See Also:
  
  Constant Field Values
- cudaSharedmemCarveoutMaxShared
```
public static final int cudaSharedmemCarveoutMaxShared
```
  enum cudaSharedCarveout
  
  See Also:
  
  Constant Field Values
- cudaSharedmemCarveoutMaxL1
```
public static final int cudaSharedmemCarveoutMaxL1
```
  enum cudaSharedCarveout
  
  See Also:
  
  Constant Field Values
- cudaComputeModeDefault
```
public static final int cudaComputeModeDefault
```
  enum cudaComputeMode
  
  See Also:
  
  Constant Field Values
- cudaComputeModeExclusive
```
public static final int cudaComputeModeExclusive
```
  enum cudaComputeMode
  
  See Also:
  
  Constant Field Values
- cudaComputeModeProhibited
```
public static final int cudaComputeModeProhibited
```
  enum cudaComputeMode
  
  See Also:
  
  Constant Field Values
- cudaComputeModeExclusiveProcess
```
public static final int cudaComputeModeExclusiveProcess
```
  enum cudaComputeMode
  
  See Also:
  
  Constant Field Values
- cudaLimitStackSize
```
public static final int cudaLimitStackSize
```
  enum cudaLimit
  
  See Also:
  
  Constant Field Values
- cudaLimitPrintfFifoSize
```
public static final int cudaLimitPrintfFifoSize
```
  enum cudaLimit
  
  See Also:
  
  Constant Field Values
- cudaLimitMallocHeapSize
```
public static final int cudaLimitMallocHeapSize
```
  enum cudaLimit
  
  See Also:
  
  Constant Field Values
- cudaLimitDevRuntimeSyncDepth
```
public static final int cudaLimitDevRuntimeSyncDepth
```
  enum cudaLimit
  
  See Also:
  
  Constant Field Values
- cudaLimitDevRuntimePendingLaunchCount
```
public static final int cudaLimitDevRuntimePendingLaunchCount
```
  enum cudaLimit
  
  See Also:
  
  Constant Field Values
- cudaLimitMaxL2FetchGranularity
```
public static final int cudaLimitMaxL2FetchGranularity
```
  enum cudaLimit
  
  See Also:
  
  Constant Field Values
- cudaMemAdviseSetReadMostly
```
public static final int cudaMemAdviseSetReadMostly
```
  enum cudaMemoryAdvise
  
  See Also:
  
  Constant Field Values
- cudaMemAdviseUnsetReadMostly
```
public static final int cudaMemAdviseUnsetReadMostly
```
  enum cudaMemoryAdvise
  
  See Also:
  
  Constant Field Values
- cudaMemAdviseSetPreferredLocation
```
public static final int cudaMemAdviseSetPreferredLocation
```
  enum cudaMemoryAdvise
  
  See Also:
  
  Constant Field Values
- cudaMemAdviseUnsetPreferredLocation
```
public static final int cudaMemAdviseUnsetPreferredLocation
```
  enum cudaMemoryAdvise
  
  See Also:
  
  Constant Field Values
- cudaMemAdviseSetAccessedBy
```
public static final int cudaMemAdviseSetAccessedBy
```
  enum cudaMemoryAdvise
  
  See Also:
  
  Constant Field Values
- cudaMemAdviseUnsetAccessedBy
```
public static final int cudaMemAdviseUnsetAccessedBy
```
  enum cudaMemoryAdvise
  
  See Also:
  
  Constant Field Values
- cudaMemRangeAttributeReadMostly
```
public static final int cudaMemRangeAttributeReadMostly
```
  enum cudaMemRangeAttribute
  
  See Also:
  
  Constant Field Values
- cudaMemRangeAttributePreferredLocation
```
public static final int cudaMemRangeAttributePreferredLocation
```
  enum cudaMemRangeAttribute
  
  See Also:
  
  Constant Field Values
- cudaMemRangeAttributeAccessedBy
```
public static final int cudaMemRangeAttributeAccessedBy
```
  enum cudaMemRangeAttribute
  
  See Also:
  
  Constant Field Values
- cudaMemRangeAttributeLastPrefetchLocation
```
public static final int cudaMemRangeAttributeLastPrefetchLocation
```
  enum cudaMemRangeAttribute
  
  See Also:
  
  Constant Field Values
- cudaKeyValuePair
```
public static final int cudaKeyValuePair
```
  enum cudaOutputMode
  
  See Also:
  
  Constant Field Values
- cudaCSV
```
public static final int cudaCSV
```
  enum cudaOutputMode
  
  See Also:
  
  Constant Field Values
- cudaDevAttrMaxThreadsPerBlock
```
public static final int cudaDevAttrMaxThreadsPerBlock
```
  enum cudaDeviceAttr
  
  See Also:
  
  Constant Field Values
- cudaDevAttrMaxBlockDimX
```
public static final int cudaDevAttrMaxBlockDimX
```
  enum cudaDeviceAttr
  
  See Also:
  
  Constant Field Values
- cudaDevAttrMaxBlockDimY
```
public static final int cudaDevAttrMaxBlockDimY
```
  enum cudaDeviceAttr
  
  See Also:
  
  Constant Field Values
- cudaDevAttrMaxBlockDimZ
```
public static final int cudaDevAttrMaxBlockDimZ
```
  enum cudaDeviceAttr
  
  See Also:
  
  Constant Field Values
- cudaDevAttrMaxGridDimX
```
public static final int cudaDevAttrMaxGridDimX
```
  enum cudaDeviceAttr
  
  See Also:
  
  Constant Field Values
- cudaDevAttrMaxGridDimY
```
public static final int cudaDevAttrMaxGridDimY
```
  enum cudaDeviceAttr
  
  See Also:
  
  Constant Field Values
- cudaDevAttrMaxGridDimZ
```
public static final int cudaDevAttrMaxGridDimZ
```
  enum cudaDeviceAttr
  
  See Also:
  
  Constant Field Values
- cudaDevAttrMaxSharedMemoryPerBlock
```
public static final int cudaDevAttrMaxSharedMemoryPerBlock
```
  enum cudaDeviceAttr
  
  See Also:
  
  Constant Field Values
- cudaDevAttrTotalConstantMemory
```
public static final int cudaDevAttrTotalConstantMemory
```
  enum cudaDeviceAttr
  
  See Also:
  
  Constant Field Values
- cudaDevAttrWarpSize
```
public static final int cudaDevAttrWarpSize
```
  enum cudaDeviceAttr
  
  See Also:
  
  Constant Field Values
- cudaDevAttrMaxPitch
```
public static final int cudaDevAttrMaxPitch
```
  enum cudaDeviceAttr
  
  See Also:
  
  Constant Field Values
- cudaDevAttrMaxRegistersPerBlock
```
public static final int cudaDevAttrMaxRegistersPerBlock
```
  enum cudaDeviceAttr
  
  See Also:
  
  Constant Field Values
- cudaDevAttrClockRate
```
public static final int cudaDevAttrClockRate
```
  enum cudaDeviceAttr
  
  See Also:
  
  Constant Field Values
- cudaDevAttrTextureAlignment
```
public static final int cudaDevAttrTextureAlignment
```
  enum cudaDeviceAttr
  
  See Also:
  
  Constant Field Values
- cudaDevAttrGpuOverlap
```
public static final int cudaDevAttrGpuOverlap
```
  enum cudaDeviceAttr
  
  See Also:
  
  Constant Field Values
- cudaDevAttrMultiProcessorCount
```
public static final int cudaDevAttrMultiProcessorCount
```
  enum cudaDeviceAttr
  
  See Also:
  
  Constant Field Values
- cudaDevAttrKernelExecTimeout
```
public static final int cudaDevAttrKernelExecTimeout
```
  enum cudaDeviceAttr
  
  See Also:
  
  Constant Field Values
- cudaDevAttrIntegrated
```
public static final int cudaDevAttrIntegrated
```
  enum cudaDeviceAttr
  
  See Also:
  
  Constant Field Values
- cudaDevAttrCanMapHostMemory
```
public static final int cudaDevAttrCanMapHostMemory
```
  enum cudaDeviceAttr
  
  See Also:
  
  Constant Field Values
- cudaDevAttrComputeMode
```
public static final int cudaDevAttrComputeMode
```
  enum cudaDeviceAttr
  
  See Also:
  
  Constant Field Values
- cudaDevAttrMaxTexture1DWidth
```
public static final int cudaDevAttrMaxTexture1DWidth
```
  enum cudaDeviceAttr
  
  See Also:
  
  Constant Field Values
- cudaDevAttrMaxTexture2DWidth
```
public static final int cudaDevAttrMaxTexture2DWidth
```
  enum cudaDeviceAttr
  
  See Also:
  
  Constant Field Values
- cudaDevAttrMaxTexture2DHeight
```
public static final int cudaDevAttrMaxTexture2DHeight
```
  enum cudaDeviceAttr
  
  See Also:
  
  Constant Field Values
- cudaDevAttrMaxTexture3DWidth
```
public static final int cudaDevAttrMaxTexture3DWidth
```
  enum cudaDeviceAttr
  
  See Also:
  
  Constant Field Values
- cudaDevAttrMaxTexture3DHeight
```
public static final int cudaDevAttrMaxTexture3DHeight
```
  enum cudaDeviceAttr
  
  See Also:
  
  Constant Field Values
- cudaDevAttrMaxTexture3DDepth
```
public static final int cudaDevAttrMaxTexture3DDepth
```
  enum cudaDeviceAttr
  
  See Also:
  
  Constant Field Values
- cudaDevAttrMaxTexture2DLayeredWidth
```
public static final int cudaDevAttrMaxTexture2DLayeredWidth
```
  enum cudaDeviceAttr
  
  See Also:
  
  Constant Field Values
- cudaDevAttrMaxTexture2DLayeredHeight
```
public static final int cudaDevAttrMaxTexture2DLayeredHeight
```
  enum cudaDeviceAttr
  
  See Also:
  
  Constant Field Values
- cudaDevAttrMaxTexture2DLayeredLayers
```
public static final int cudaDevAttrMaxTexture2DLayeredLayers
```
  enum cudaDeviceAttr
  
  See Also:
  
  Constant Field Values
- cudaDevAttrSurfaceAlignment
```
public static final int cudaDevAttrSurfaceAlignment
```
  enum cudaDeviceAttr
  
  See Also:
  
  Constant Field Values
- cudaDevAttrConcurrentKernels
```
public static final int cudaDevAttrConcurrentKernels
```
  enum cudaDeviceAttr
  
  See Also:
  
  Constant Field Values
- cudaDevAttrEccEnabled
```
public static final int cudaDevAttrEccEnabled
```
  enum cudaDeviceAttr
  
  See Also:
  
  Constant Field Values
- cudaDevAttrPciBusId
```
public static final int cudaDevAttrPciBusId
```
  enum cudaDeviceAttr
  
  See Also:
  
  Constant Field Values
- cudaDevAttrPciDeviceId
```
public static final int cudaDevAttrPciDeviceId
```
  enum cudaDeviceAttr
  
  See Also:
  
  Constant Field Values
- cudaDevAttrTccDriver
```
public static final int cudaDevAttrTccDriver
```
  enum cudaDeviceAttr
  
  See Also:
  
  Constant Field Values
- cudaDevAttrMemoryClockRate
```
public static final int cudaDevAttrMemoryClockRate
```
  enum cudaDeviceAttr
  
  See Also:
  
  Constant Field Values
- cudaDevAttrGlobalMemoryBusWidth
```
public static final int cudaDevAttrGlobalMemoryBusWidth
```
  enum cudaDeviceAttr
  
  See Also:
  
  Constant Field Values
- cudaDevAttrL2CacheSize
```
public static final int cudaDevAttrL2CacheSize
```
  enum cudaDeviceAttr
  
  See Also:
  
  Constant Field Values
- cudaDevAttrMaxThreadsPerMultiProcessor
```
public static final int cudaDevAttrMaxThreadsPerMultiProcessor
```
  enum cudaDeviceAttr
  
  See Also:
  
  Constant Field Values
- cudaDevAttrAsyncEngineCount
```
public static final int cudaDevAttrAsyncEngineCount
```
  enum cudaDeviceAttr
  
  See Also:
  
  Constant Field Values
- cudaDevAttrUnifiedAddressing
```
public static final int cudaDevAttrUnifiedAddressing
```
  enum cudaDeviceAttr
  
  See Also:
  
  Constant Field Values
- cudaDevAttrMaxTexture1DLayeredWidth
```
public static final int cudaDevAttrMaxTexture1DLayeredWidth
```
  enum cudaDeviceAttr
  
  See Also:
  
  Constant Field Values
- cudaDevAttrMaxTexture1DLayeredLayers
```
public static final int cudaDevAttrMaxTexture1DLayeredLayers
```
  enum cudaDeviceAttr
  
  See Also:
  
  Constant Field Values
- cudaDevAttrMaxTexture2DGatherWidth
```
public static final int cudaDevAttrMaxTexture2DGatherWidth
```
  enum cudaDeviceAttr
  
  See Also:
  
  Constant Field Values
- cudaDevAttrMaxTexture2DGatherHeight
```
public static final int cudaDevAttrMaxTexture2DGatherHeight
```
  enum cudaDeviceAttr
  
  See Also:
  
  Constant Field Values
- cudaDevAttrMaxTexture3DWidthAlt
```
public static final int cudaDevAttrMaxTexture3DWidthAlt
```
  enum cudaDeviceAttr
  
  See Also:
  
  Constant Field Values
- cudaDevAttrMaxTexture3DHeightAlt
```
public static final int cudaDevAttrMaxTexture3DHeightAlt
```
  enum cudaDeviceAttr
  
  See Also:
  
  Constant Field Values
- cudaDevAttrMaxTexture3DDepthAlt
```
public static final int cudaDevAttrMaxTexture3DDepthAlt
```
  enum cudaDeviceAttr
  
  See Also:
  
  Constant Field Values
- cudaDevAttrPciDomainId
```
public static final int cudaDevAttrPciDomainId
```
  enum cudaDeviceAttr
  
  See Also:
  
  Constant Field Values
- cudaDevAttrTexturePitchAlignment
```
public static final int cudaDevAttrTexturePitchAlignment
```
  enum cudaDeviceAttr
  
  See Also:
  
  Constant Field Values
- cudaDevAttrMaxTextureCubemapWidth
```
public static final int cudaDevAttrMaxTextureCubemapWidth
```
  enum cudaDeviceAttr
  
  See Also:
  
  Constant Field Values
- cudaDevAttrMaxTextureCubemapLayeredWidth
```
public static final int cudaDevAttrMaxTextureCubemapLayeredWidth
```
  enum cudaDeviceAttr
  
  See Also:
  
  Constant Field Values
- cudaDevAttrMaxTextureCubemapLayeredLayers
```
public static final int cudaDevAttrMaxTextureCubemapLayeredLayers
```
  enum cudaDeviceAttr
  
  See Also:
  
  Constant Field Values
- cudaDevAttrMaxSurface1DWidth
```
public static final int cudaDevAttrMaxSurface1DWidth
```
  enum cudaDeviceAttr
  
  See Also:
  
  Constant Field Values
- cudaDevAttrMaxSurface2DWidth
```
public static final int cudaDevAttrMaxSurface2DWidth
```
  enum cudaDeviceAttr
  
  See Also:
  
  Constant Field Values
- cudaDevAttrMaxSurface2DHeight
```
public static final int cudaDevAttrMaxSurface2DHeight
```
  enum cudaDeviceAttr
  
  See Also:
  
  Constant Field Values
- cudaDevAttrMaxSurface3DWidth
```
public static final int cudaDevAttrMaxSurface3DWidth
```
  enum cudaDeviceAttr
  
  See Also:
  
  Constant Field Values
- cudaDevAttrMaxSurface3DHeight
```
public static final int cudaDevAttrMaxSurface3DHeight
```
  enum cudaDeviceAttr
  
  See Also:
  
  Constant Field Values
- cudaDevAttrMaxSurface3DDepth
```
public static final int cudaDevAttrMaxSurface3DDepth
```
  enum cudaDeviceAttr
  
  See Also:
  
  Constant Field Values
- cudaDevAttrMaxSurface1DLayeredWidth
```
public static final int cudaDevAttrMaxSurface1DLayeredWidth
```
  enum cudaDeviceAttr
  
  See Also:
  
  Constant Field Values
- cudaDevAttrMaxSurface1DLayeredLayers
```
public static final int cudaDevAttrMaxSurface1DLayeredLayers
```
  enum cudaDeviceAttr
  
  See Also:
  
  Constant Field Values
- cudaDevAttrMaxSurface2DLayeredWidth
```
public static final int cudaDevAttrMaxSurface2DLayeredWidth
```
  enum cudaDeviceAttr
  
  See Also:
  
  Constant Field Values
- cudaDevAttrMaxSurface2DLayeredHeight
```
public static final int cudaDevAttrMaxSurface2DLayeredHeight
```
  enum cudaDeviceAttr
  
  See Also:
  
  Constant Field Values
- cudaDevAttrMaxSurface2DLayeredLayers
```
public static final int cudaDevAttrMaxSurface2DLayeredLayers
```
  enum cudaDeviceAttr
  
  See Also:
  
  Constant Field Values
- cudaDevAttrMaxSurfaceCubemapWidth
```
public static final int cudaDevAttrMaxSurfaceCubemapWidth
```
  enum cudaDeviceAttr
  
  See Also:
  
  Constant Field Values
- cudaDevAttrMaxSurfaceCubemapLayeredWidth
```
public static final int cudaDevAttrMaxSurfaceCubemapLayeredWidth
```
  enum cudaDeviceAttr
  
  See Also:
  
  Constant Field Values
- cudaDevAttrMaxSurfaceCubemapLayeredLayers
```
public static final int cudaDevAttrMaxSurfaceCubemapLayeredLayers
```
  enum cudaDeviceAttr
  
  See Also:
  
  Constant Field Values
- cudaDevAttrMaxTexture1DLinearWidth
```
public static final int cudaDevAttrMaxTexture1DLinearWidth
```
  enum cudaDeviceAttr
  
  See Also:
  
  Constant Field Values
- cudaDevAttrMaxTexture2DLinearWidth
```
public static final int cudaDevAttrMaxTexture2DLinearWidth
```
  enum cudaDeviceAttr
  
  See Also:
  
  Constant Field Values
- cudaDevAttrMaxTexture2DLinearHeight
```
public static final int cudaDevAttrMaxTexture2DLinearHeight
```
  enum cudaDeviceAttr
  
  See Also:
  
  Constant Field Values
- cudaDevAttrMaxTexture2DLinearPitch
```
public static final int cudaDevAttrMaxTexture2DLinearPitch
```
  enum cudaDeviceAttr
  
  See Also:
  
  Constant Field Values
- cudaDevAttrMaxTexture2DMipmappedWidth
```
public static final int cudaDevAttrMaxTexture2DMipmappedWidth
```
  enum cudaDeviceAttr
  
  See Also:
  
  Constant Field Values
- cudaDevAttrMaxTexture2DMipmappedHeight
```
public static final int cudaDevAttrMaxTexture2DMipmappedHeight
```
  enum cudaDeviceAttr
  
  See Also:
  
  Constant Field Values
- cudaDevAttrComputeCapabilityMajor
```
public static final int cudaDevAttrComputeCapabilityMajor
```
  enum cudaDeviceAttr
  
  See Also:
  
  Constant Field Values
- cudaDevAttrComputeCapabilityMinor
```
public static final int cudaDevAttrComputeCapabilityMinor
```
  enum cudaDeviceAttr
  
  See Also:
  
  Constant Field Values
- cudaDevAttrMaxTexture1DMipmappedWidth
```
public static final int cudaDevAttrMaxTexture1DMipmappedWidth
```
  enum cudaDeviceAttr
  
  See Also:
  
  Constant Field Values
- cudaDevAttrStreamPrioritiesSupported
```
public static final int cudaDevAttrStreamPrioritiesSupported
```
  enum cudaDeviceAttr
  
  See Also:
  
  Constant Field Values
- cudaDevAttrGlobalL1CacheSupported
```
public static final int cudaDevAttrGlobalL1CacheSupported
```
  enum cudaDeviceAttr
  
  See Also:
  
  Constant Field Values
- cudaDevAttrLocalL1CacheSupported
```
public static final int cudaDevAttrLocalL1CacheSupported
```
  enum cudaDeviceAttr
  
  See Also:
  
  Constant Field Values
- cudaDevAttrMaxSharedMemoryPerMultiprocessor
```
public static final int cudaDevAttrMaxSharedMemoryPerMultiprocessor
```
  enum cudaDeviceAttr
  
  See Also:
  
  Constant Field Values
- cudaDevAttrMaxRegistersPerMultiprocessor
```
public static final int cudaDevAttrMaxRegistersPerMultiprocessor
```
  enum cudaDeviceAttr
  
  See Also:
  
  Constant Field Values
- cudaDevAttrManagedMemory
```
public static final int cudaDevAttrManagedMemory
```
  enum cudaDeviceAttr
  
  See Also:
  
  Constant Field Values
- cudaDevAttrIsMultiGpuBoard
```
public static final int cudaDevAttrIsMultiGpuBoard
```
  enum cudaDeviceAttr
  
  See Also:
  
  Constant Field Values
- cudaDevAttrMultiGpuBoardGroupID
```
public static final int cudaDevAttrMultiGpuBoardGroupID
```
  enum cudaDeviceAttr
  
  See Also:
  
  Constant Field Values
- cudaDevAttrHostNativeAtomicSupported
```
public static final int cudaDevAttrHostNativeAtomicSupported
```
  enum cudaDeviceAttr
  
  See Also:
  
  Constant Field Values
- cudaDevAttrSingleToDoublePrecisionPerfRatio
```
public static final int cudaDevAttrSingleToDoublePrecisionPerfRatio
```
  enum cudaDeviceAttr
  
  See Also:
  
  Constant Field Values
- cudaDevAttrPageableMemoryAccess
```
public static final int cudaDevAttrPageableMemoryAccess
```
  enum cudaDeviceAttr
  
  See Also:
  
  Constant Field Values
- cudaDevAttrConcurrentManagedAccess
```
public static final int cudaDevAttrConcurrentManagedAccess
```
  enum cudaDeviceAttr
  
  See Also:
  
  Constant Field Values
- cudaDevAttrComputePreemptionSupported
```
public static final int cudaDevAttrComputePreemptionSupported
```
  enum cudaDeviceAttr
  
  See Also:
  
  Constant Field Values
- cudaDevAttrCanUseHostPointerForRegisteredMem
```
public static final int cudaDevAttrCanUseHostPointerForRegisteredMem
```
  enum cudaDeviceAttr
  
  See Also:
  
  Constant Field Values
- cudaDevAttrReserved92
```
public static final int cudaDevAttrReserved92
```
  enum cudaDeviceAttr
  
  See Also:
  
  Constant Field Values
- cudaDevAttrReserved93
```
public static final int cudaDevAttrReserved93
```
  enum cudaDeviceAttr
  
  See Also:
  
  Constant Field Values
- cudaDevAttrReserved94
```
public static final int cudaDevAttrReserved94
```
  enum cudaDeviceAttr
  
  See Also:
  
  Constant Field Values
- cudaDevAttrCooperativeLaunch
```
public static final int cudaDevAttrCooperativeLaunch
```
  enum cudaDeviceAttr
  
  See Also:
  
  Constant Field Values
- cudaDevAttrCooperativeMultiDeviceLaunch
```
public static final int cudaDevAttrCooperativeMultiDeviceLaunch
```
  enum cudaDeviceAttr
  
  See Also:
  
  Constant Field Values
- cudaDevAttrMaxSharedMemoryPerBlockOptin
```
public static final int cudaDevAttrMaxSharedMemoryPerBlockOptin
```
  enum cudaDeviceAttr
  
  See Also:
  
  Constant Field Values
- cudaDevAttrCanFlushRemoteWrites
```
public static final int cudaDevAttrCanFlushRemoteWrites
```
  enum cudaDeviceAttr
  
  See Also:
  
  Constant Field Values
- cudaDevAttrHostRegisterSupported
```
public static final int cudaDevAttrHostRegisterSupported
```
  enum cudaDeviceAttr
  
  See Also:
  
  Constant Field Values
- cudaDevAttrPageableMemoryAccessUsesHostPageTables
```
public static final int cudaDevAttrPageableMemoryAccessUsesHostPageTables
```
  enum cudaDeviceAttr
  
  See Also:
  
  Constant Field Values
- cudaDevAttrDirectManagedMemAccessFromHost
```
public static final int cudaDevAttrDirectManagedMemAccessFromHost
```
  enum cudaDeviceAttr
  
  See Also:
  
  Constant Field Values
- cudaDevP2PAttrPerformanceRank
```
public static final int cudaDevP2PAttrPerformanceRank
```
  enum cudaDeviceP2PAttr
  
  See Also:
  
  Constant Field Values
- cudaDevP2PAttrAccessSupported
```
public static final int cudaDevP2PAttrAccessSupported
```
  enum cudaDeviceP2PAttr
  
  See Also:
  
  Constant Field Values
- cudaDevP2PAttrNativeAtomicSupported
```
public static final int cudaDevP2PAttrNativeAtomicSupported
```
  enum cudaDeviceP2PAttr
  
  See Also:
  
  Constant Field Values
- cudaDevP2PAttrCudaArrayAccessSupported
```
public static final int cudaDevP2PAttrCudaArrayAccessSupported
```
  enum cudaDeviceP2PAttr
  
  See Also:
  
  Constant Field Values
- CUDA_IPC_HANDLE_SIZE
```
public static final int CUDA_IPC_HANDLE_SIZE
```
  CUDA IPC Handle Size
  
  See Also:
  
  Constant Field Values
- cudaExternalMemoryHandleTypeOpaqueFd
```
public static final int cudaExternalMemoryHandleTypeOpaqueFd
```
  enum cudaExternalMemoryHandleType
  
  See Also:
  
  Constant Field Values
- cudaExternalMemoryHandleTypeOpaqueWin32
```
public static final int cudaExternalMemoryHandleTypeOpaqueWin32
```
  enum cudaExternalMemoryHandleType
  
  See Also:
  
  Constant Field Values
- cudaExternalMemoryHandleTypeOpaqueWin32Kmt
```
public static final int cudaExternalMemoryHandleTypeOpaqueWin32Kmt
```
  enum cudaExternalMemoryHandleType
  
  See Also:
  
  Constant Field Values
- cudaExternalMemoryHandleTypeD3D12Heap
```
public static final int cudaExternalMemoryHandleTypeD3D12Heap
```
  enum cudaExternalMemoryHandleType
  
  See Also:
  
  Constant Field Values
- cudaExternalMemoryHandleTypeD3D12Resource
```
public static final int cudaExternalMemoryHandleTypeD3D12Resource
```
  enum cudaExternalMemoryHandleType
  
  See Also:
  
  Constant Field Values
- cudaExternalMemoryHandleTypeD3D11Resource
```
public static final int cudaExternalMemoryHandleTypeD3D11Resource
```
  enum cudaExternalMemoryHandleType
  
  See Also:
  
  Constant Field Values
- cudaExternalMemoryHandleTypeD3D11ResourceKmt
```
public static final int cudaExternalMemoryHandleTypeD3D11ResourceKmt
```
  enum cudaExternalMemoryHandleType
  
  See Also:
  
  Constant Field Values
- cudaExternalMemoryHandleTypeNvSciBuf
```
public static final int cudaExternalMemoryHandleTypeNvSciBuf
```
  enum cudaExternalMemoryHandleType
  
  See Also:
  
  Constant Field Values
- cudaExternalMemoryDedicated
```
public static final int cudaExternalMemoryDedicated
```
  Indicates that the external memory object is a dedicated resource
  
  See Also:
  
  Constant Field Values
- cudaExternalSemaphoreSignalSkipNvSciBufMemSync
```
public static final int cudaExternalSemaphoreSignalSkipNvSciBufMemSync
```
  When the /p flags parameter of ::cudaExternalSemaphoreSignalParams contains this flag, it indicates that signaling an external semaphore object should skip performing appropriate memory synchronization operations over all the external memory objects that are imported as ::cudaExternalMemoryHandleTypeNvSciBuf, which otherwise are performed by default to ensure data coherency with other importers of the same NvSciBuf memory objects.
  
  See Also:
  
  Constant Field Values
- cudaExternalSemaphoreWaitSkipNvSciBufMemSync
```
public static final int cudaExternalSemaphoreWaitSkipNvSciBufMemSync
```
  When the /p flags parameter of ::cudaExternalSemaphoreWaitParams contains this flag, it indicates that waiting an external semaphore object should skip performing appropriate memory synchronization operations over all the external memory objects that are imported as ::cudaExternalMemoryHandleTypeNvSciBuf, which otherwise are performed by default to ensure data coherency with other importers of the same NvSciBuf memory objects.
  
  See Also:
  
  Constant Field Values
- cudaNvSciSyncAttrSignal
```
public static final int cudaNvSciSyncAttrSignal
```
  When /p flags of ::cudaDeviceGetNvSciSyncAttributes is set to this, it indicates that application need signaler specific NvSciSyncAttr to be filled by ::cudaDeviceGetNvSciSyncAttributes.
  
  See Also:
  
  Constant Field Values
- cudaNvSciSyncAttrWait
```
public static final int cudaNvSciSyncAttrWait
```
  When /p flags of ::cudaDeviceGetNvSciSyncAttributes is set to this, it indicates that application need waiter specific NvSciSyncAttr to be filled by ::cudaDeviceGetNvSciSyncAttributes.
  
  See Also:
  
  Constant Field Values
- cudaExternalSemaphoreHandleTypeOpaqueFd
```
public static final int cudaExternalSemaphoreHandleTypeOpaqueFd
```
  enum cudaExternalSemaphoreHandleType
  
  See Also:
  
  Constant Field Values
- cudaExternalSemaphoreHandleTypeOpaqueWin32
```
public static final int cudaExternalSemaphoreHandleTypeOpaqueWin32
```
  enum cudaExternalSemaphoreHandleType
  
  See Also:
  
  Constant Field Values
- cudaExternalSemaphoreHandleTypeOpaqueWin32Kmt
```
public static final int cudaExternalSemaphoreHandleTypeOpaqueWin32Kmt
```
  enum cudaExternalSemaphoreHandleType
  
  See Also:
  
  Constant Field Values
- cudaExternalSemaphoreHandleTypeD3D12Fence
```
public static final int cudaExternalSemaphoreHandleTypeD3D12Fence
```
  enum cudaExternalSemaphoreHandleType
  
  See Also:
  
  Constant Field Values
- cudaExternalSemaphoreHandleTypeD3D11Fence
```
public static final int cudaExternalSemaphoreHandleTypeD3D11Fence
```
  enum cudaExternalSemaphoreHandleType
  
  See Also:
  
  Constant Field Values
- cudaExternalSemaphoreHandleTypeNvSciSync
```
public static final int cudaExternalSemaphoreHandleTypeNvSciSync
```
  enum cudaExternalSemaphoreHandleType
  
  See Also:
  
  Constant Field Values
- cudaExternalSemaphoreHandleTypeKeyedMutex
```
public static final int cudaExternalSemaphoreHandleTypeKeyedMutex
```
  enum cudaExternalSemaphoreHandleType
  
  See Also:
  
  Constant Field Values
- cudaExternalSemaphoreHandleTypeKeyedMutexKmt
```
public static final int cudaExternalSemaphoreHandleTypeKeyedMutexKmt
```
  enum cudaExternalSemaphoreHandleType
  
  See Also:
  
  Constant Field Values
- cudaCGScopeInvalid
```
public static final int cudaCGScopeInvalid
```
  enum cudaCGScope
  
  See Also:
  
  Constant Field Values
- cudaCGScopeGrid
```
public static final int cudaCGScopeGrid
```
  enum cudaCGScope
  
  See Also:
  
  Constant Field Values
- cudaCGScopeMultiGrid
```
public static final int cudaCGScopeMultiGrid
```
  enum cudaCGScope
  
  See Also:
  
  Constant Field Values
- cudaGraphNodeTypeKernel
```
public static final int cudaGraphNodeTypeKernel
```
  enum cudaGraphNodeType
  
  See Also:
  
  Constant Field Values
- cudaGraphNodeTypeMemcpy
```
public static final int cudaGraphNodeTypeMemcpy
```
  enum cudaGraphNodeType
  
  See Also:
  
  Constant Field Values
- cudaGraphNodeTypeMemset
```
public static final int cudaGraphNodeTypeMemset
```
  enum cudaGraphNodeType
  
  See Also:
  
  Constant Field Values
- cudaGraphNodeTypeHost
```
public static final int cudaGraphNodeTypeHost
```
  enum cudaGraphNodeType
  
  See Also:
  
  Constant Field Values
- cudaGraphNodeTypeGraph
```
public static final int cudaGraphNodeTypeGraph
```
  enum cudaGraphNodeType
  
  See Also:
  
  Constant Field Values
- cudaGraphNodeTypeEmpty
```
public static final int cudaGraphNodeTypeEmpty
```
  enum cudaGraphNodeType
  
  See Also:
  
  Constant Field Values
- cudaGraphNodeTypeCount
```
public static final int cudaGraphNodeTypeCount
```
  enum cudaGraphNodeType
  
  See Also:
  
  Constant Field Values
- cudaGraphExecUpdateSuccess
```
public static final int cudaGraphExecUpdateSuccess
```
  enum cudaGraphExecUpdateResult
  
  See Also:
  
  Constant Field Values
- cudaGraphExecUpdateError
```
public static final int cudaGraphExecUpdateError
```
  enum cudaGraphExecUpdateResult
  
  See Also:
  
  Constant Field Values
- cudaGraphExecUpdateErrorTopologyChanged
```
public static final int cudaGraphExecUpdateErrorTopologyChanged
```
  enum cudaGraphExecUpdateResult
  
  See Also:
  
  Constant Field Values
- cudaGraphExecUpdateErrorNodeTypeChanged
```
public static final int cudaGraphExecUpdateErrorNodeTypeChanged
```
  enum cudaGraphExecUpdateResult
  
  See Also:
  
  Constant Field Values
- cudaGraphExecUpdateErrorFunctionChanged
```
public static final int cudaGraphExecUpdateErrorFunctionChanged
```
  enum cudaGraphExecUpdateResult
  
  See Also:
  
  Constant Field Values
- cudaGraphExecUpdateErrorParametersChanged
```
public static final int cudaGraphExecUpdateErrorParametersChanged
```
  enum cudaGraphExecUpdateResult
  
  See Also:
  
  Constant Field Values
- cudaGraphExecUpdateErrorNotSupported
```
public static final int cudaGraphExecUpdateErrorNotSupported
```
  enum cudaGraphExecUpdateResult
  
  See Also:
  
  Constant Field Values
- cudaSurfaceType1D
```
public static final int cudaSurfaceType1D
```
  * * *
  
  See Also:
  
  Constant Field Values
- cudaSurfaceType2D
```
public static final int cudaSurfaceType2D
```
  See Also:
  
  Constant Field Values
- cudaSurfaceType3D
```
public static final int cudaSurfaceType3D
```
  See Also:
  
  Constant Field Values
- cudaSurfaceTypeCubemap
```
public static final int cudaSurfaceTypeCubemap
```
  See Also:
  
  Constant Field Values
- cudaSurfaceType1DLayered
```
public static final int cudaSurfaceType1DLayered
```
  See Also:
  
  Constant Field Values
- cudaSurfaceType2DLayered
```
public static final int cudaSurfaceType2DLayered
```
  See Also:
  
  Constant Field Values
- cudaSurfaceTypeCubemapLayered
```
public static final int cudaSurfaceTypeCubemapLayered
```
  See Also:
  
  Constant Field Values
- cudaBoundaryModeZero
```
public static final int cudaBoundaryModeZero
```
  enum cudaSurfaceBoundaryMode
  
  See Also:
  
  Constant Field Values
- cudaBoundaryModeClamp
```
public static final int cudaBoundaryModeClamp
```
  enum cudaSurfaceBoundaryMode
  
  See Also:
  
  Constant Field Values
- cudaBoundaryModeTrap
```
public static final int cudaBoundaryModeTrap
```
  enum cudaSurfaceBoundaryMode
  
  See Also:
  
  Constant Field Values
- cudaFormatModeForced
```
public static final int cudaFormatModeForced
```
  enum cudaSurfaceFormatMode
  
  See Also:
  
  Constant Field Values
- cudaFormatModeAuto
```
public static final int cudaFormatModeAuto
```
  enum cudaSurfaceFormatMode
  
  See Also:
  
  Constant Field Values
- cudaTextureType1D
```
public static final int cudaTextureType1D
```
  * * *
  
  See Also:
  
  Constant Field Values
- cudaTextureType2D
```
public static final int cudaTextureType2D
```
  See Also:
  
  Constant Field Values
- cudaTextureType3D
```
public static final int cudaTextureType3D
```
  See Also:
  
  Constant Field Values
- cudaTextureTypeCubemap
```
public static final int cudaTextureTypeCubemap
```
  See Also:
  
  Constant Field Values
- cudaTextureType1DLayered
```
public static final int cudaTextureType1DLayered
```
  See Also:
  
  Constant Field Values
- cudaTextureType2DLayered
```
public static final int cudaTextureType2DLayered
```
  See Also:
  
  Constant Field Values
- cudaTextureTypeCubemapLayered
```
public static final int cudaTextureTypeCubemapLayered
```
  See Also:
  
  Constant Field Values
- cudaAddressModeWrap
```
public static final int cudaAddressModeWrap
```
  enum cudaTextureAddressMode
  
  See Also:
  
  Constant Field Values
- cudaAddressModeClamp
```
public static final int cudaAddressModeClamp
```
  enum cudaTextureAddressMode
  
  See Also:
  
  Constant Field Values
- cudaAddressModeMirror
```
public static final int cudaAddressModeMirror
```
  enum cudaTextureAddressMode
  
  See Also:
  
  Constant Field Values
- cudaAddressModeBorder
```
public static final int cudaAddressModeBorder
```
  enum cudaTextureAddressMode
  
  See Also:
  
  Constant Field Values
- cudaFilterModePoint
```
public static final int cudaFilterModePoint
```
  enum cudaTextureFilterMode
  
  See Also:
  
  Constant Field Values
- cudaFilterModeLinear
```
public static final int cudaFilterModeLinear
```
  enum cudaTextureFilterMode
  
  See Also:
  
  Constant Field Values
- cudaReadModeElementType
```
public static final int cudaReadModeElementType
```
  enum cudaTextureReadMode
  
  See Also:
  
  Constant Field Values
- cudaReadModeNormalizedFloat
```
public static final int cudaReadModeNormalizedFloat
```
  enum cudaTextureReadMode
  
  See Also:
  
  Constant Field Values
- CUDART_VERSION
```
public static final int CUDART_VERSION
```
  CUDA Runtime API Version
  
  See Also:
  
  Constant Field Values
- CUDA_R_16F
```
public static final int CUDA_R_16F
```
  enum cudaDataType
  
  See Also:
  
  Constant Field Values
- CUDA_C_16F
```
public static final int CUDA_C_16F
```
  enum cudaDataType
  
  See Also:
  
  Constant Field Values
- CUDA_R_32F
```
public static final int CUDA_R_32F
```
  enum cudaDataType
  
  See Also:
  
  Constant Field Values
- CUDA_C_32F
```
public static final int CUDA_C_32F
```
  enum cudaDataType
  
  See Also:
  
  Constant Field Values
- CUDA_R_64F
```
public static final int CUDA_R_64F
```
  enum cudaDataType
  
  See Also:
  
  Constant Field Values
- CUDA_C_64F
```
public static final int CUDA_C_64F
```
  enum cudaDataType
  
  See Also:
  
  Constant Field Values
- CUDA_R_8I
```
public static final int CUDA_R_8I
```
  enum cudaDataType
  
  See Also:
  
  Constant Field Values
- CUDA_C_8I
```
public static final int CUDA_C_8I
```
  enum cudaDataType
  
  See Also:
  
  Constant Field Values
- CUDA_R_8U
```
public static final int CUDA_R_8U
```
  enum cudaDataType
  
  See Also:
  
  Constant Field Values
- CUDA_C_8U
```
public static final int CUDA_C_8U
```
  enum cudaDataType
  
  See Also:
  
  Constant Field Values
- CUDA_R_32I
```
public static final int CUDA_R_32I
```
  enum cudaDataType
  
  See Also:
  
  Constant Field Values
- CUDA_C_32I
```
public static final int CUDA_C_32I
```
  enum cudaDataType
  
  See Also:
  
  Constant Field Values
- CUDA_R_32U
```
public static final int CUDA_R_32U
```
  enum cudaDataType
  
  See Also:
  
  Constant Field Values
- CUDA_C_32U
```
public static final int CUDA_C_32U
```
  enum cudaDataType
  
  See Also:
  
  Constant Field Values
- MAJOR_VERSION
```
public static final int MAJOR_VERSION
```
  enum libraryPropertyType
  
  See Also:
  
  Constant Field Values
- MINOR_VERSION
```
public static final int MINOR_VERSION
```
  enum libraryPropertyType
  
  See Also:
  
  Constant Field Values
- PATCH_LEVEL
```
public static final int PATCH_LEVEL
```
  enum libraryPropertyType
  
  See Also:
  
  Constant Field Values

Constructor Detail
- cudart
```
public cudart()
```

Method Detail

CU_STREAM_LEGACY
```
@MemberGetter
public static CUstream_st CU_STREAM_LEGACY()
```
Legacy stream handle Stream handle that can be passed as a CUstream to use an implicit stream with legacy synchronization behavior. See details of the \link_sync_behavior

CU_STREAM_PER_THREAD
```
@MemberGetter
public static CUstream_st CU_STREAM_PER_THREAD()
```
Per-thread stream handle Stream handle that can be passed as a CUstream to use an implicit stream with per-thread synchronization behavior. See details of the \link_sync_behavior

CU_LAUNCH_PARAM_END
```
@MemberGetter
public static Pointer CU_LAUNCH_PARAM_END()
```
End of array terminator for the \p extra parameter to ::cuLaunchKernel

CU_LAUNCH_PARAM_BUFFER_POINTER
```
@MemberGetter
public static Pointer CU_LAUNCH_PARAM_BUFFER_POINTER()
```
Indicator that the next value in the \p extra parameter to ::cuLaunchKernel will be a pointer to a buffer containing all kernel parameters used for launching kernel \p f. This buffer needs to honor all alignment/padding requirements of the individual parameters. If ::CU_LAUNCH_PARAM_BUFFER_SIZE is not also specified in the \p extra array, then ::CU_LAUNCH_PARAM_BUFFER_POINTER will have no effect.

CU_LAUNCH_PARAM_BUFFER_SIZE
```
@MemberGetter
public static Pointer CU_LAUNCH_PARAM_BUFFER_SIZE()
```
Indicator that the next value in the \p extra parameter to ::cuLaunchKernel will be a pointer to a size_t which contains the size of the buffer specified with ::CU_LAUNCH_PARAM_BUFFER_POINTER. It is required that ::CU_LAUNCH_PARAM_BUFFER_POINTER also be specified in the \p extra array if the value associated with ::CU_LAUNCH_PARAM_BUFFER_SIZE is not zero.

CU_DEVICE_CPU

@MemberGetter
public static int CU_DEVICE_CPU()

Device that represents the CPU

CU_DEVICE_INVALID
```
@MemberGetter
public static int CU_DEVICE_INVALID()
```
Device that represents an invalid device

cuGetErrorString
```
@Cast("CUresult")
public static int cuGetErrorString(@Cast("CUresult")
                                   int error,
                                   @Cast("const char**")
                                   PointerPointer pStr)
```
\brief Gets the string description of an error code Sets \p *pStr to the address of a NULL-terminated string description of the error code \p error. If the error code is not recognized, ::CUDA_ERROR_INVALID_VALUE will be returned and \p *pStr will be set to the NULL address.

Parameters:

error - - Error code to convert to string

pStr - - Address of the string pointer.

Returns:

::CUDA_SUCCESS, ::CUDA_ERROR_INVALID_VALUE

cuGetErrorString

@Cast("CUresult")
public static int cuGetErrorString(@Cast("CUresult")
                                   int error,
                                   @Cast("const char**") @ByPtrPtr
                                   BytePointer pStr)

cuGetErrorString

@Cast("CUresult")
public static int cuGetErrorString(@Cast("CUresult")
                                   int error,
                                   @Cast("const char**") @ByPtrPtr
                                   ByteBuffer pStr)

cuGetErrorString

@Cast("CUresult")
public static int cuGetErrorString(@Cast("CUresult")
                                   int error,
                                   @Cast("const char**") @ByPtrPtr
                                   byte[] pStr)

cuGetErrorName
```
@Cast("CUresult")
public static int cuGetErrorName(@Cast("CUresult")
                                 int error,
                                 @Cast("const char**")
                                 PointerPointer pStr)
```
\brief Gets the string representation of an error code enum name Sets \p *pStr to the address of a NULL-terminated string representation of the name of the enum error code \p error. If the error code is not recognized, ::CUDA_ERROR_INVALID_VALUE will be returned and \p *pStr will be set to the NULL address.

Parameters:

error - - Error code to convert to string

pStr - - Address of the string pointer.

Returns:

::CUDA_SUCCESS, ::CUDA_ERROR_INVALID_VALUE

cuGetErrorName

@Cast("CUresult")
public static int cuGetErrorName(@Cast("CUresult")
                                 int error,
                                 @Cast("const char**") @ByPtrPtr
                                 BytePointer pStr)

cuGetErrorName

@Cast("CUresult")
public static int cuGetErrorName(@Cast("CUresult")
                                 int error,
                                 @Cast("const char**") @ByPtrPtr
                                 ByteBuffer pStr)

cuGetErrorName

@Cast("CUresult")
public static int cuGetErrorName(@Cast("CUresult")
                                 int error,
                                 @Cast("const char**") @ByPtrPtr
                                 byte[] pStr)

cuInit
```
@Cast("CUresult")
public static int cuInit(@Cast("unsigned int")
                         int Flags)
```
\brief Initialize the CUDA driver API Initializes the driver API and must be called before any other function from the driver API. Currently, the \p Flags parameter must be 0. If ::cuInit() has not been called, any function from the driver API will return ::CUDA_ERROR_NOT_INITIALIZED.

Parameters:

Flags - - Initialization flag for CUDA.

Returns:

::CUDA_SUCCESS, ::CUDA_ERROR_INVALID_VALUE, ::CUDA_ERROR_INVALID_DEVICE, ::CUDA_ERROR_SYSTEM_DRIVER_MISMATCH, ::CUDA_ERROR_COMPAT_NOT_SUPPORTED_ON_DEVICE \notefnerr

cuDriverGetVersion
```
@Cast("CUresult")
public static int cuDriverGetVersion(IntPointer driverVersion)
```
\brief Returns the latest CUDA version supported by driver Returns in \p *driverVersion the version of CUDA supported by the driver. The version is returned as (1000 × major + 10 × minor). For example, CUDA 9.2 would be represented by 9020. This function automatically returns ::CUDA_ERROR_INVALID_VALUE if \p driverVersion is NULL.

Parameters:

driverVersion - - Returns the CUDA driver version

Returns:

::CUDA_SUCCESS, ::CUDA_ERROR_INVALID_VALUE \notefnerr

cuDriverGetVersion

@Cast("CUresult")
public static int cuDriverGetVersion(IntBuffer driverVersion)

cuDriverGetVersion

@Cast("CUresult")
public static int cuDriverGetVersion(int[] driverVersion)

cuDeviceGet
```
@Cast("CUresult")
public static int cuDeviceGet(@Cast("CUdevice*")
                              IntPointer device,
                              int ordinal)
```
\brief Returns a handle to a compute device Returns in \p *device a device handle given an ordinal in the range [0, ::cuDeviceGetCount()-1].

Parameters:

device - - Returned device handle

ordinal - - Device number to get handle for

Returns:

::CUDA_SUCCESS, ::CUDA_ERROR_DEINITIALIZED, ::CUDA_ERROR_NOT_INITIALIZED, ::CUDA_ERROR_INVALID_CONTEXT, ::CUDA_ERROR_INVALID_VALUE, ::CUDA_ERROR_INVALID_DEVICE \notefnerr

cuDeviceGet

@Cast("CUresult")
public static int cuDeviceGet(@Cast("CUdevice*")
                              IntBuffer device,
                              int ordinal)

cuDeviceGet

@Cast("CUresult")
public static int cuDeviceGet(@Cast("CUdevice*")
                              int[] device,
                              int ordinal)

cuDeviceGetCount
```
@Cast("CUresult")
public static int cuDeviceGetCount(IntPointer count)
```
\brief Returns the number of compute-capable devices Returns in \p *count the number of devices with compute capability greater than or equal to 2.0 that are available for execution. If there is no such device, ::cuDeviceGetCount() returns 0.

Parameters:

count - - Returned number of compute-capable devices

Returns:

::CUDA_SUCCESS, ::CUDA_ERROR_DEINITIALIZED, ::CUDA_ERROR_NOT_INITIALIZED, ::CUDA_ERROR_INVALID_CONTEXT, ::CUDA_ERROR_INVALID_VALUE \notefnerr

cuDeviceGetCount

@Cast("CUresult")
public static int cuDeviceGetCount(IntBuffer count)

cuDeviceGetCount

@Cast("CUresult")
public static int cuDeviceGetCount(int[] count)

cuDeviceGetName
```
@Cast("CUresult")
public static int cuDeviceGetName(@Cast("char*")
                                  BytePointer name,
                                  int len,
                                  @Cast("CUdevice")
                                  int dev)
```
\brief Returns an identifer string for the device Returns an ASCII string identifying the device \p dev in the NULL-terminated string pointed to by \p name. \p len specifies the maximum length of the string that may be returned.

Parameters:

name - - Returned identifier string for the device

len - - Maximum length of string to store in \p name

dev - - Device to get identifier string for

Returns:

::CUDA_SUCCESS, ::CUDA_ERROR_DEINITIALIZED, ::CUDA_ERROR_NOT_INITIALIZED, ::CUDA_ERROR_INVALID_CONTEXT, ::CUDA_ERROR_INVALID_VALUE, ::CUDA_ERROR_INVALID_DEVICE \notefnerr

cuDeviceGetName

@Cast("CUresult")
public static int cuDeviceGetName(@Cast("char*")
                                  ByteBuffer name,
                                  int len,
                                  @Cast("CUdevice")
                                  int dev)

cuDeviceGetName

@Cast("CUresult")
public static int cuDeviceGetName(@Cast("char*")
                                  byte[] name,
                                  int len,
                                  @Cast("CUdevice")
                                  int dev)

cuDeviceGetUuid
```
@Cast("CUresult")
public static int cuDeviceGetUuid(CUuuid uuid,
                                  @Cast("CUdevice")
                                  int dev)
```
\brief Return an UUID for the device Returns 16-octets identifing the device \p dev in the structure pointed by the \p uuid.

Parameters:

uuid - - Returned UUID

dev - - Device to get identifier string for

Returns:

::CUDA_SUCCESS, ::CUDA_ERROR_DEINITIALIZED, ::CUDA_ERROR_NOT_INITIALIZED, ::CUDA_ERROR_INVALID_VALUE, ::CUDA_ERROR_INVALID_DEVICE \notefnerr

cuDeviceTotalMem
```
@Cast("CUresult")
public static int cuDeviceTotalMem(@Cast("size_t*")
                                   SizeTPointer bytes,
                                   @Cast("CUdevice")
                                   int dev)
```
\brief Returns the total amount of memory on the device Returns in \p *bytes the total amount of memory available on the device \p dev in bytes.

Parameters:

bytes - - Returned memory available on device in bytes

dev - - Device handle

Returns:

::CUDA_SUCCESS, ::CUDA_ERROR_DEINITIALIZED, ::CUDA_ERROR_NOT_INITIALIZED, ::CUDA_ERROR_INVALID_CONTEXT, ::CUDA_ERROR_INVALID_VALUE, ::CUDA_ERROR_INVALID_DEVICE \notefnerr

cuDeviceGetAttribute
```
@Cast("CUresult")
public static int cuDeviceGetAttribute(IntPointer pi,
                                       @Cast("CUdevice_attribute")
                                       int attrib,
                                       @Cast("CUdevice")
                                       int dev)
```
\brief Returns information about the device Returns in \p *pi the integer value of the attribute \p attrib on device \p dev. The supported attributes are: - ::CU_DEVICE_ATTRIBUTE_MAX_THREADS_PER_BLOCK: Maximum number of threads per block; - ::CU_DEVICE_ATTRIBUTE_MAX_BLOCK_DIM_X: Maximum x-dimension of a block; - ::CU_DEVICE_ATTRIBUTE_MAX_BLOCK_DIM_Y: Maximum y-dimension of a block; - ::CU_DEVICE_ATTRIBUTE_MAX_BLOCK_DIM_Z: Maximum z-dimension of a block; - ::CU_DEVICE_ATTRIBUTE_MAX_GRID_DIM_X: Maximum x-dimension of a grid; - ::CU_DEVICE_ATTRIBUTE_MAX_GRID_DIM_Y: Maximum y-dimension of a grid; - ::CU_DEVICE_ATTRIBUTE_MAX_GRID_DIM_Z: Maximum z-dimension of a grid; - ::CU_DEVICE_ATTRIBUTE_MAX_SHARED_MEMORY_PER_BLOCK: Maximum amount of shared memory available to a thread block in bytes; - ::CU_DEVICE_ATTRIBUTE_TOTAL_CONSTANT_MEMORY: Memory available on device for __constant__ variables in a CUDA C kernel in bytes; - ::CU_DEVICE_ATTRIBUTE_WARP_SIZE: Warp size in threads; - ::CU_DEVICE_ATTRIBUTE_MAX_PITCH: Maximum pitch in bytes allowed by the memory copy functions that involve memory regions allocated through ::cuMemAllocPitch(); - ::CU_DEVICE_ATTRIBUTE_MAXIMUM_TEXTURE1D_WIDTH: Maximum 1D texture width; - ::CU_DEVICE_ATTRIBUTE_MAXIMUM_TEXTURE1D_LINEAR_WIDTH: Maximum width for a 1D texture bound to linear memory; - ::CU_DEVICE_ATTRIBUTE_MAXIMUM_TEXTURE1D_MIPMAPPED_WIDTH: Maximum mipmapped 1D texture width; - ::CU_DEVICE_ATTRIBUTE_MAXIMUM_TEXTURE2D_WIDTH: Maximum 2D texture width; - ::CU_DEVICE_ATTRIBUTE_MAXIMUM_TEXTURE2D_HEIGHT: Maximum 2D texture height; - ::CU_DEVICE_ATTRIBUTE_MAXIMUM_TEXTURE2D_LINEAR_WIDTH: Maximum width for a 2D texture bound to linear memory; - ::CU_DEVICE_ATTRIBUTE_MAXIMUM_TEXTURE2D_LINEAR_HEIGHT: Maximum height for a 2D texture bound to linear memory; - ::CU_DEVICE_ATTRIBUTE_MAXIMUM_TEXTURE2D_LINEAR_PITCH: Maximum pitch in bytes for a 2D texture bound to linear memory; - ::CU_DEVICE_ATTRIBUTE_MAXIMUM_TEXTURE2D_MIPMAPPED_WIDTH: Maximum mipmapped 2D texture width; - ::CU_DEVICE_ATTRIBUTE_MAXIMUM_TEXTURE2D_MIPMAPPED_HEIGHT: Maximum mipmapped 2D texture height; - ::CU_DEVICE_ATTRIBUTE_MAXIMUM_TEXTURE3D_WIDTH: Maximum 3D texture width; - ::CU_DEVICE_ATTRIBUTE_MAXIMUM_TEXTURE3D_HEIGHT: Maximum 3D texture height; - ::CU_DEVICE_ATTRIBUTE_MAXIMUM_TEXTURE3D_DEPTH: Maximum 3D texture depth; - ::CU_DEVICE_ATTRIBUTE_MAXIMUM_TEXTURE3D_WIDTH_ALTERNATE: Alternate maximum 3D texture width, 0 if no alternate maximum 3D texture size is supported; - ::CU_DEVICE_ATTRIBUTE_MAXIMUM_TEXTURE3D_HEIGHT_ALTERNATE: Alternate maximum 3D texture height, 0 if no alternate maximum 3D texture size is supported; - ::CU_DEVICE_ATTRIBUTE_MAXIMUM_TEXTURE3D_DEPTH_ALTERNATE: Alternate maximum 3D texture depth, 0 if no alternate maximum 3D texture size is supported; - ::CU_DEVICE_ATTRIBUTE_MAXIMUM_TEXTURECUBEMAP_WIDTH: Maximum cubemap texture width or height; - ::CU_DEVICE_ATTRIBUTE_MAXIMUM_TEXTURE1D_LAYERED_WIDTH: Maximum 1D layered texture width; - ::CU_DEVICE_ATTRIBUTE_MAXIMUM_TEXTURE1D_LAYERED_LAYERS: Maximum layers in a 1D layered texture; - ::CU_DEVICE_ATTRIBUTE_MAXIMUM_TEXTURE2D_LAYERED_WIDTH: Maximum 2D layered texture width; - ::CU_DEVICE_ATTRIBUTE_MAXIMUM_TEXTURE2D_LAYERED_HEIGHT: Maximum 2D layered texture height; - ::CU_DEVICE_ATTRIBUTE_MAXIMUM_TEXTURE2D_LAYERED_LAYERS: Maximum layers in a 2D layered texture; - ::CU_DEVICE_ATTRIBUTE_MAXIMUM_TEXTURECUBEMAP_LAYERED_WIDTH: Maximum cubemap layered texture width or height; - ::CU_DEVICE_ATTRIBUTE_MAXIMUM_TEXTURECUBEMAP_LAYERED_LAYERS: Maximum layers in a cubemap layered texture; - ::CU_DEVICE_ATTRIBUTE_MAXIMUM_SURFACE1D_WIDTH: Maximum 1D surface width; - ::CU_DEVICE_ATTRIBUTE_MAXIMUM_SURFACE2D_WIDTH: Maximum 2D surface width; - ::CU_DEVICE_ATTRIBUTE_MAXIMUM_SURFACE2D_HEIGHT: Maximum 2D surface height; - ::CU_DEVICE_ATTRIBUTE_MAXIMUM_SURFACE3D_WIDTH: Maximum 3D surface width; - ::CU_DEVICE_ATTRIBUTE_MAXIMUM_SURFACE3D_HEIGHT: Maximum 3D surface height; - ::CU_DEVICE_ATTRIBUTE_MAXIMUM_SURFACE3D_DEPTH: Maximum 3D surface depth; - ::CU_DEVICE_ATTRIBUTE_MAXIMUM_SURFACE1D_LAYERED_WIDTH: Maximum 1D layered surface width; - ::CU_DEVICE_ATTRIBUTE_MAXIMUM_SURFACE1D_LAYERED_LAYERS: Maximum layers in a 1D layered surface; - ::CU_DEVICE_ATTRIBUTE_MAXIMUM_SURFACE2D_LAYERED_WIDTH: Maximum 2D layered surface width; - ::CU_DEVICE_ATTRIBUTE_MAXIMUM_SURFACE2D_LAYERED_HEIGHT: Maximum 2D layered surface height; - ::CU_DEVICE_ATTRIBUTE_MAXIMUM_SURFACE2D_LAYERED_LAYERS: Maximum layers in a 2D layered surface; - ::CU_DEVICE_ATTRIBUTE_MAXIMUM_SURFACECUBEMAP_WIDTH: Maximum cubemap surface width; - ::CU_DEVICE_ATTRIBUTE_MAXIMUM_SURFACECUBEMAP_LAYERED_WIDTH: Maximum cubemap layered surface width; - ::CU_DEVICE_ATTRIBUTE_MAXIMUM_SURFACECUBEMAP_LAYERED_LAYERS: Maximum layers in a cubemap layered surface; - ::CU_DEVICE_ATTRIBUTE_MAX_REGISTERS_PER_BLOCK: Maximum number of 32-bit registers available to a thread block; - ::CU_DEVICE_ATTRIBUTE_CLOCK_RATE: The typical clock frequency in kilohertz; - ::CU_DEVICE_ATTRIBUTE_TEXTURE_ALIGNMENT: Alignment requirement; texture base addresses aligned to ::textureAlign bytes do not need an offset applied to texture fetches; - ::CU_DEVICE_ATTRIBUTE_TEXTURE_PITCH_ALIGNMENT: Pitch alignment requirement for 2D texture references bound to pitched memory; - ::CU_DEVICE_ATTRIBUTE_GPU_OVERLAP: 1 if the device can concurrently copy memory between host and device while executing a kernel, or 0 if not; - ::CU_DEVICE_ATTRIBUTE_MULTIPROCESSOR_COUNT: Number of multiprocessors on the device; - ::CU_DEVICE_ATTRIBUTE_KERNEL_EXEC_TIMEOUT: 1 if there is a run time limit for kernels executed on the device, or 0 if not; - ::CU_DEVICE_ATTRIBUTE_INTEGRATED: 1 if the device is integrated with the memory subsystem, or 0 if not; - ::CU_DEVICE_ATTRIBUTE_CAN_MAP_HOST_MEMORY: 1 if the device can map host memory into the CUDA address space, or 0 if not; - ::CU_DEVICE_ATTRIBUTE_COMPUTE_MODE: Compute mode that device is currently in. Available modes are as follows: - ::CU_COMPUTEMODE_DEFAULT: Default mode - Device is not restricted and can have multiple CUDA contexts present at a single time. - ::CU_COMPUTEMODE_PROHIBITED: Compute-prohibited mode - Device is prohibited from creating new CUDA contexts. - ::CU_COMPUTEMODE_EXCLUSIVE_PROCESS: Compute-exclusive-process mode - Device can have only one context used by a single process at a time. - ::CU_DEVICE_ATTRIBUTE_CONCURRENT_KERNELS: 1 if the device supports executing multiple kernels within the same context simultaneously, or 0 if not. It is not guaranteed that multiple kernels will be resident on the device concurrently so this feature should not be relied upon for correctness; - ::CU_DEVICE_ATTRIBUTE_ECC_ENABLED: 1 if error correction is enabled on the device, 0 if error correction is disabled or not supported by the device; - ::CU_DEVICE_ATTRIBUTE_PCI_BUS_ID: PCI bus identifier of the device; - ::CU_DEVICE_ATTRIBUTE_PCI_DEVICE_ID: PCI device (also known as slot) identifier of the device; - ::CU_DEVICE_ATTRIBUTE_PCI_DOMAIN_ID: PCI domain identifier of the device - ::CU_DEVICE_ATTRIBUTE_TCC_DRIVER: 1 if the device is using a TCC driver. TCC is only available on Tesla hardware running Windows Vista or later; - ::CU_DEVICE_ATTRIBUTE_MEMORY_CLOCK_RATE: Peak memory clock frequency in kilohertz; - ::CU_DEVICE_ATTRIBUTE_GLOBAL_MEMORY_BUS_WIDTH: Global memory bus width in bits; - ::CU_DEVICE_ATTRIBUTE_L2_CACHE_SIZE: Size of L2 cache in bytes. 0 if the device doesn't have L2 cache; - ::CU_DEVICE_ATTRIBUTE_MAX_THREADS_PER_MULTIPROCESSOR: Maximum resident threads per multiprocessor; - ::CU_DEVICE_ATTRIBUTE_UNIFIED_ADDRESSING: 1 if the device shares a unified address space with the host, or 0 if not; - ::CU_DEVICE_ATTRIBUTE_COMPUTE_CAPABILITY_MAJOR: Major compute capability version number; - ::CU_DEVICE_ATTRIBUTE_COMPUTE_CAPABILITY_MINOR: Minor compute capability version number; - ::CU_DEVICE_ATTRIBUTE_GLOBAL_L1_CACHE_SUPPORTED: 1 if device supports caching globals in L1 cache, 0 if caching globals in L1 cache is not supported by the device; - ::CU_DEVICE_ATTRIBUTE_LOCAL_L1_CACHE_SUPPORTED: 1 if device supports caching locals in L1 cache, 0 if caching locals in L1 cache is not supported by the device; - ::CU_DEVICE_ATTRIBUTE_MAX_SHARED_MEMORY_PER_MULTIPROCESSOR: Maximum amount of shared memory available to a multiprocessor in bytes; this amount is shared by all thread blocks simultaneously resident on a multiprocessor; - ::CU_DEVICE_ATTRIBUTE_MAX_REGISTERS_PER_MULTIPROCESSOR: Maximum number of 32-bit registers available to a multiprocessor; this number is shared by all thread blocks simultaneously resident on a multiprocessor; - ::CU_DEVICE_ATTRIBUTE_MANAGED_MEMORY: 1 if device supports allocating managed memory on this system, 0 if allocating managed memory is not supported by the device on this system. - ::CU_DEVICE_ATTRIBUTE_MULTI_GPU_BOARD: 1 if device is on a multi-GPU board, 0 if not. - ::CU_DEVICE_ATTRIBUTE_MULTI_GPU_BOARD_GROUP_ID: Unique identifier for a group of devices associated with the same board. Devices on the same multi-GPU board will share the same identifier. - ::CU_DEVICE_ATTRIBUTE_HOST_NATIVE_ATOMIC_SUPPORTED: 1 if Link between the device and the host supports native atomic operations. - ::CU_DEVICE_ATTRIBUTE_SINGLE_TO_DOUBLE_PRECISION_PERF_RATIO: Ratio of single precision performance (in floating-point operations per second) to double precision performance. - ::CU_DEVICE_ATTRIBUTE_PAGEABLE_MEMORY_ACCESS: Device suppports coherently accessing pageable memory without calling cudaHostRegister on it. - ::CU_DEVICE_ATTRIBUTE_CONCURRENT_MANAGED_ACCESS: Device can coherently access managed memory concurrently with the CPU. - ::CU_DEVICE_ATTRIBUTE_COMPUTE_PREEMPTION_SUPPORTED: Device supports Compute Preemption. - ::CU_DEVICE_ATTRIBUTE_CAN_USE_HOST_POINTER_FOR_REGISTERED_MEM: Device can access host registered memory at the same virtual address as the CPU. - ::CU_DEVICE_ATTRIBUTE_MAX_SHARED_MEMORY_PER_BLOCK_OPTIN: The maximum per block shared memory size suported on this device. This is the maximum value that can be opted into when using the cuFuncSetAttribute() call. For more details see ::CU_FUNC_ATTRIBUTE_MAX_DYNAMIC_SHARED_SIZE_BYTES - ::CU_DEVICE_ATTRIBUTE_PAGEABLE_MEMORY_ACCESS_USES_HOST_PAGE_TABLES: Device accesses pageable memory via the host's page tables. - ::CU_DEVICE_ATTRIBUTE_DIRECT_MANAGED_MEM_ACCESS_FROM_HOST: The host can directly access managed memory on the device without migration. - ::CU_DEVICE_ATTRIBUTE_VIRTUAL_ADDRESS_MANAGEMENT_SUPPORTED: Device supports virtual address management APIs like ::cuMemAddressReserve, ::cuMemCreate, ::cuMemMap and related APIs - ::CU_DEVICE_ATTRIBUTE_HANDLE_TYPE_POSIX_FILE_DESCRIPTOR_SUPPORTED: Device supports exporting memory to a posix file descriptor with ::cuMemExportToShareableHandle, if requested via ::cuMemCreate - ::CU_DEVICE_ATTRIBUTE_HANDLE_TYPE_WIN32_HANDLE_SUPPORTED: Device supports exporting memory to a Win32 NT handle with ::cuMemExportToShareableHandle, if requested via ::cuMemCreate - ::CU_DEVICE_ATTRIBUTE_HANDLE_TYPE_WIN32_KMT_HANDLE_SUPPORTED: Device supports exporting memory to a Win32 KMT handle with ::cuMemExportToShareableHandle, if requested ::cuMemCreate

Parameters:

pi - - Returned device attribute value

attrib - - Device attribute to query

dev - - Device handle

Returns:

::CUDA_SUCCESS, ::CUDA_ERROR_DEINITIALIZED, ::CUDA_ERROR_NOT_INITIALIZED, ::CUDA_ERROR_INVALID_CONTEXT, ::CUDA_ERROR_INVALID_VALUE, ::CUDA_ERROR_INVALID_DEVICE \notefnerr

cuDeviceGetAttribute

@Cast("CUresult")
public static int cuDeviceGetAttribute(IntBuffer pi,
                                       @Cast("CUdevice_attribute")
                                       int attrib,
                                       @Cast("CUdevice")
                                       int dev)

cuDeviceGetAttribute

@Cast("CUresult")
public static int cuDeviceGetAttribute(int[] pi,
                                       @Cast("CUdevice_attribute")
                                       int attrib,
                                       @Cast("CUdevice")
                                       int dev)

cuDeviceGetProperties
```
@Cast("CUresult")
@Deprecated
public static int cuDeviceGetProperties(CUdevprop prop,
                                        @Cast("CUdevice")
                                        int dev)
```
Deprecated.
This function was deprecated as of CUDA 5.0 and replaced by ::cuDeviceGetAttribute(). Returns in \p *prop the properties of device \p dev. The ::CUdevprop structure is defined as:
```
     typedef struct CUdevprop_st {
     int maxThreadsPerBlock;
     int maxThreadsDim[3];
     int maxGridSize[3];
     int sharedMemPerBlock;
     int totalConstantMemory;
     int SIMDWidth;
     int memPitch;
     int regsPerBlock;
     int clockRate;
     int textureAlign
  } CUdevprop;
 
```
where: - ::maxThreadsPerBlock is the maximum number of threads per block; - ::maxThreadsDim[3] is the maximum sizes of each dimension of a block; - ::maxGridSize[3] is the maximum sizes of each dimension of a grid; - ::sharedMemPerBlock is the total amount of shared memory available per block in bytes; - ::totalConstantMemory is the total amount of constant memory available on the device in bytes; - ::SIMDWidth is the warp size; - ::memPitch is the maximum pitch allowed by the memory copy functions that involve memory regions allocated through ::cuMemAllocPitch(); - ::regsPerBlock is the total number of registers available per block; - ::clockRate is the clock frequency in kilohertz; - ::textureAlign is the alignment requirement; texture base addresses that are aligned to ::textureAlign bytes do not need an offset applied to texture fetches.
\brief Returns properties for a selected device

Parameters:

prop - - Returned properties of device

dev - - Device to get properties for

Returns:

::CUDA_SUCCESS, ::CUDA_ERROR_DEINITIALIZED, ::CUDA_ERROR_NOT_INITIALIZED, ::CUDA_ERROR_INVALID_CONTEXT, ::CUDA_ERROR_INVALID_VALUE, ::CUDA_ERROR_INVALID_DEVICE \notefnerr

cuDeviceComputeCapability
```
@Cast("CUresult")
@Deprecated
public static int cuDeviceComputeCapability(IntPointer major,
                                            IntPointer minor,
                                            @Cast("CUdevice")
                                            int dev)
```
Deprecated.
This function was deprecated as of CUDA 5.0 and its functionality superceded by ::cuDeviceGetAttribute(). Returns in \p *major and \p *minor the major and minor revision numbers that define the compute capability of the device \p dev.

\brief Returns the compute capability of the device

Parameters:

major - - Major revision number

minor - - Minor revision number

dev - - Device handle

Returns:

::CUDA_SUCCESS, ::CUDA_ERROR_DEINITIALIZED, ::CUDA_ERROR_NOT_INITIALIZED, ::CUDA_ERROR_INVALID_CONTEXT, ::CUDA_ERROR_INVALID_VALUE, ::CUDA_ERROR_INVALID_DEVICE \notefnerr

cuDeviceComputeCapability

@Cast("CUresult")
@Deprecated
public static int cuDeviceComputeCapability(IntBuffer major,
                                            IntBuffer minor,
                                            @Cast("CUdevice")
                                            int dev)

Deprecated.

cuDeviceComputeCapability

@Cast("CUresult")
@Deprecated
public static int cuDeviceComputeCapability(int[] major,
                                            int[] minor,
                                            @Cast("CUdevice")
                                            int dev)

Deprecated.

cuDevicePrimaryCtxRetain
```
@Cast("CUresult")
public static int cuDevicePrimaryCtxRetain(@ByPtrPtr
                                           CUctx_st pctx,
                                           @Cast("CUdevice")
                                           int dev)
```
\brief Retain the primary context on the GPU Retains the primary context on the device, creating it if necessary, increasing its usage count. The caller must call ::cuDevicePrimaryCtxRelease() when done using the context. Unlike ::cuCtxCreate() the newly created context is not pushed onto the stack. Context creation will fail with ::CUDA_ERROR_UNKNOWN if the compute mode of the device is ::CU_COMPUTEMODE_PROHIBITED. The function ::cuDeviceGetAttribute() can be used with ::CU_DEVICE_ATTRIBUTE_COMPUTE_MODE to determine the compute mode of the device. The nvidia-smi tool can be used to set the compute mode for devices. Documentation for nvidia-smi can be obtained by passing a -h option to it. Please note that the primary context always supports pinned allocations. Other flags can be specified by ::cuDevicePrimaryCtxSetFlags().

Parameters:

pctx - - Returned context handle of the new context

dev - - Device for which primary context is requested

Returns:

::CUDA_SUCCESS, ::CUDA_ERROR_DEINITIALIZED, ::CUDA_ERROR_NOT_INITIALIZED, ::CUDA_ERROR_INVALID_CONTEXT, ::CUDA_ERROR_INVALID_DEVICE, ::CUDA_ERROR_INVALID_VALUE, ::CUDA_ERROR_OUT_OF_MEMORY, ::CUDA_ERROR_UNKNOWN \notefnerr

cuDevicePrimaryCtxRelease
```
@Cast("CUresult")
public static int cuDevicePrimaryCtxRelease(@Cast("CUdevice")
                                            int dev)
```
\brief Release the primary context on the GPU Releases the primary context interop on the device by decreasing the usage count by 1. If the usage drops to 0 the primary context of device \p dev will be destroyed regardless of how many threads it is current to. Please note that unlike ::cuCtxDestroy() this method does not pop the context from stack in any circumstances.

Parameters:

dev - - Device which primary context is released

Returns:

::CUDA_SUCCESS, ::CUDA_ERROR_DEINITIALIZED, ::CUDA_ERROR_NOT_INITIALIZED, ::CUDA_ERROR_INVALID_DEVICE \notefnerr

cuDevicePrimaryCtxSetFlags
```
@Cast("CUresult")
public static int cuDevicePrimaryCtxSetFlags(@Cast("CUdevice")
                                             int dev,
                                             @Cast("unsigned int")
                                             int flags)
```
\brief Set flags for the primary context Sets the flags for the primary context on the device overwriting perviously set ones. If the primary context is already created ::CUDA_ERROR_PRIMARY_CONTEXT_ACTIVE is returned. The three LSBs of the \p flags parameter can be used to control how the OS thread, which owns the CUDA context at the time of an API call, interacts with the OS scheduler when waiting for results from the GPU. Only one of the scheduling flags can be set when creating a context. - ::CU_CTX_SCHED_SPIN: Instruct CUDA to actively spin when waiting for results from the GPU. This can decrease latency when waiting for the GPU, but may lower the performance of CPU threads if they are performing work in parallel with the CUDA thread. - ::CU_CTX_SCHED_YIELD: Instruct CUDA to yield its thread when waiting for results from the GPU. This can increase latency when waiting for the GPU, but can increase the performance of CPU threads performing work in parallel with the GPU. - ::CU_CTX_SCHED_BLOCKING_SYNC: Instruct CUDA to block the CPU thread on a synchronization primitive when waiting for the GPU to finish work. - ::CU_CTX_BLOCKING_SYNC: Instruct CUDA to block the CPU thread on a synchronization primitive when waiting for the GPU to finish work.
Deprecated: This flag was deprecated as of CUDA 4.0 and was replaced with ::CU_CTX_SCHED_BLOCKING_SYNC. - ::CU_CTX_SCHED_AUTO: The default value if the \p flags parameter is zero, uses a heuristic based on the number of active CUDA contexts in the process \e C and the number of logical processors in the system \e P. If \e C > \e P, then CUDA will yield to other OS threads when waiting for the GPU (::CU_CTX_SCHED_YIELD), otherwise CUDA will not yield while waiting for results and actively spin on the processor (::CU_CTX_SCHED_SPIN). Additionally, on Tegra devices, ::CU_CTX_SCHED_AUTO uses a heuristic based on the power profile of the platform and may choose ::CU_CTX_SCHED_BLOCKING_SYNC for low-powered devices. - ::CU_CTX_LMEM_RESIZE_TO_MAX: Instruct CUDA to not reduce local memory after resizing local memory for a kernel. This can prevent thrashing by local memory allocations when launching many kernels with high local memory usage at the cost of potentially increased memory usage.

Parameters:

dev - - Device for which the primary context flags are set

flags - - New flags for the device

Returns:

::CUDA_SUCCESS, ::CUDA_ERROR_DEINITIALIZED, ::CUDA_ERROR_NOT_INITIALIZED, ::CUDA_ERROR_INVALID_DEVICE, ::CUDA_ERROR_INVALID_VALUE, ::CUDA_ERROR_PRIMARY_CONTEXT_ACTIVE \notefnerr

cuDevicePrimaryCtxGetState
```
@Cast("CUresult")
public static int cuDevicePrimaryCtxGetState(@Cast("CUdevice")
                                             int dev,
                                             @Cast("unsigned int*")
                                             IntPointer flags,
                                             IntPointer active)
```
\brief Get the state of the primary context Returns in \p *flags the flags for the primary context of \p dev, and in \p *active whether it is active. See ::cuDevicePrimaryCtxSetFlags for flag values.

Parameters:

dev - - Device to get primary context flags for

flags - - Pointer to store flags

active - - Pointer to store context state; 0 = inactive, 1 = active

Returns:

::CUDA_SUCCESS, ::CUDA_ERROR_DEINITIALIZED, ::CUDA_ERROR_NOT_INITIALIZED, ::CUDA_ERROR_INVALID_DEVICE, ::CUDA_ERROR_INVALID_VALUE, \notefnerr

cuDevicePrimaryCtxGetState

@Cast("CUresult")
public static int cuDevicePrimaryCtxGetState(@Cast("CUdevice")
                                             int dev,
                                             @Cast("unsigned int*")
                                             IntBuffer flags,
                                             IntBuffer active)

cuDevicePrimaryCtxGetState

@Cast("CUresult")
public static int cuDevicePrimaryCtxGetState(@Cast("CUdevice")
                                             int dev,
                                             @Cast("unsigned int*")
                                             int[] flags,
                                             int[] active)

cuDevicePrimaryCtxReset
```
@Cast("CUresult")
public static int cuDevicePrimaryCtxReset(@Cast("CUdevice")
                                          int dev)
```
\brief Destroy all allocations and reset all state on the primary context Explicitly destroys and cleans up all resources associated with the current device in the current process. Note that it is responsibility of the calling function to ensure that no other module in the process is using the device any more. For that reason it is recommended to use ::cuDevicePrimaryCtxRelease() in most cases. However it is safe for other modules to call ::cuDevicePrimaryCtxRelease() even after resetting the device.

Parameters:

dev - - Device for which primary context is destroyed

Returns:

::CUDA_SUCCESS, ::CUDA_ERROR_DEINITIALIZED, ::CUDA_ERROR_NOT_INITIALIZED, ::CUDA_ERROR_INVALID_DEVICE, ::CUDA_ERROR_PRIMARY_CONTEXT_ACTIVE \notefnerr

cuCtxCreate
```
@Cast("CUresult")
public static int cuCtxCreate(@ByPtrPtr
                              CUctx_st pctx,
                              @Cast("unsigned int")
                              int flags,
                              @Cast("CUdevice")
                              int dev)
```
\brief Create a CUDA context \note In most cases it is recommended to use ::cuDevicePrimaryCtxRetain. Creates a new CUDA context and associates it with the calling thread. The \p flags parameter is described below. The context is created with a usage count of 1 and the caller of ::cuCtxCreate() must call ::cuCtxDestroy() when done using the context. If a context is already current to the thread, it is supplanted by the newly created context and may be restored by a subsequent call to ::cuCtxPopCurrent(). The three LSBs of the \p flags parameter can be used to control how the OS thread, which owns the CUDA context at the time of an API call, interacts with the OS scheduler when waiting for results from the GPU. Only one of the scheduling flags can be set when creating a context. - ::CU_CTX_SCHED_SPIN: Instruct CUDA to actively spin when waiting for results from the GPU. This can decrease latency when waiting for the GPU, but may lower the performance of CPU threads if they are performing work in parallel with the CUDA thread. - ::CU_CTX_SCHED_YIELD: Instruct CUDA to yield its thread when waiting for results from the GPU. This can increase latency when waiting for the GPU, but can increase the performance of CPU threads performing work in parallel with the GPU. - ::CU_CTX_SCHED_BLOCKING_SYNC: Instruct CUDA to block the CPU thread on a synchronization primitive when waiting for the GPU to finish work. - ::CU_CTX_BLOCKING_SYNC: Instruct CUDA to block the CPU thread on a synchronization primitive when waiting for the GPU to finish work.
Deprecated: This flag was deprecated as of CUDA 4.0 and was replaced with ::CU_CTX_SCHED_BLOCKING_SYNC. - ::CU_CTX_SCHED_AUTO: The default value if the \p flags parameter is zero, uses a heuristic based on the number of active CUDA contexts in the process \e C and the number of logical processors in the system \e P. If \e C > \e P, then CUDA will yield to other OS threads when waiting for the GPU (::CU_CTX_SCHED_YIELD), otherwise CUDA will not yield while waiting for results and actively spin on the processor (::CU_CTX_SCHED_SPIN). Additionally, on Tegra devices, ::CU_CTX_SCHED_AUTO uses a heuristic based on the power profile of the platform and may choose ::CU_CTX_SCHED_BLOCKING_SYNC for low-powered devices. - ::CU_CTX_MAP_HOST: Instruct CUDA to support mapped pinned allocations. This flag must be set in order to allocate pinned host memory that is accessible to the GPU. - ::CU_CTX_LMEM_RESIZE_TO_MAX: Instruct CUDA to not reduce local memory after resizing local memory for a kernel. This can prevent thrashing by local memory allocations when launching many kernels with high local memory usage at the cost of potentially increased memory usage. Context creation will fail with ::CUDA_ERROR_UNKNOWN if the compute mode of the device is ::CU_COMPUTEMODE_PROHIBITED. The function ::cuDeviceGetAttribute() can be used with ::CU_DEVICE_ATTRIBUTE_COMPUTE_MODE to determine the compute mode of the device. The nvidia-smi tool can be used to set the compute mode for * devices. Documentation for nvidia-smi can be obtained by passing a -h option to it.

Parameters:

pctx - - Returned context handle of the new context

flags - - Context creation flags

dev - - Device to create context on

Returns:

::CUDA_SUCCESS, ::CUDA_ERROR_DEINITIALIZED, ::CUDA_ERROR_NOT_INITIALIZED, ::CUDA_ERROR_INVALID_CONTEXT, ::CUDA_ERROR_INVALID_DEVICE, ::CUDA_ERROR_INVALID_VALUE, ::CUDA_ERROR_OUT_OF_MEMORY, ::CUDA_ERROR_UNKNOWN \notefnerr

cuCtxDestroy
```
@Cast("CUresult")
public static int cuCtxDestroy(CUctx_st ctx)
```
\brief Destroy a CUDA context Destroys the CUDA context specified by \p ctx. The context \p ctx will be destroyed regardless of how many threads it is current to. It is the responsibility of the calling function to ensure that no API call issues using \p ctx while ::cuCtxDestroy() is executing. If \p ctx is current to the calling thread then \p ctx will also be popped from the current thread's context stack (as though ::cuCtxPopCurrent() were called). If \p ctx is current to other threads, then \p ctx will remain current to those threads, and attempting to access \p ctx from those threads will result in the error ::CUDA_ERROR_CONTEXT_IS_DESTROYED.

Parameters:

ctx - - Context to destroy

Returns:

::CUDA_SUCCESS, ::CUDA_ERROR_DEINITIALIZED, ::CUDA_ERROR_NOT_INITIALIZED, ::CUDA_ERROR_INVALID_CONTEXT, ::CUDA_ERROR_INVALID_VALUE \notefnerr

cuCtxPushCurrent
```
@Cast("CUresult")
public static int cuCtxPushCurrent(CUctx_st ctx)
```
\brief Pushes a context on the current CPU thread Pushes the given context \p ctx onto the CPU thread's stack of current contexts. The specified context becomes the CPU thread's current context, so all CUDA functions that operate on the current context are affected. The previous current context may be made current again by calling ::cuCtxDestroy() or ::cuCtxPopCurrent().

Parameters:

ctx - - Context to push

Returns:

::CUDA_SUCCESS, ::CUDA_ERROR_DEINITIALIZED, ::CUDA_ERROR_NOT_INITIALIZED, ::CUDA_ERROR_INVALID_CONTEXT, ::CUDA_ERROR_INVALID_VALUE \notefnerr

cuCtxPopCurrent
```
@Cast("CUresult")
public static int cuCtxPopCurrent(@ByPtrPtr
                                  CUctx_st pctx)
```
\brief Pops the current CUDA context from the current CPU thread. Pops the current CUDA context from the CPU thread and passes back the old context handle in \p *pctx. That context may then be made current to a different CPU thread by calling ::cuCtxPushCurrent(). If a context was current to the CPU thread before ::cuCtxCreate() or ::cuCtxPushCurrent() was called, this function makes that context current to the CPU thread again.

Parameters:

pctx - - Returned new context handle

Returns:

::CUDA_SUCCESS, ::CUDA_ERROR_DEINITIALIZED, ::CUDA_ERROR_NOT_INITIALIZED, ::CUDA_ERROR_INVALID_CONTEXT \notefnerr

cuCtxSetCurrent
```
@Cast("CUresult")
public static int cuCtxSetCurrent(CUctx_st ctx)
```
\brief Binds the specified CUDA context to the calling CPU thread Binds the specified CUDA context to the calling CPU thread. If \p ctx is NULL then the CUDA context previously bound to the calling CPU thread is unbound and ::CUDA_SUCCESS is returned. If there exists a CUDA context stack on the calling CPU thread, this will replace the top of that stack with \p ctx. If \p ctx is NULL then this will be equivalent to popping the top of the calling CPU thread's CUDA context stack (or a no-op if the calling CPU thread's CUDA context stack is empty).

Parameters:

ctx - - Context to bind to the calling CPU thread

Returns:

::CUDA_SUCCESS, ::CUDA_ERROR_DEINITIALIZED, ::CUDA_ERROR_NOT_INITIALIZED, ::CUDA_ERROR_INVALID_CONTEXT \notefnerr

cuCtxGetCurrent
```
@Cast("CUresult")
public static int cuCtxGetCurrent(@ByPtrPtr
                                  CUctx_st pctx)
```
\brief Returns the CUDA context bound to the calling CPU thread. Returns in \p *pctx the CUDA context bound to the calling CPU thread. If no context is bound to the calling CPU thread then \p *pctx is set to NULL and ::CUDA_SUCCESS is returned.

Parameters:

pctx - - Returned context handle

Returns:

::CUDA_SUCCESS, ::CUDA_ERROR_DEINITIALIZED, ::CUDA_ERROR_NOT_INITIALIZED, \notefnerr

cuCtxGetDevice
```
@Cast("CUresult")
public static int cuCtxGetDevice(@Cast("CUdevice*")
                                 IntPointer device)
```
\brief Returns the device ID for the current context Returns in \p *device the ordinal of the current context's device.

Parameters:

device - - Returned device ID for the current context

Returns:

::CUDA_SUCCESS, ::CUDA_ERROR_DEINITIALIZED, ::CUDA_ERROR_NOT_INITIALIZED, ::CUDA_ERROR_INVALID_CONTEXT, ::CUDA_ERROR_INVALID_VALUE, \notefnerr

cuCtxGetDevice

@Cast("CUresult")
public static int cuCtxGetDevice(@Cast("CUdevice*")
                                 IntBuffer device)

cuCtxGetDevice

@Cast("CUresult")
public static int cuCtxGetDevice(@Cast("CUdevice*")
                                 int[] device)

cuCtxGetFlags
```
@Cast("CUresult")
public static int cuCtxGetFlags(@Cast("unsigned int*")
                                IntPointer flags)
```
\brief Returns the flags for the current context Returns in \p *flags the flags of the current context. See ::cuCtxCreate for flag values.

Parameters:

flags - - Pointer to store flags of current context

Returns:

::CUDA_SUCCESS, ::CUDA_ERROR_DEINITIALIZED, ::CUDA_ERROR_NOT_INITIALIZED, ::CUDA_ERROR_INVALID_CONTEXT, ::CUDA_ERROR_INVALID_VALUE, \notefnerr

cuCtxGetFlags

@Cast("CUresult")
public static int cuCtxGetFlags(@Cast("unsigned int*")
                                IntBuffer flags)

cuCtxGetFlags

@Cast("CUresult")
public static int cuCtxGetFlags(@Cast("unsigned int*")
                                int[] flags)

cuCtxSynchronize
```
@Cast("CUresult")
public static int cuCtxSynchronize()
```
\brief Block for a context's tasks to complete Blocks until the device has completed all preceding requested tasks. ::cuCtxSynchronize() returns an error if one of the preceding tasks failed. If the context was created with the ::CU_CTX_SCHED_BLOCKING_SYNC flag, the CPU thread will block until the GPU context has finished its work.

Returns:

::CUDA_SUCCESS, ::CUDA_ERROR_DEINITIALIZED, ::CUDA_ERROR_NOT_INITIALIZED, ::CUDA_ERROR_INVALID_CONTEXT \notefnerr

cuCtxSetLimit
```
@Cast("CUresult")
public static int cuCtxSetLimit(@Cast("CUlimit")
                                int _limit,
                                @Cast("size_t")
                                long value)
```
\brief Set resource limits Setting \p limit to \p value is a request by the application to update the current limit maintained by the context. The driver is free to modify the requested value to meet h/w requirements (this could be clamping to minimum or maximum values, rounding up to nearest element size, etc). The application can use ::cuCtxGetLimit() to find out exactly what the limit has been set to. Setting each ::CUlimit has its own specific restrictions, so each is discussed here. - ::CU_LIMIT_STACK_SIZE controls the stack size in bytes of each GPU thread. Note that the CUDA driver will set the \p limit to the maximum of \p value and what the kernel function requires. - ::CU_LIMIT_PRINTF_FIFO_SIZE controls the size in bytes of the FIFO used by the ::printf() device system call. Setting ::CU_LIMIT_PRINTF_FIFO_SIZE must be performed before launching any kernel that uses the ::printf() device system call, otherwise ::CUDA_ERROR_INVALID_VALUE will be returned. - ::CU_LIMIT_MALLOC_HEAP_SIZE controls the size in bytes of the heap used by the ::malloc() and ::free() device system calls. Setting ::CU_LIMIT_MALLOC_HEAP_SIZE must be performed before launching any kernel that uses the ::malloc() or ::free() device system calls, otherwise ::CUDA_ERROR_INVALID_VALUE will be returned. - ::CU_LIMIT_DEV_RUNTIME_SYNC_DEPTH controls the maximum nesting depth of a grid at which a thread can safely call ::cudaDeviceSynchronize(). Setting this limit must be performed before any launch of a kernel that uses the device runtime and calls ::cudaDeviceSynchronize() above the default sync depth, two levels of grids. Calls to ::cudaDeviceSynchronize() will fail with error code ::cudaErrorSyncDepthExceeded if the limitation is violated. This limit can be set smaller than the default or up the maximum launch depth of 24. When setting this limit, keep in mind that additional levels of sync depth require the driver to reserve large amounts of device memory which can no longer be used for user allocations. If these reservations of device memory fail, ::cuCtxSetLimit will return ::CUDA_ERROR_OUT_OF_MEMORY, and the limit can be reset to a lower value. This limit is only applicable to devices of compute capability 3.5 and higher. Attempting to set this limit on devices of compute capability less than 3.5 will result in the error ::CUDA_ERROR_UNSUPPORTED_LIMIT being returned. - ::CU_LIMIT_DEV_RUNTIME_PENDING_LAUNCH_COUNT controls the maximum number of outstanding device runtime launches that can be made from the current context. A grid is outstanding from the point of launch up until the grid is known to have been completed. Device runtime launches which violate this limitation fail and return ::cudaErrorLaunchPendingCountExceeded when ::cudaGetLastError() is called after launch. If more pending launches than the default (2048 launches) are needed for a module using the device runtime, this limit can be increased. Keep in mind that being able to sustain additional pending launches will require the driver to reserve larger amounts of device memory upfront which can no longer be used for allocations. If these reservations fail, ::cuCtxSetLimit will return ::CUDA_ERROR_OUT_OF_MEMORY, and the limit can be reset to a lower value. This limit is only applicable to devices of compute capability 3.5 and higher. Attempting to set this limit on devices of compute capability less than 3.5 will result in the error ::CUDA_ERROR_UNSUPPORTED_LIMIT being returned. - ::CU_LIMIT_MAX_L2_FETCH_GRANULARITY controls the L2 cache fetch granularity. Values can range from 0B to 128B. This is purely a performance hint and it can be ignored or clamped depending on the platform.

Parameters:

limit - - Limit to set

value - - Size of limit

Returns:

::CUDA_SUCCESS, ::CUDA_ERROR_INVALID_VALUE, ::CUDA_ERROR_UNSUPPORTED_LIMIT, ::CUDA_ERROR_OUT_OF_MEMORY, ::CUDA_ERROR_INVALID_CONTEXT \notefnerr

cuCtxGetLimit
```
@Cast("CUresult")
public static int cuCtxGetLimit(@Cast("size_t*")
                                SizeTPointer pvalue,
                                @Cast("CUlimit")
                                int _limit)
```
\brief Returns resource limits Returns in \p *pvalue the current size of \p limit. The supported ::CUlimit values are: - ::CU_LIMIT_STACK_SIZE: stack size in bytes of each GPU thread. - ::CU_LIMIT_PRINTF_FIFO_SIZE: size in bytes of the FIFO used by the ::printf() device system call. - ::CU_LIMIT_MALLOC_HEAP_SIZE: size in bytes of the heap used by the ::malloc() and ::free() device system calls. - ::CU_LIMIT_DEV_RUNTIME_SYNC_DEPTH: maximum grid depth at which a thread can issue the device runtime call ::cudaDeviceSynchronize() to wait on child grid launches to complete. - ::CU_LIMIT_DEV_RUNTIME_PENDING_LAUNCH_COUNT: maximum number of outstanding device runtime launches that can be made from this context. - ::CU_LIMIT_MAX_L2_FETCH_GRANULARITY: L2 cache fetch granularity.

Parameters:

limit - - Limit to query

pvalue - - Returned size of limit

Returns:

::CUDA_SUCCESS, ::CUDA_ERROR_INVALID_VALUE, ::CUDA_ERROR_UNSUPPORTED_LIMIT \notefnerr

cuCtxGetCacheConfig
```
@Cast("CUresult")
public static int cuCtxGetCacheConfig(@Cast("CUfunc_cache*")
                                      IntPointer pconfig)
```
\brief Returns the preferred cache configuration for the current context. On devices where the L1 cache and shared memory use the same hardware resources, this function returns through \p pconfig the preferred cache configuration for the current context. This is only a preference. The driver will use the requested configuration if possible, but it is free to choose a different configuration if required to execute functions. This will return a \p pconfig of ::CU_FUNC_CACHE_PREFER_NONE on devices where the size of the L1 cache and shared memory are fixed. The supported cache configurations are: - ::CU_FUNC_CACHE_PREFER_NONE: no preference for shared memory or L1 (default) - ::CU_FUNC_CACHE_PREFER_SHARED: prefer larger shared memory and smaller L1 cache - ::CU_FUNC_CACHE_PREFER_L1: prefer larger L1 cache and smaller shared memory - ::CU_FUNC_CACHE_PREFER_EQUAL: prefer equal sized L1 cache and shared memory

Parameters:

pconfig - - Returned cache configuration

Returns:

::CUDA_SUCCESS, ::CUDA_ERROR_DEINITIALIZED, ::CUDA_ERROR_NOT_INITIALIZED, ::CUDA_ERROR_INVALID_CONTEXT, ::CUDA_ERROR_INVALID_VALUE \notefnerr

cuCtxGetCacheConfig

@Cast("CUresult")
public static int cuCtxGetCacheConfig(@Cast("CUfunc_cache*")
                                      IntBuffer pconfig)

cuCtxGetCacheConfig

@Cast("CUresult")
public static int cuCtxGetCacheConfig(@Cast("CUfunc_cache*")
                                      int[] pconfig)

cuCtxSetCacheConfig
```
@Cast("CUresult")
public static int cuCtxSetCacheConfig(@Cast("CUfunc_cache")
                                      int config)
```
\brief Sets the preferred cache configuration for the current context. On devices where the L1 cache and shared memory use the same hardware resources, this sets through \p config the preferred cache configuration for the current context. This is only a preference. The driver will use the requested configuration if possible, but it is free to choose a different configuration if required to execute the function. Any function preference set via ::cuFuncSetCacheConfig() will be preferred over this context-wide setting. Setting the context-wide cache configuration to ::CU_FUNC_CACHE_PREFER_NONE will cause subsequent kernel launches to prefer to not change the cache configuration unless required to launch the kernel. This setting does nothing on devices where the size of the L1 cache and shared memory are fixed. Launching a kernel with a different preference than the most recent preference setting may insert a device-side synchronization point. The supported cache configurations are: - ::CU_FUNC_CACHE_PREFER_NONE: no preference for shared memory or L1 (default) - ::CU_FUNC_CACHE_PREFER_SHARED: prefer larger shared memory and smaller L1 cache - ::CU_FUNC_CACHE_PREFER_L1: prefer larger L1 cache and smaller shared memory - ::CU_FUNC_CACHE_PREFER_EQUAL: prefer equal sized L1 cache and shared memory

Parameters:

config - - Requested cache configuration

Returns:

::CUDA_SUCCESS, ::CUDA_ERROR_DEINITIALIZED, ::CUDA_ERROR_NOT_INITIALIZED, ::CUDA_ERROR_INVALID_CONTEXT, ::CUDA_ERROR_INVALID_VALUE \notefnerr

cuCtxGetSharedMemConfig
```
@Cast("CUresult")
public static int cuCtxGetSharedMemConfig(@Cast("CUsharedconfig*")
                                          IntPointer pConfig)
```
\brief Returns the current shared memory configuration for the current context. This function will return in \p pConfig the current size of shared memory banks in the current context. On devices with configurable shared memory banks, ::cuCtxSetSharedMemConfig can be used to change this setting, so that all subsequent kernel launches will by default use the new bank size. When ::cuCtxGetSharedMemConfig is called on devices without configurable shared memory, it will return the fixed bank size of the hardware. The returned bank configurations can be either: - ::CU_SHARED_MEM_CONFIG_FOUR_BYTE_BANK_SIZE: shared memory bank width is four bytes. - ::CU_SHARED_MEM_CONFIG_EIGHT_BYTE_BANK_SIZE: shared memory bank width will eight bytes.

Parameters:

pConfig - - returned shared memory configuration

Returns:

::CUDA_SUCCESS, ::CUDA_ERROR_DEINITIALIZED, ::CUDA_ERROR_NOT_INITIALIZED, ::CUDA_ERROR_INVALID_CONTEXT, ::CUDA_ERROR_INVALID_VALUE \notefnerr

cuCtxGetSharedMemConfig

@Cast("CUresult")
public static int cuCtxGetSharedMemConfig(@Cast("CUsharedconfig*")
                                          IntBuffer pConfig)

cuCtxGetSharedMemConfig

@Cast("CUresult")
public static int cuCtxGetSharedMemConfig(@Cast("CUsharedconfig*")
                                          int[] pConfig)

cuCtxSetSharedMemConfig
```
@Cast("CUresult")
public static int cuCtxSetSharedMemConfig(@Cast("CUsharedconfig")
                                          int config)
```
\brief Sets the shared memory configuration for the current context. On devices with configurable shared memory banks, this function will set the context's shared memory bank size which is used for subsequent kernel launches. Changed the shared memory configuration between launches may insert a device side synchronization point between those launches. Changing the shared memory bank size will not increase shared memory usage or affect occupancy of kernels, but may have major effects on performance. Larger bank sizes will allow for greater potential bandwidth to shared memory, but will change what kinds of accesses to shared memory will result in bank conflicts. This function will do nothing on devices with fixed shared memory bank size. The supported bank configurations are: - ::CU_SHARED_MEM_CONFIG_DEFAULT_BANK_SIZE: set bank width to the default initial setting (currently, four bytes). - ::CU_SHARED_MEM_CONFIG_FOUR_BYTE_BANK_SIZE: set shared memory bank width to be natively four bytes. - ::CU_SHARED_MEM_CONFIG_EIGHT_BYTE_BANK_SIZE: set shared memory bank width to be natively eight bytes.

Parameters:

config - - requested shared memory configuration

Returns:

::CUDA_SUCCESS, ::CUDA_ERROR_DEINITIALIZED, ::CUDA_ERROR_NOT_INITIALIZED, ::CUDA_ERROR_INVALID_CONTEXT, ::CUDA_ERROR_INVALID_VALUE \notefnerr

cuCtxGetApiVersion
```
@Cast("CUresult")
public static int cuCtxGetApiVersion(CUctx_st ctx,
                                     @Cast("unsigned int*")
                                     IntPointer version)
```
\brief Gets the context's API version. Returns a version number in \p version corresponding to the capabilities of the context (e.g. 3010 or 3020), which library developers can use to direct callers to a specific API version. If \p ctx is NULL, returns the API version used to create the currently bound context. Note that new API versions are only introduced when context capabilities are changed that break binary compatibility, so the API version and driver version may be different. For example, it is valid for the API version to be 3020 while the driver version is 4020.

Parameters:

ctx - - Context to check

version - - Pointer to version

Returns:

::CUDA_SUCCESS, ::CUDA_ERROR_DEINITIALIZED, ::CUDA_ERROR_NOT_INITIALIZED, ::CUDA_ERROR_INVALID_CONTEXT, ::CUDA_ERROR_INVALID_VALUE, ::CUDA_ERROR_UNKNOWN \notefnerr

cuCtxGetApiVersion

@Cast("CUresult")
public static int cuCtxGetApiVersion(CUctx_st ctx,
                                     @Cast("unsigned int*")
                                     IntBuffer version)

cuCtxGetApiVersion

@Cast("CUresult")
public static int cuCtxGetApiVersion(CUctx_st ctx,
                                     @Cast("unsigned int*")
                                     int[] version)

cuCtxGetStreamPriorityRange
```
@Cast("CUresult")
public static int cuCtxGetStreamPriorityRange(IntPointer leastPriority,
                                              IntPointer greatestPriority)
```
\brief Returns numerical values that correspond to the least and greatest stream priorities. Returns in \p *leastPriority and \p *greatestPriority the numerical values that correspond to the least and greatest stream priorities respectively. Stream priorities follow a convention where lower numbers imply greater priorities. The range of meaningful stream priorities is given by [\p *greatestPriority, \p *leastPriority]. If the user attempts to create a stream with a priority value that is outside the meaningful range as specified by this API, the priority is automatically clamped down or up to either \p *leastPriority or \p *greatestPriority respectively. See ::cuStreamCreateWithPriority for details on creating a priority stream. A NULL may be passed in for \p *leastPriority or \p *greatestPriority if the value is not desired. This function will return '0' in both \p *leastPriority and \p *greatestPriority if the current context's device does not support stream priorities (see ::cuDeviceGetAttribute).

Parameters:

leastPriority - - Pointer to an int in which the numerical value for least stream priority is returned

greatestPriority - - Pointer to an int in which the numerical value for greatest stream priority is returned

Returns:

::CUDA_SUCCESS, ::CUDA_ERROR_INVALID_VALUE, \notefnerr

cuCtxGetStreamPriorityRange

@Cast("CUresult")
public static int cuCtxGetStreamPriorityRange(IntBuffer leastPriority,
                                              IntBuffer greatestPriority)

cuCtxGetStreamPriorityRange

@Cast("CUresult")
public static int cuCtxGetStreamPriorityRange(int[] leastPriority,
                                              int[] greatestPriority)

cuCtxAttach
```
@Cast("CUresult")
@Deprecated
public static int cuCtxAttach(@ByPtrPtr
                              CUctx_st pctx,
                              @Cast("unsigned int")
                              int flags)
```
Deprecated.
Note that this function is deprecated and should not be used. Increments the usage count of the context and passes back a context handle in \p *pctx that must be passed to ::cuCtxDetach() when the application is done with the context. ::cuCtxAttach() fails if there is no context current to the thread. Currently, the \p flags parameter must be 0.

\brief Increment a context's usage-count

Parameters:

pctx - - Returned context handle of the current context

flags - - Context attach flags (must be 0)

Returns:

::CUDA_SUCCESS, ::CUDA_ERROR_DEINITIALIZED, ::CUDA_ERROR_NOT_INITIALIZED, ::CUDA_ERROR_INVALID_CONTEXT, ::CUDA_ERROR_INVALID_VALUE \notefnerr

cuCtxDetach
```
@Cast("CUresult")
@Deprecated
public static int cuCtxDetach(CUctx_st ctx)
```
Deprecated.
Note that this function is deprecated and should not be used. Decrements the usage count of the context \p ctx, and destroys the context if the usage count goes to 0. The context must be a handle that was passed back by ::cuCtxCreate() or ::cuCtxAttach(), and must be current to the calling thread.

\brief Decrement a context's usage-count

Parameters:

ctx - - Context to destroy

Returns:

::CUDA_SUCCESS, ::CUDA_ERROR_DEINITIALIZED, ::CUDA_ERROR_NOT_INITIALIZED, ::CUDA_ERROR_INVALID_CONTEXT \notefnerr

cuModuleLoad
```
@Cast("CUresult")
public static int cuModuleLoad(@ByPtrPtr
                               CUmod_st module,
                               @Cast("const char*")
                               BytePointer fname)
```
\brief Loads a compute module Takes a filename \p fname and loads the corresponding module \p module into the current context. The CUDA driver API does not attempt to lazily allocate the resources needed by a module; if the memory for functions and data (constant and global) needed by the module cannot be allocated, ::cuModuleLoad() fails. The file should be a \e cubin file as output by \b nvcc, or a \e PTX file either as output by \b nvcc or handwritten, or a \e fatbin file as output by \b nvcc from toolchain 4.0 or later.

Parameters:

module - - Returned module

fname - - Filename of module to load

Returns:

::CUDA_SUCCESS, ::CUDA_ERROR_DEINITIALIZED, ::CUDA_ERROR_NOT_INITIALIZED, ::CUDA_ERROR_INVALID_CONTEXT, ::CUDA_ERROR_INVALID_VALUE, ::CUDA_ERROR_INVALID_PTX, ::CUDA_ERROR_NOT_FOUND, ::CUDA_ERROR_OUT_OF_MEMORY, ::CUDA_ERROR_FILE_NOT_FOUND, ::CUDA_ERROR_NO_BINARY_FOR_GPU, ::CUDA_ERROR_SHARED_OBJECT_SYMBOL_NOT_FOUND, ::CUDA_ERROR_SHARED_OBJECT_INIT_FAILED, ::CUDA_ERROR_JIT_COMPILER_NOT_FOUND \notefnerr

cuModuleLoad

@Cast("CUresult")
public static int cuModuleLoad(@ByPtrPtr
                               CUmod_st module,
                               String fname)

cuModuleLoadData
```
@Cast("CUresult")
public static int cuModuleLoadData(@ByPtrPtr
                                   CUmod_st module,
                                   @Const
                                   Pointer image)
```
\brief Load a module's data Takes a pointer \p image and loads the corresponding module \p module into the current context. The pointer may be obtained by mapping a \e cubin or \e PTX or \e fatbin file, passing a \e cubin or \e PTX or \e fatbin file as a NULL-terminated text string, or incorporating a \e cubin or \e fatbin object into the executable resources and using operating system calls such as Windows \c FindResource() to obtain the pointer.

Parameters:

module - - Returned module

image - - Module data to load

Returns:

::CUDA_SUCCESS, ::CUDA_ERROR_DEINITIALIZED, ::CUDA_ERROR_NOT_INITIALIZED, ::CUDA_ERROR_INVALID_CONTEXT, ::CUDA_ERROR_INVALID_VALUE, ::CUDA_ERROR_INVALID_PTX, ::CUDA_ERROR_OUT_OF_MEMORY, ::CUDA_ERROR_NO_BINARY_FOR_GPU, ::CUDA_ERROR_SHARED_OBJECT_SYMBOL_NOT_FOUND, ::CUDA_ERROR_SHARED_OBJECT_INIT_FAILED, ::CUDA_ERROR_JIT_COMPILER_NOT_FOUND \notefnerr

cuModuleLoadDataEx
```
@Cast("CUresult")
public static int cuModuleLoadDataEx(@ByPtrPtr
                                     CUmod_st module,
                                     @Const
                                     Pointer image,
                                     @Cast("unsigned int")
                                     int numOptions,
                                     @Cast("CUjit_option*")
                                     IntPointer options,
                                     @Cast("void**")
                                     PointerPointer optionValues)
```
\brief Load a module's data with options Takes a pointer \p image and loads the corresponding module \p module into the current context. The pointer may be obtained by mapping a \e cubin or \e PTX or \e fatbin file, passing a \e cubin or \e PTX or \e fatbin file as a NULL-terminated text string, or incorporating a \e cubin or \e fatbin object into the executable resources and using operating system calls such as Windows \c FindResource() to obtain the pointer. Options are passed as an array via \p options and any corresponding parameters are passed in \p optionValues. The number of total options is supplied via \p numOptions. Any outputs will be returned via \p optionValues.

Parameters:

module - - Returned module

image - - Module data to load

numOptions - - Number of options

options - - Options for JIT

optionValues - - Option values for JIT

Returns:

::CUDA_SUCCESS, ::CUDA_ERROR_DEINITIALIZED, ::CUDA_ERROR_NOT_INITIALIZED, ::CUDA_ERROR_INVALID_CONTEXT, ::CUDA_ERROR_INVALID_VALUE, ::CUDA_ERROR_INVALID_PTX, ::CUDA_ERROR_OUT_OF_MEMORY, ::CUDA_ERROR_NO_BINARY_FOR_GPU, ::CUDA_ERROR_SHARED_OBJECT_SYMBOL_NOT_FOUND, ::CUDA_ERROR_SHARED_OBJECT_INIT_FAILED, ::CUDA_ERROR_JIT_COMPILER_NOT_FOUND \notefnerr

cuModuleLoadDataEx

@Cast("CUresult")
public static int cuModuleLoadDataEx(@ByPtrPtr
                                     CUmod_st module,
                                     @Const
                                     Pointer image,
                                     @Cast("unsigned int")
                                     int numOptions,
                                     @Cast("CUjit_option*")
                                     IntPointer options,
                                     @Cast("void**") @ByPtrPtr
                                     Pointer optionValues)

cuModuleLoadDataEx

@Cast("CUresult")
public static int cuModuleLoadDataEx(@ByPtrPtr
                                     CUmod_st module,
                                     @Const
                                     Pointer image,
                                     @Cast("unsigned int")
                                     int numOptions,
                                     @Cast("CUjit_option*")
                                     IntBuffer options,
                                     @Cast("void**") @ByPtrPtr
                                     Pointer optionValues)

cuModuleLoadDataEx

@Cast("CUresult")
public static int cuModuleLoadDataEx(@ByPtrPtr
                                     CUmod_st module,
                                     @Const
                                     Pointer image,
                                     @Cast("unsigned int")
                                     int numOptions,
                                     @Cast("CUjit_option*")
                                     int[] options,
                                     @Cast("void**") @ByPtrPtr
                                     Pointer optionValues)

cuModuleLoadFatBinary
```
@Cast("CUresult")
public static int cuModuleLoadFatBinary(@ByPtrPtr
                                        CUmod_st module,
                                        @Const
                                        Pointer fatCubin)
```
\brief Load a module's data Takes a pointer \p fatCubin and loads the corresponding module \p module into the current context. The pointer represents a fat binary object, which is a collection of different \e cubin and/or \e PTX files, all representing the same device code, but compiled and optimized for different architectures. Prior to CUDA 4.0, there was no documented API for constructing and using fat binary objects by programmers. Starting with CUDA 4.0, fat binary objects can be constructed by providing the -fatbin option to \b nvcc. More information can be found in the \b nvcc document.

Parameters:

module - - Returned module

fatCubin - - Fat binary to load

Returns:

::CUDA_SUCCESS, ::CUDA_ERROR_DEINITIALIZED, ::CUDA_ERROR_NOT_INITIALIZED, ::CUDA_ERROR_INVALID_CONTEXT, ::CUDA_ERROR_INVALID_VALUE, ::CUDA_ERROR_INVALID_PTX, ::CUDA_ERROR_NOT_FOUND, ::CUDA_ERROR_OUT_OF_MEMORY, ::CUDA_ERROR_NO_BINARY_FOR_GPU, ::CUDA_ERROR_SHARED_OBJECT_SYMBOL_NOT_FOUND, ::CUDA_ERROR_SHARED_OBJECT_INIT_FAILED, ::CUDA_ERROR_JIT_COMPILER_NOT_FOUND \notefnerr

cuModuleUnload
```
@Cast("CUresult")
public static int cuModuleUnload(CUmod_st hmod)
```
\brief Unloads a module Unloads a module \p hmod from the current context.

Parameters:

hmod - - Module to unload

Returns:

::CUDA_SUCCESS, ::CUDA_ERROR_DEINITIALIZED, ::CUDA_ERROR_NOT_INITIALIZED, ::CUDA_ERROR_INVALID_CONTEXT, ::CUDA_ERROR_INVALID_VALUE \notefnerr

cuModuleGetFunction
```
@Cast("CUresult")
public static int cuModuleGetFunction(@ByPtrPtr
                                      CUfunc_st hfunc,
                                      CUmod_st hmod,
                                      @Cast("const char*")
                                      BytePointer name)
```
\brief Returns a function handle Returns in \p *hfunc the handle of the function of name \p name located in module \p hmod. If no function of that name exists, ::cuModuleGetFunction() returns ::CUDA_ERROR_NOT_FOUND.

Parameters:

hfunc - - Returned function handle

hmod - - Module to retrieve function from

name - - Name of function to retrieve

Returns:

::CUDA_SUCCESS, ::CUDA_ERROR_DEINITIALIZED, ::CUDA_ERROR_NOT_INITIALIZED, ::CUDA_ERROR_INVALID_CONTEXT, ::CUDA_ERROR_INVALID_VALUE, ::CUDA_ERROR_NOT_FOUND \notefnerr

cuModuleGetFunction

@Cast("CUresult")
public static int cuModuleGetFunction(@ByPtrPtr
                                      CUfunc_st hfunc,
                                      CUmod_st hmod,
                                      String name)

cuModuleGetGlobal
```
@Cast("CUresult")
public static int cuModuleGetGlobal(@Cast("CUdeviceptr*")
                                    LongPointer dptr,
                                    @Cast("size_t*")
                                    SizeTPointer bytes,
                                    CUmod_st hmod,
                                    @Cast("const char*")
                                    BytePointer name)
```
\brief Returns a global pointer from a module Returns in \p *dptr and \p *bytes the base pointer and size of the global of name \p name located in module \p hmod. If no variable of that name exists, ::cuModuleGetGlobal() returns ::CUDA_ERROR_NOT_FOUND. Both parameters \p dptr and \p bytes are optional. If one of them is NULL, it is ignored.

Parameters:

dptr - - Returned global device pointer

bytes - - Returned global size in bytes

hmod - - Module to retrieve global from

name - - Name of global to retrieve

Returns:

::CUDA_SUCCESS, ::CUDA_ERROR_DEINITIALIZED, ::CUDA_ERROR_NOT_INITIALIZED, ::CUDA_ERROR_INVALID_CONTEXT, ::CUDA_ERROR_INVALID_VALUE, ::CUDA_ERROR_NOT_FOUND \notefnerr

cuModuleGetGlobal

@Cast("CUresult")
public static int cuModuleGetGlobal(@Cast("CUdeviceptr*")
                                    LongBuffer dptr,
                                    @Cast("size_t*")
                                    SizeTPointer bytes,
                                    CUmod_st hmod,
                                    String name)

cuModuleGetGlobal

@Cast("CUresult")
public static int cuModuleGetGlobal(@Cast("CUdeviceptr*")
                                    long[] dptr,
                                    @Cast("size_t*")
                                    SizeTPointer bytes,
                                    CUmod_st hmod,
                                    @Cast("const char*")
                                    BytePointer name)

cuModuleGetGlobal

@Cast("CUresult")
public static int cuModuleGetGlobal(@Cast("CUdeviceptr*")
                                    LongPointer dptr,
                                    @Cast("size_t*")
                                    SizeTPointer bytes,
                                    CUmod_st hmod,
                                    String name)

cuModuleGetGlobal

@Cast("CUresult")
public static int cuModuleGetGlobal(@Cast("CUdeviceptr*")
                                    LongBuffer dptr,
                                    @Cast("size_t*")
                                    SizeTPointer bytes,
                                    CUmod_st hmod,
                                    @Cast("const char*")
                                    BytePointer name)

cuModuleGetGlobal

@Cast("CUresult")
public static int cuModuleGetGlobal(@Cast("CUdeviceptr*")
                                    long[] dptr,
                                    @Cast("size_t*")
                                    SizeTPointer bytes,
                                    CUmod_st hmod,
                                    String name)

cuModuleGetTexRef
```
@Cast("CUresult")
public static int cuModuleGetTexRef(@ByPtrPtr
                                    CUtexref_st pTexRef,
                                    CUmod_st hmod,
                                    @Cast("const char*")
                                    BytePointer name)
```
\brief Returns a handle to a texture reference Returns in \p *pTexRef the handle of the texture reference of name \p name in the module \p hmod. If no texture reference of that name exists, ::cuModuleGetTexRef() returns ::CUDA_ERROR_NOT_FOUND. This texture reference handle should not be destroyed, since it will be destroyed when the module is unloaded.

Parameters:

pTexRef - - Returned texture reference

hmod - - Module to retrieve texture reference from

name - - Name of texture reference to retrieve

Returns:

::CUDA_SUCCESS, ::CUDA_ERROR_DEINITIALIZED, ::CUDA_ERROR_NOT_INITIALIZED, ::CUDA_ERROR_INVALID_CONTEXT, ::CUDA_ERROR_INVALID_VALUE, ::CUDA_ERROR_NOT_FOUND \notefnerr

cuModuleGetTexRef

@Cast("CUresult")
public static int cuModuleGetTexRef(@ByPtrPtr
                                    CUtexref_st pTexRef,
                                    CUmod_st hmod,
                                    String name)

cuModuleGetSurfRef
```
@Cast("CUresult")
public static int cuModuleGetSurfRef(@ByPtrPtr
                                     CUsurfref_st pSurfRef,
                                     CUmod_st hmod,
                                     @Cast("const char*")
                                     BytePointer name)
```
\brief Returns a handle to a surface reference Returns in \p *pSurfRef the handle of the surface reference of name \p name in the module \p hmod. If no surface reference of that name exists, ::cuModuleGetSurfRef() returns ::CUDA_ERROR_NOT_FOUND.

Parameters:

pSurfRef - - Returned surface reference

hmod - - Module to retrieve surface reference from

name - - Name of surface reference to retrieve

Returns:

::CUDA_SUCCESS, ::CUDA_ERROR_DEINITIALIZED, ::CUDA_ERROR_NOT_INITIALIZED, ::CUDA_ERROR_INVALID_CONTEXT, ::CUDA_ERROR_INVALID_VALUE, ::CUDA_ERROR_NOT_FOUND \notefnerr

cuModuleGetSurfRef

@Cast("CUresult")
public static int cuModuleGetSurfRef(@ByPtrPtr
                                     CUsurfref_st pSurfRef,
                                     CUmod_st hmod,
                                     String name)

cuLinkCreate
```
@Cast("CUresult")
public static int cuLinkCreate(@Cast("unsigned int")
                               int numOptions,
                               @Cast("CUjit_option*")
                               IntPointer options,
                               @Cast("void**")
                               PointerPointer optionValues,
                               @ByPtrPtr
                               CUlinkState_st stateOut)
```
\brief Creates a pending JIT linker invocation. If the call is successful, the caller owns the returned CUlinkState, which should eventually be destroyed with ::cuLinkDestroy. The device code machine size (32 or 64 bit) will match the calling application. Both linker and compiler options may be specified. Compiler options will be applied to inputs to this linker action which must be compiled from PTX. The options ::CU_JIT_WALL_TIME, ::CU_JIT_INFO_LOG_BUFFER_SIZE_BYTES, and ::CU_JIT_ERROR_LOG_BUFFER_SIZE_BYTES will accumulate data until the CUlinkState is destroyed. \p optionValues must remain valid for the life of the CUlinkState if output options are used. No other references to inputs are maintained after this call returns.

Parameters:

numOptions - Size of options arrays

options - Array of linker and compiler options

optionValues - Array of option values, each cast to void *

stateOut - On success, this will contain a CUlinkState to specify and complete this action

Returns:

::CUDA_SUCCESS, ::CUDA_ERROR_DEINITIALIZED, ::CUDA_ERROR_NOT_INITIALIZED, ::CUDA_ERROR_INVALID_CONTEXT, ::CUDA_ERROR_INVALID_VALUE, ::CUDA_ERROR_OUT_OF_MEMORY, ::CUDA_ERROR_JIT_COMPILER_NOT_FOUND \notefnerr

cuLinkCreate

@Cast("CUresult")
public static int cuLinkCreate(@Cast("unsigned int")
                               int numOptions,
                               @Cast("CUjit_option*")
                               IntPointer options,
                               @Cast("void**") @ByPtrPtr
                               Pointer optionValues,
                               @ByPtrPtr
                               CUlinkState_st stateOut)

cuLinkCreate

@Cast("CUresult")
public static int cuLinkCreate(@Cast("unsigned int")
                               int numOptions,
                               @Cast("CUjit_option*")
                               IntBuffer options,
                               @Cast("void**") @ByPtrPtr
                               Pointer optionValues,
                               @ByPtrPtr
                               CUlinkState_st stateOut)

cuLinkCreate

@Cast("CUresult")
public static int cuLinkCreate(@Cast("unsigned int")
                               int numOptions,
                               @Cast("CUjit_option*")
                               int[] options,
                               @Cast("void**") @ByPtrPtr
                               Pointer optionValues,
                               @ByPtrPtr
                               CUlinkState_st stateOut)

cuLinkAddData

@Cast("CUresult")
public static int cuLinkAddData(CUlinkState_st state,
                                @Cast("CUjitInputType")
                                int type,
                                Pointer data,
                                @Cast("size_t")
                                long size,
                                @Cast("const char*")
                                BytePointer name,
                                @Cast("unsigned int")
                                int numOptions,
                                @Cast("CUjit_option*")
                                IntPointer options,
                                @Cast("void**")
                                PointerPointer optionValues)

\brief Add an input to a pending linker invocation Ownership of \p data is retained by the caller. No reference is retained to any inputs after this call returns. This method accepts only compiler options, which are used if the data must be compiled from PTX, and does not accept any of ::CU_JIT_WALL_TIME, ::CU_JIT_INFO_LOG_BUFFER, ::CU_JIT_ERROR_LOG_BUFFER, ::CU_JIT_TARGET_FROM_CUCONTEXT, or ::CU_JIT_TARGET.

Parameters:: state - A pending linker action.; type - The type of the input data.; data - The input data. PTX must be NULL-terminated.; size - The length of the input data.; name - An optional name for this input in log messages.; numOptions - Size of options.; options - Options to be applied only for this input (overrides options from ::cuLinkCreate).; optionValues - Array of option values, each cast to void *.
Returns:: ::CUDA_SUCCESS, ::CUDA_ERROR_INVALID_HANDLE, ::CUDA_ERROR_INVALID_VALUE, ::CUDA_ERROR_INVALID_IMAGE, ::CUDA_ERROR_INVALID_PTX, ::CUDA_ERROR_OUT_OF_MEMORY, ::CUDA_ERROR_NO_BINARY_FOR_GPU

cuLinkAddData

@Cast("CUresult")
public static int cuLinkAddData(CUlinkState_st state,
                                @Cast("CUjitInputType")
                                int type,
                                Pointer data,
                                @Cast("size_t")
                                long size,
                                @Cast("const char*")
                                BytePointer name,
                                @Cast("unsigned int")
                                int numOptions,
                                @Cast("CUjit_option*")
                                IntPointer options,
                                @Cast("void**") @ByPtrPtr
                                Pointer optionValues)

cuLinkAddData

@Cast("CUresult")
public static int cuLinkAddData(CUlinkState_st state,
                                @Cast("CUjitInputType")
                                int type,
                                Pointer data,
                                @Cast("size_t")
                                long size,
                                String name,
                                @Cast("unsigned int")
                                int numOptions,
                                @Cast("CUjit_option*")
                                IntBuffer options,
                                @Cast("void**") @ByPtrPtr
                                Pointer optionValues)

cuLinkAddData

@Cast("CUresult")
public static int cuLinkAddData(CUlinkState_st state,
                                @Cast("CUjitInputType")
                                int type,
                                Pointer data,
                                @Cast("size_t")
                                long size,
                                @Cast("const char*")
                                BytePointer name,
                                @Cast("unsigned int")
                                int numOptions,
                                @Cast("CUjit_option*")
                                int[] options,
                                @Cast("void**") @ByPtrPtr
                                Pointer optionValues)

cuLinkAddData

@Cast("CUresult")
public static int cuLinkAddData(CUlinkState_st state,
                                @Cast("CUjitInputType")
                                int type,
                                Pointer data,
                                @Cast("size_t")
                                long size,
                                String name,
                                @Cast("unsigned int")
                                int numOptions,
                                @Cast("CUjit_option*")
                                IntPointer options,
                                @Cast("void**") @ByPtrPtr
                                Pointer optionValues)

cuLinkAddData

@Cast("CUresult")
public static int cuLinkAddData(CUlinkState_st state,
                                @Cast("CUjitInputType")
                                int type,
                                Pointer data,
                                @Cast("size_t")
                                long size,
                                @Cast("const char*")
                                BytePointer name,
                                @Cast("unsigned int")
                                int numOptions,
                                @Cast("CUjit_option*")
                                IntBuffer options,
                                @Cast("void**") @ByPtrPtr
                                Pointer optionValues)

cuLinkAddData

@Cast("CUresult")
public static int cuLinkAddData(CUlinkState_st state,
                                @Cast("CUjitInputType")
                                int type,
                                Pointer data,
                                @Cast("size_t")
                                long size,
                                String name,
                                @Cast("unsigned int")
                                int numOptions,
                                @Cast("CUjit_option*")
                                int[] options,
                                @Cast("void**") @ByPtrPtr
                                Pointer optionValues)

cuLinkAddFile
```
@Cast("CUresult")
public static int cuLinkAddFile(CUlinkState_st state,
                                @Cast("CUjitInputType")
                                int type,
                                @Cast("const char*")
                                BytePointer path,
                                @Cast("unsigned int")
                                int numOptions,
                                @Cast("CUjit_option*")
                                IntPointer options,
                                @Cast("void**")
                                PointerPointer optionValues)
```
\brief Add a file input to a pending linker invocation No reference is retained to any inputs after this call returns. This method accepts only compiler options, which are used if the input must be compiled from PTX, and does not accept any of ::CU_JIT_WALL_TIME, ::CU_JIT_INFO_LOG_BUFFER, ::CU_JIT_ERROR_LOG_BUFFER, ::CU_JIT_TARGET_FROM_CUCONTEXT, or ::CU_JIT_TARGET. This method is equivalent to invoking ::cuLinkAddData on the contents of the file.

Parameters:

state - A pending linker action

type - The type of the input data

path - Path to the input file

numOptions - Size of options

options - Options to be applied only for this input (overrides options from ::cuLinkCreate)

optionValues - Array of option values, each cast to void *

Returns:

::CUDA_SUCCESS, ::CUDA_ERROR_FILE_NOT_FOUND ::CUDA_ERROR_INVALID_HANDLE, ::CUDA_ERROR_INVALID_VALUE, ::CUDA_ERROR_INVALID_IMAGE, ::CUDA_ERROR_INVALID_PTX, ::CUDA_ERROR_OUT_OF_MEMORY, ::CUDA_ERROR_NO_BINARY_FOR_GPU

cuLinkAddFile

@Cast("CUresult")
public static int cuLinkAddFile(CUlinkState_st state,
                                @Cast("CUjitInputType")
                                int type,
                                @Cast("const char*")
                                BytePointer path,
                                @Cast("unsigned int")
                                int numOptions,
                                @Cast("CUjit_option*")
                                IntPointer options,
                                @Cast("void**") @ByPtrPtr
                                Pointer optionValues)

cuLinkAddFile

@Cast("CUresult")
public static int cuLinkAddFile(CUlinkState_st state,
                                @Cast("CUjitInputType")
                                int type,
                                String path,
                                @Cast("unsigned int")
                                int numOptions,
                                @Cast("CUjit_option*")
                                IntBuffer options,
                                @Cast("void**") @ByPtrPtr
                                Pointer optionValues)

cuLinkAddFile

@Cast("CUresult")
public static int cuLinkAddFile(CUlinkState_st state,
                                @Cast("CUjitInputType")
                                int type,
                                @Cast("const char*")
                                BytePointer path,
                                @Cast("unsigned int")
                                int numOptions,
                                @Cast("CUjit_option*")
                                int[] options,
                                @Cast("void**") @ByPtrPtr
                                Pointer optionValues)

cuLinkAddFile

@Cast("CUresult")
public static int cuLinkAddFile(CUlinkState_st state,
                                @Cast("CUjitInputType")
                                int type,
                                String path,
                                @Cast("unsigned int")
                                int numOptions,
                                @Cast("CUjit_option*")
                                IntPointer options,
                                @Cast("void**") @ByPtrPtr
                                Pointer optionValues)

cuLinkAddFile

@Cast("CUresult")
public static int cuLinkAddFile(CUlinkState_st state,
                                @Cast("CUjitInputType")
                                int type,
                                @Cast("const char*")
                                BytePointer path,
                                @Cast("unsigned int")
                                int numOptions,
                                @Cast("CUjit_option*")
                                IntBuffer options,
                                @Cast("void**") @ByPtrPtr
                                Pointer optionValues)

cuLinkAddFile

@Cast("CUresult")
public static int cuLinkAddFile(CUlinkState_st state,
                                @Cast("CUjitInputType")
                                int type,
                                String path,
                                @Cast("unsigned int")
                                int numOptions,
                                @Cast("CUjit_option*")
                                int[] options,
                                @Cast("void**") @ByPtrPtr
                                Pointer optionValues)

cuLinkComplete
```
@Cast("CUresult")
public static int cuLinkComplete(CUlinkState_st state,
                                 @Cast("void**")
                                 PointerPointer cubinOut,
                                 @Cast("size_t*")
                                 SizeTPointer sizeOut)
```
\brief Complete a pending linker invocation Completes the pending linker action and returns the cubin image for the linked device code, which can be used with ::cuModuleLoadData. The cubin is owned by \p state, so it should be loaded before \p state is destroyed via ::cuLinkDestroy. This call does not destroy \p state.

Parameters:

state - A pending linker invocation

cubinOut - On success, this will point to the output image

sizeOut - Optional parameter to receive the size of the generated image

Returns:

::CUDA_SUCCESS, ::CUDA_ERROR_INVALID_HANDLE, ::CUDA_ERROR_OUT_OF_MEMORY

cuLinkComplete

@Cast("CUresult")
public static int cuLinkComplete(CUlinkState_st state,
                                 @Cast("void**") @ByPtrPtr
                                 Pointer cubinOut,
                                 @Cast("size_t*")
                                 SizeTPointer sizeOut)

cuLinkDestroy
```
@Cast("CUresult")
public static int cuLinkDestroy(CUlinkState_st state)
```
\brief Destroys state for a JIT linker invocation.

Parameters:

state - State object for the linker invocation

Returns:

::CUDA_SUCCESS, ::CUDA_ERROR_INVALID_HANDLE

cuMemGetInfo
```
@Cast("CUresult")
public static int cuMemGetInfo(@Cast("size_t*")
                               SizeTPointer _free,
                               @Cast("size_t*")
                               SizeTPointer total)
```
\brief Gets free and total memory Returns in \p *free and \p *total respectively, the free and total amount of memory available for allocation by the CUDA context, in bytes.

Parameters:

free - - Returned free memory in bytes

total - - Returned total memory in bytes

Returns:

::CUDA_SUCCESS, ::CUDA_ERROR_DEINITIALIZED, ::CUDA_ERROR_NOT_INITIALIZED, ::CUDA_ERROR_INVALID_CONTEXT, ::CUDA_ERROR_INVALID_VALUE \notefnerr

cuMemAlloc
```
@Cast("CUresult")
public static int cuMemAlloc(@Cast("CUdeviceptr*")
                             LongPointer dptr,
                             @Cast("size_t")
                             long bytesize)
```
\brief Allocates device memory Allocates \p bytesize bytes of linear memory on the device and returns in \p *dptr a pointer to the allocated memory. The allocated memory is suitably aligned for any kind of variable. The memory is not cleared. If \p bytesize is 0, ::cuMemAlloc() returns ::CUDA_ERROR_INVALID_VALUE.

Parameters:

dptr - - Returned device pointer

bytesize - - Requested allocation size in bytes

Returns:

::CUDA_SUCCESS, ::CUDA_ERROR_DEINITIALIZED, ::CUDA_ERROR_NOT_INITIALIZED, ::CUDA_ERROR_INVALID_CONTEXT, ::CUDA_ERROR_INVALID_VALUE, ::CUDA_ERROR_OUT_OF_MEMORY \notefnerr

cuMemAlloc

@Cast("CUresult")
public static int cuMemAlloc(@Cast("CUdeviceptr*")
                             LongBuffer dptr,
                             @Cast("size_t")
                             long bytesize)

cuMemAlloc

@Cast("CUresult")
public static int cuMemAlloc(@Cast("CUdeviceptr*")
                             long[] dptr,
                             @Cast("size_t")
                             long bytesize)

cuMemAllocPitch
```
@Cast("CUresult")
public static int cuMemAllocPitch(@Cast("CUdeviceptr*")
                                  LongPointer dptr,
                                  @Cast("size_t*")
                                  SizeTPointer pPitch,
                                  @Cast("size_t")
                                  long WidthInBytes,
                                  @Cast("size_t")
                                  long Height,
                                  @Cast("unsigned int")
                                  int ElementSizeBytes)
```
\brief Allocates pitched device memory Allocates at least \p WidthInBytes * \p Height bytes of linear memory on the device and returns in \p *dptr a pointer to the allocated memory. The function may pad the allocation to ensure that corresponding pointers in any given row will continue to meet the alignment requirements for coalescing as the address is updated from row to row. \p ElementSizeBytes specifies the size of the largest reads and writes that will be performed on the memory range. \p ElementSizeBytes may be 4, 8 or 16 (since coalesced memory transactions are not possible on other data sizes). If \p ElementSizeBytes is smaller than the actual read/write size of a kernel, the kernel will run correctly, but possibly at reduced speed. The pitch returned in \p *pPitch by ::cuMemAllocPitch() is the width in bytes of the allocation. The intended usage of pitch is as a separate parameter of the allocation, used to compute addresses within the 2D array. Given the row and column of an array element of type \b T, the address is computed as:
```
   T* pElement = (T*)((char*)BaseAddress + Row * Pitch) + Column;
 
```
The pitch returned by ::cuMemAllocPitch() is guaranteed to work with ::cuMemcpy2D() under all circumstances. For allocations of 2D arrays, it is recommended that programmers consider performing pitch allocations using ::cuMemAllocPitch(). Due to alignment restrictions in the hardware, this is especially true if the application will be performing 2D memory copies between different regions of device memory (whether linear memory or CUDA arrays). The byte alignment of the pitch returned by ::cuMemAllocPitch() is guaranteed to match or exceed the alignment requirement for texture binding with ::cuTexRefSetAddress2D().
Parameters:

dptr - - Returned device pointer

pPitch - - Returned pitch of allocation in bytes

WidthInBytes - - Requested allocation width in bytes

Height - - Requested allocation height in rows

ElementSizeBytes - - Size of largest reads/writes for range

Returns:

::CUDA_SUCCESS, ::CUDA_ERROR_DEINITIALIZED, ::CUDA_ERROR_NOT_INITIALIZED, ::CUDA_ERROR_INVALID_CONTEXT, ::CUDA_ERROR_INVALID_VALUE, ::CUDA_ERROR_OUT_OF_MEMORY \notefnerr

cuMemAllocPitch

@Cast("CUresult")
public static int cuMemAllocPitch(@Cast("CUdeviceptr*")
                                  LongBuffer dptr,
                                  @Cast("size_t*")
                                  SizeTPointer pPitch,
                                  @Cast("size_t")
                                  long WidthInBytes,
                                  @Cast("size_t")
                                  long Height,
                                  @Cast("unsigned int")
                                  int ElementSizeBytes)

cuMemAllocPitch

@Cast("CUresult")
public static int cuMemAllocPitch(@Cast("CUdeviceptr*")
                                  long[] dptr,
                                  @Cast("size_t*")
                                  SizeTPointer pPitch,
                                  @Cast("size_t")
                                  long WidthInBytes,
                                  @Cast("size_t")
                                  long Height,
                                  @Cast("unsigned int")
                                  int ElementSizeBytes)

cuMemFree
```
@Cast("CUresult")
public static int cuMemFree(@Cast("CUdeviceptr")
                            long dptr)
```
\brief Frees device memory Frees the memory space pointed to by \p dptr, which must have been returned by a previous call to ::cuMemAlloc() or ::cuMemAllocPitch().

Parameters:

dptr - - Pointer to memory to free

Returns:

::CUDA_SUCCESS, ::CUDA_ERROR_DEINITIALIZED, ::CUDA_ERROR_NOT_INITIALIZED, ::CUDA_ERROR_INVALID_CONTEXT, ::CUDA_ERROR_INVALID_VALUE \notefnerr

cuMemGetAddressRange
```
@Cast("CUresult")
public static int cuMemGetAddressRange(@Cast("CUdeviceptr*")
                                       LongPointer pbase,
                                       @Cast("size_t*")
                                       SizeTPointer psize,
                                       @Cast("CUdeviceptr")
                                       long dptr)
```
\brief Get information on memory allocations Returns the base address in \p *pbase and size in \p *psize of the allocation by ::cuMemAlloc() or ::cuMemAllocPitch() that contains the input pointer \p dptr. Both parameters \p pbase and \p psize are optional. If one of them is NULL, it is ignored.

Parameters:

pbase - - Returned base address

psize - - Returned size of device memory allocation

dptr - - Device pointer to query

Returns:

::CUDA_SUCCESS, ::CUDA_ERROR_DEINITIALIZED, ::CUDA_ERROR_NOT_INITIALIZED, ::CUDA_ERROR_INVALID_CONTEXT, ::CUDA_ERROR_NOT_FOUND, ::CUDA_ERROR_INVALID_VALUE \notefnerr

cuMemGetAddressRange

@Cast("CUresult")
public static int cuMemGetAddressRange(@Cast("CUdeviceptr*")
                                       LongBuffer pbase,
                                       @Cast("size_t*")
                                       SizeTPointer psize,
                                       @Cast("CUdeviceptr")
                                       long dptr)

cuMemGetAddressRange

@Cast("CUresult")
public static int cuMemGetAddressRange(@Cast("CUdeviceptr*")
                                       long[] pbase,
                                       @Cast("size_t*")
                                       SizeTPointer psize,
                                       @Cast("CUdeviceptr")
                                       long dptr)

cuMemAllocHost
```
@Cast("CUresult")
public static int cuMemAllocHost(@Cast("void**")
                                 PointerPointer pp,
                                 @Cast("size_t")
                                 long bytesize)
```
\brief Allocates page-locked host memory Allocates \p bytesize bytes of host memory that is page-locked and accessible to the device. The driver tracks the virtual memory ranges allocated with this function and automatically accelerates calls to functions such as ::cuMemcpy(). Since the memory can be accessed directly by the device, it can be read or written with much higher bandwidth than pageable memory obtained with functions such as ::malloc(). Allocating excessive amounts of memory with ::cuMemAllocHost() may degrade system performance, since it reduces the amount of memory available to the system for paging. As a result, this function is best used sparingly to allocate staging areas for data exchange between host and device. Note all host memory allocated using ::cuMemHostAlloc() will automatically be immediately accessible to all contexts on all devices which support unified addressing (as may be queried using ::CU_DEVICE_ATTRIBUTE_UNIFIED_ADDRESSING). The device pointer that may be used to access this host memory from those contexts is always equal to the returned host pointer \p *pp. See \ref CUDA_UNIFIED for additional details.

Parameters:

pp - - Returned host pointer to page-locked memory

bytesize - - Requested allocation size in bytes

Returns:

::CUDA_SUCCESS, ::CUDA_ERROR_DEINITIALIZED, ::CUDA_ERROR_NOT_INITIALIZED, ::CUDA_ERROR_INVALID_CONTEXT, ::CUDA_ERROR_INVALID_VALUE, ::CUDA_ERROR_OUT_OF_MEMORY \notefnerr

cuMemAllocHost

@Cast("CUresult")
public static int cuMemAllocHost(@Cast("void**") @ByPtrPtr
                                 Pointer pp,
                                 @Cast("size_t")
                                 long bytesize)

cuMemFreeHost
```
@Cast("CUresult")
public static int cuMemFreeHost(Pointer p)
```
\brief Frees page-locked host memory Frees the memory space pointed to by \p p, which must have been returned by a previous call to ::cuMemAllocHost().

Parameters:

p - - Pointer to memory to free

Returns:

::CUDA_SUCCESS, ::CUDA_ERROR_DEINITIALIZED, ::CUDA_ERROR_NOT_INITIALIZED, ::CUDA_ERROR_INVALID_CONTEXT, ::CUDA_ERROR_INVALID_VALUE \notefnerr

cuMemHostAlloc
```
@Cast("CUresult")
public static int cuMemHostAlloc(@Cast("void**")
                                 PointerPointer pp,
                                 @Cast("size_t")
                                 long bytesize,
                                 @Cast("unsigned int")
                                 int Flags)
```
\brief Allocates page-locked host memory Allocates \p bytesize bytes of host memory that is page-locked and accessible to the device. The driver tracks the virtual memory ranges allocated with this function and automatically accelerates calls to functions such as ::cuMemcpyHtoD(). Since the memory can be accessed directly by the device, it can be read or written with much higher bandwidth than pageable memory obtained with functions such as ::malloc(). Allocating excessive amounts of pinned memory may degrade system performance, since it reduces the amount of memory available to the system for paging. As a result, this function is best used sparingly to allocate staging areas for data exchange between host and device. The \p Flags parameter enables different options to be specified that affect the allocation, as follows. - ::CU_MEMHOSTALLOC_PORTABLE: The memory returned by this call will be considered as pinned memory by all CUDA contexts, not just the one that performed the allocation. - ::CU_MEMHOSTALLOC_DEVICEMAP: Maps the allocation into the CUDA address space. The device pointer to the memory may be obtained by calling ::cuMemHostGetDevicePointer(). - ::CU_MEMHOSTALLOC_WRITECOMBINED: Allocates the memory as write-combined (WC). WC memory can be transferred across the PCI Express bus more quickly on some system configurations, but cannot be read efficiently by most CPUs. WC memory is a good option for buffers that will be written by the CPU and read by the GPU via mapped pinned memory or host->device transfers. All of these flags are orthogonal to one another: a developer may allocate memory that is portable, mapped and/or write-combined with no restrictions. The CUDA context must have been created with the ::CU_CTX_MAP_HOST flag in order for the ::CU_MEMHOSTALLOC_DEVICEMAP flag to have any effect. The ::CU_MEMHOSTALLOC_DEVICEMAP flag may be specified on CUDA contexts for devices that do not support mapped pinned memory. The failure is deferred to ::cuMemHostGetDevicePointer() because the memory may be mapped into other CUDA contexts via the ::CU_MEMHOSTALLOC_PORTABLE flag. The memory allocated by this function must be freed with ::cuMemFreeHost(). Note all host memory allocated using ::cuMemHostAlloc() will automatically be immediately accessible to all contexts on all devices which support unified addressing (as may be queried using ::CU_DEVICE_ATTRIBUTE_UNIFIED_ADDRESSING). Unless the flag ::CU_MEMHOSTALLOC_WRITECOMBINED is specified, the device pointer that may be used to access this host memory from those contexts is always equal to the returned host pointer \p *pp. If the flag ::CU_MEMHOSTALLOC_WRITECOMBINED is specified, then the function ::cuMemHostGetDevicePointer() must be used to query the device pointer, even if the context supports unified addressing. See \ref CUDA_UNIFIED for additional details.

Parameters:

pp - - Returned host pointer to page-locked memory

bytesize - - Requested allocation size in bytes

Flags - - Flags for allocation request

Returns:

::CUDA_SUCCESS, ::CUDA_ERROR_DEINITIALIZED, ::CUDA_ERROR_NOT_INITIALIZED, ::CUDA_ERROR_INVALID_CONTEXT, ::CUDA_ERROR_INVALID_VALUE, ::CUDA_ERROR_OUT_OF_MEMORY \notefnerr

cuMemHostAlloc

@Cast("CUresult")
public static int cuMemHostAlloc(@Cast("void**") @ByPtrPtr
                                 Pointer pp,
                                 @Cast("size_t")
                                 long bytesize,
                                 @Cast("unsigned int")
                                 int Flags)

cuMemHostGetDevicePointer
```
@Cast("CUresult")
public static int cuMemHostGetDevicePointer(@Cast("CUdeviceptr*")
                                            LongPointer pdptr,
                                            Pointer p,
                                            @Cast("unsigned int")
                                            int Flags)
```
\brief Passes back device pointer of mapped pinned memory Passes back the device pointer \p pdptr corresponding to the mapped, pinned host buffer \p p allocated by ::cuMemHostAlloc. ::cuMemHostGetDevicePointer() will fail if the ::CU_MEMHOSTALLOC_DEVICEMAP flag was not specified at the time the memory was allocated, or if the function is called on a GPU that does not support mapped pinned memory. For devices that have a non-zero value for the device attribute ::CU_DEVICE_ATTRIBUTE_CAN_USE_HOST_POINTER_FOR_REGISTERED_MEM, the memory can also be accessed from the device using the host pointer \p p. The device pointer returned by ::cuMemHostGetDevicePointer() may or may not match the original host pointer \p p and depends on the devices visible to the application. If all devices visible to the application have a non-zero value for the device attribute, the device pointer returned by ::cuMemHostGetDevicePointer() will match the original pointer \p p. If any device visible to the application has a zero value for the device attribute, the device pointer returned by ::cuMemHostGetDevicePointer() will not match the original host pointer \p p, but it will be suitable for use on all devices provided Unified Virtual Addressing is enabled. In such systems, it is valid to access the memory using either pointer on devices that have a non-zero value for the device attribute. Note however that such devices should access the memory using only of the two pointers and not both. \p Flags provides for future releases. For now, it must be set to 0.

Parameters:

pdptr - - Returned device pointer

p - - Host pointer

Flags - - Options (must be 0)

Returns:

::CUDA_SUCCESS, ::CUDA_ERROR_DEINITIALIZED, ::CUDA_ERROR_NOT_INITIALIZED, ::CUDA_ERROR_INVALID_CONTEXT, ::CUDA_ERROR_INVALID_VALUE \notefnerr

cuMemHostGetDevicePointer

@Cast("CUresult")
public static int cuMemHostGetDevicePointer(@Cast("CUdeviceptr*")
                                            LongBuffer pdptr,
                                            Pointer p,
                                            @Cast("unsigned int")
                                            int Flags)

cuMemHostGetDevicePointer

@Cast("CUresult")
public static int cuMemHostGetDevicePointer(@Cast("CUdeviceptr*")
                                            long[] pdptr,
                                            Pointer p,
                                            @Cast("unsigned int")
                                            int Flags)

cuMemHostGetFlags
```
@Cast("CUresult")
public static int cuMemHostGetFlags(@Cast("unsigned int*")
                                    IntPointer pFlags,
                                    Pointer p)
```
\brief Passes back flags that were used for a pinned allocation Passes back the flags \p pFlags that were specified when allocating the pinned host buffer \p p allocated by ::cuMemHostAlloc. ::cuMemHostGetFlags() will fail if the pointer does not reside in an allocation performed by ::cuMemAllocHost() or ::cuMemHostAlloc().

Parameters:

pFlags - - Returned flags word

p - - Host pointer

Returns:

::CUDA_SUCCESS, ::CUDA_ERROR_DEINITIALIZED, ::CUDA_ERROR_NOT_INITIALIZED, ::CUDA_ERROR_INVALID_CONTEXT, ::CUDA_ERROR_INVALID_VALUE \notefnerr

cuMemHostGetFlags

@Cast("CUresult")
public static int cuMemHostGetFlags(@Cast("unsigned int*")
                                    IntBuffer pFlags,
                                    Pointer p)

cuMemHostGetFlags

@Cast("CUresult")
public static int cuMemHostGetFlags(@Cast("unsigned int*")
                                    int[] pFlags,
                                    Pointer p)

cuMemAllocManaged
```
@Cast("CUresult")
public static int cuMemAllocManaged(@Cast("CUdeviceptr*")
                                    LongPointer dptr,
                                    @Cast("size_t")
                                    long bytesize,
                                    @Cast("unsigned int")
                                    int flags)
```
\brief Allocates memory that will be automatically managed by the Unified Memory system Allocates \p bytesize bytes of managed memory on the device and returns in \p *dptr a pointer to the allocated memory. If the device doesn't support allocating managed memory, ::CUDA_ERROR_NOT_SUPPORTED is returned. Support for managed memory can be queried using the device attribute ::CU_DEVICE_ATTRIBUTE_MANAGED_MEMORY. The allocated memory is suitably aligned for any kind of variable. The memory is not cleared. If \p bytesize is 0, ::cuMemAllocManaged returns ::CUDA_ERROR_INVALID_VALUE. The pointer is valid on the CPU and on all GPUs in the system that support managed memory. All accesses to this pointer must obey the Unified Memory programming model. \p flags specifies the default stream association for this allocation. \p flags must be one of ::CU_MEM_ATTACH_GLOBAL or ::CU_MEM_ATTACH_HOST. If ::CU_MEM_ATTACH_GLOBAL is specified, then this memory is accessible from any stream on any device. If ::CU_MEM_ATTACH_HOST is specified, then the allocation should not be accessed from devices that have a zero value for the device attribute ::CU_DEVICE_ATTRIBUTE_CONCURRENT_MANAGED_ACCESS; an explicit call to ::cuStreamAttachMemAsync will be required to enable access on such devices. If the association is later changed via ::cuStreamAttachMemAsync to a single stream, the default association as specifed during ::cuMemAllocManaged is restored when that stream is destroyed. For __managed__ variables, the default association is always ::CU_MEM_ATTACH_GLOBAL. Note that destroying a stream is an asynchronous operation, and as a result, the change to default association won't happen until all work in the stream has completed. Memory allocated with ::cuMemAllocManaged should be released with ::cuMemFree. Device memory oversubscription is possible for GPUs that have a non-zero value for the device attribute ::CU_DEVICE_ATTRIBUTE_CONCURRENT_MANAGED_ACCESS. Managed memory on such GPUs may be evicted from device memory to host memory at any time by the Unified Memory driver in order to make room for other allocations. In a multi-GPU system where all GPUs have a non-zero value for the device attribute ::CU_DEVICE_ATTRIBUTE_CONCURRENT_MANAGED_ACCESS, managed memory may not be populated when this API returns and instead may be populated on access. In such systems, managed memory can migrate to any processor's memory at any time. The Unified Memory driver will employ heuristics to maintain data locality and prevent excessive page faults to the extent possible. The application can also guide the driver about memory usage patterns via ::cuMemAdvise. The application can also explicitly migrate memory to a desired processor's memory via ::cuMemPrefetchAsync. In a multi-GPU system where all of the GPUs have a zero value for the device attribute ::CU_DEVICE_ATTRIBUTE_CONCURRENT_MANAGED_ACCESS and all the GPUs have peer-to-peer support with each other, the physical storage for managed memory is created on the GPU which is active at the time ::cuMemAllocManaged is called. All other GPUs will reference the data at reduced bandwidth via peer mappings over the PCIe bus. The Unified Memory driver does not migrate memory among such GPUs. In a multi-GPU system where not all GPUs have peer-to-peer support with each other and where the value of the device attribute ::CU_DEVICE_ATTRIBUTE_CONCURRENT_MANAGED_ACCESS is zero for at least one of those GPUs, the location chosen for physical storage of managed memory is system-dependent. - On Linux, the location chosen will be device memory as long as the current set of active contexts are on devices that either have peer-to-peer support with each other or have a non-zero value for the device attribute ::CU_DEVICE_ATTRIBUTE_CONCURRENT_MANAGED_ACCESS. If there is an active context on a GPU that does not have a non-zero value for that device attribute and it does not have peer-to-peer support with the other devices that have active contexts on them, then the location for physical storage will be 'zero-copy' or host memory. Note that this means that managed memory that is located in device memory is migrated to host memory if a new context is created on a GPU that doesn't have a non-zero value for the device attribute and does not support peer-to-peer with at least one of the other devices that has an active context. This in turn implies that context creation may fail if there is insufficient host memory to migrate all managed allocations. - On Windows, the physical storage is always created in 'zero-copy' or host memory. All GPUs will reference the data at reduced bandwidth over the PCIe bus. In these circumstances, use of the environment variable CUDA_VISIBLE_DEVICES is recommended to restrict CUDA to only use those GPUs that have peer-to-peer support. Alternatively, users can also set CUDA_MANAGED_FORCE_DEVICE_ALLOC to a non-zero value to force the driver to always use device memory for physical storage. When this environment variable is set to a non-zero value, all contexts created in that process on devices that support managed memory have to be peer-to-peer compatible with each other. Context creation will fail if a context is created on a device that supports managed memory and is not peer-to-peer compatible with any of the other managed memory supporting devices on which contexts were previously created, even if those contexts have been destroyed. These environment variables are described in the CUDA programming guide under the "CUDA environment variables" section. - On ARM, managed memory is not available on discrete gpu with Drive PX-2.

Parameters:

dptr - - Returned device pointer

bytesize - - Requested allocation size in bytes

flags - - Must be one of ::CU_MEM_ATTACH_GLOBAL or ::CU_MEM_ATTACH_HOST

Returns:

::CUDA_SUCCESS, ::CUDA_ERROR_DEINITIALIZED, ::CUDA_ERROR_NOT_INITIALIZED, ::CUDA_ERROR_INVALID_CONTEXT, ::CUDA_ERROR_NOT_SUPPORTED, ::CUDA_ERROR_INVALID_VALUE, ::CUDA_ERROR_OUT_OF_MEMORY \notefnerr

cuMemAllocManaged

@Cast("CUresult")
public static int cuMemAllocManaged(@Cast("CUdeviceptr*")
                                    LongBuffer dptr,
                                    @Cast("size_t")
                                    long bytesize,
                                    @Cast("unsigned int")
                                    int flags)

cuMemAllocManaged

@Cast("CUresult")
public static int cuMemAllocManaged(@Cast("CUdeviceptr*")
                                    long[] dptr,
                                    @Cast("size_t")
                                    long bytesize,
                                    @Cast("unsigned int")
                                    int flags)

cuDeviceGetByPCIBusId
```
@Cast("CUresult")
public static int cuDeviceGetByPCIBusId(@Cast("CUdevice*")
                                        IntPointer dev,
                                        @Cast("const char*")
                                        BytePointer pciBusId)
```
\brief Returns a handle to a compute device Returns in \p *device a device handle given a PCI bus ID string.

Parameters:

dev - - Returned device handle

pciBusId - - String in one of the following forms: [domain]:[bus]:[device].[function] [domain]:[bus]:[device] [bus]:[device].[function] where \p domain, \p bus, \p device, and \p function are all hexadecimal values

Returns:

::CUDA_SUCCESS, ::CUDA_ERROR_DEINITIALIZED, ::CUDA_ERROR_NOT_INITIALIZED, ::CUDA_ERROR_INVALID_VALUE, ::CUDA_ERROR_INVALID_DEVICE \notefnerr

cuDeviceGetByPCIBusId

@Cast("CUresult")
public static int cuDeviceGetByPCIBusId(@Cast("CUdevice*")
                                        IntBuffer dev,
                                        String pciBusId)

cuDeviceGetByPCIBusId

@Cast("CUresult")
public static int cuDeviceGetByPCIBusId(@Cast("CUdevice*")
                                        int[] dev,
                                        @Cast("const char*")
                                        BytePointer pciBusId)

cuDeviceGetByPCIBusId

@Cast("CUresult")
public static int cuDeviceGetByPCIBusId(@Cast("CUdevice*")
                                        IntPointer dev,
                                        String pciBusId)

cuDeviceGetByPCIBusId

@Cast("CUresult")
public static int cuDeviceGetByPCIBusId(@Cast("CUdevice*")
                                        IntBuffer dev,
                                        @Cast("const char*")
                                        BytePointer pciBusId)

cuDeviceGetByPCIBusId

@Cast("CUresult")
public static int cuDeviceGetByPCIBusId(@Cast("CUdevice*")
                                        int[] dev,
                                        String pciBusId)

cuDeviceGetPCIBusId
```
@Cast("CUresult")
public static int cuDeviceGetPCIBusId(@Cast("char*")
                                      BytePointer pciBusId,
                                      int len,
                                      @Cast("CUdevice")
                                      int dev)
```
\brief Returns a PCI Bus Id string for the device Returns an ASCII string identifying the device \p dev in the NULL-terminated string pointed to by \p pciBusId. \p len specifies the maximum length of the string that may be returned.

Parameters:

pciBusId - - Returned identifier string for the device in the following format [domain]:[bus]:[device].[function] where \p domain, \p bus, \p device, and \p function are all hexadecimal values. pciBusId should be large enough to store 13 characters including the NULL-terminator.

len - - Maximum length of string to store in \p name

dev - - Device to get identifier string for

Returns:

::CUDA_SUCCESS, ::CUDA_ERROR_DEINITIALIZED, ::CUDA_ERROR_NOT_INITIALIZED, ::CUDA_ERROR_INVALID_VALUE, ::CUDA_ERROR_INVALID_DEVICE \notefnerr

cuDeviceGetPCIBusId

@Cast("CUresult")
public static int cuDeviceGetPCIBusId(@Cast("char*")
                                      ByteBuffer pciBusId,
                                      int len,
                                      @Cast("CUdevice")
                                      int dev)

cuDeviceGetPCIBusId

@Cast("CUresult")
public static int cuDeviceGetPCIBusId(@Cast("char*")
                                      byte[] pciBusId,
                                      int len,
                                      @Cast("CUdevice")
                                      int dev)

cuIpcGetEventHandle
```
@Cast("CUresult")
public static int cuIpcGetEventHandle(CUipcEventHandle pHandle,
                                      CUevent_st event)
```
\brief Gets an interprocess handle for a previously allocated event Takes as input a previously allocated event. This event must have been created with the ::CU_EVENT_INTERPROCESS and ::CU_EVENT_DISABLE_TIMING flags set. This opaque handle may be copied into other processes and opened with ::cuIpcOpenEventHandle to allow efficient hardware synchronization between GPU work in different processes. After the event has been opened in the importing process, ::cuEventRecord, ::cuEventSynchronize, ::cuStreamWaitEvent and ::cuEventQuery may be used in either process. Performing operations on the imported event after the exported event has been freed with ::cuEventDestroy will result in undefined behavior. IPC functionality is restricted to devices with support for unified addressing on Linux and Windows operating systems. IPC functionality on Windows is restricted to GPUs in TCC mode

Parameters:

pHandle - - Pointer to a user allocated CUipcEventHandle in which to return the opaque event handle

event - - Event allocated with ::CU_EVENT_INTERPROCESS and ::CU_EVENT_DISABLE_TIMING flags.

Returns:

::CUDA_SUCCESS, ::CUDA_ERROR_INVALID_HANDLE, ::CUDA_ERROR_OUT_OF_MEMORY, ::CUDA_ERROR_MAP_FAILED, ::CUDA_ERROR_INVALID_VALUE

cuIpcOpenEventHandle
```
@Cast("CUresult")
public static int cuIpcOpenEventHandle(@ByPtrPtr
                                       CUevent_st phEvent,
                                       @ByVal
                                       CUipcEventHandle handle)
```
\brief Opens an interprocess event handle for use in the current process Opens an interprocess event handle exported from another process with ::cuIpcGetEventHandle. This function returns a ::CUevent that behaves like a locally created event with the ::CU_EVENT_DISABLE_TIMING flag specified. This event must be freed with ::cuEventDestroy. Performing operations on the imported event after the exported event has been freed with ::cuEventDestroy will result in undefined behavior. IPC functionality is restricted to devices with support for unified addressing on Linux and Windows operating systems. IPC functionality on Windows is restricted to GPUs in TCC mode

Parameters:

phEvent - - Returns the imported event

handle - - Interprocess handle to open

Returns:

::CUDA_SUCCESS, ::CUDA_ERROR_INVALID_CONTEXT, ::CUDA_ERROR_MAP_FAILED, ::CUDA_ERROR_PEER_ACCESS_UNSUPPORTED, ::CUDA_ERROR_INVALID_HANDLE, ::CUDA_ERROR_INVALID_VALUE

cuIpcGetMemHandle
```
@Cast("CUresult")
public static int cuIpcGetMemHandle(CUipcMemHandle pHandle,
                                    @Cast("CUdeviceptr")
                                    long dptr)
```
\brief Gets an interprocess memory handle for an existing device memory allocation Takes a pointer to the base of an existing device memory allocation created with ::cuMemAlloc and exports it for use in another process. This is a lightweight operation and may be called multiple times on an allocation without adverse effects. If a region of memory is freed with ::cuMemFree and a subsequent call to ::cuMemAlloc returns memory with the same device address, ::cuIpcGetMemHandle will return a unique handle for the new memory. IPC functionality is restricted to devices with support for unified addressing on Linux and Windows operating systems. IPC functionality on Windows is restricted to GPUs in TCC mode

Parameters:

pHandle - - Pointer to user allocated ::CUipcMemHandle to return the handle in.

dptr - - Base pointer to previously allocated device memory

Returns:

::CUDA_SUCCESS, ::CUDA_ERROR_INVALID_HANDLE, ::CUDA_ERROR_OUT_OF_MEMORY, ::CUDA_ERROR_MAP_FAILED, ::CUDA_ERROR_INVALID_VALUE

cuIpcOpenMemHandle
```
@Cast("CUresult")
public static int cuIpcOpenMemHandle(@Cast("CUdeviceptr*")
                                     LongPointer pdptr,
                                     @ByVal
                                     CUipcMemHandle handle,
                                     @Cast("unsigned int")
                                     int Flags)
```
\brief Opens an interprocess memory handle exported from another process and returns a device pointer usable in the local process. Maps memory exported from another process with ::cuIpcGetMemHandle into the current device address space. For contexts on different devices ::cuIpcOpenMemHandle can attempt to enable peer access between the devices as if the user called ::cuCtxEnablePeerAccess. This behavior is controlled by the ::CU_IPC_MEM_LAZY_ENABLE_PEER_ACCESS flag. ::cuDeviceCanAccessPeer can determine if a mapping is possible. ::cuIpcOpenMemHandle can open handles to devices that may not be visible in the process calling the API. Contexts that may open ::CUipcMemHandles are restricted in the following way. ::CUipcMemHandles from each ::CUdevice in a given process may only be opened by one ::CUcontext per ::CUdevice per other process. Memory returned from ::cuIpcOpenMemHandle must be freed with ::cuIpcCloseMemHandle. Calling ::cuMemFree on an exported memory region before calling ::cuIpcCloseMemHandle in the importing context will result in undefined behavior. IPC functionality is restricted to devices with support for unified addressing on Linux and Windows operating systems. IPC functionality on Windows is restricted to GPUs in TCC mode

Parameters:

pdptr - - Returned device pointer

handle - - ::CUipcMemHandle to open

Flags - - Flags for this operation. Must be specified as ::CU_IPC_MEM_LAZY_ENABLE_PEER_ACCESS

Returns:

::CUDA_SUCCESS, ::CUDA_ERROR_INVALID_CONTEXT, ::CUDA_ERROR_MAP_FAILED, ::CUDA_ERROR_INVALID_HANDLE, ::CUDA_ERROR_TOO_MANY_PEERS, ::CUDA_ERROR_INVALID_VALUE \note No guarantees are made about the address returned in \p *pdptr. In particular, multiple processes may not receive the same address for the same \p handle.

cuIpcOpenMemHandle

@Cast("CUresult")
public static int cuIpcOpenMemHandle(@Cast("CUdeviceptr*")
                                     LongBuffer pdptr,
                                     @ByVal
                                     CUipcMemHandle handle,
                                     @Cast("unsigned int")
                                     int Flags)

cuIpcOpenMemHandle

@Cast("CUresult")
public static int cuIpcOpenMemHandle(@Cast("CUdeviceptr*")
                                     long[] pdptr,
                                     @ByVal
                                     CUipcMemHandle handle,
                                     @Cast("unsigned int")
                                     int Flags)

cuIpcCloseMemHandle
```
@Cast("CUresult")
public static int cuIpcCloseMemHandle(@Cast("CUdeviceptr")
                                      long dptr)
```
\brief Close memory mapped with ::cuIpcOpenMemHandle Unmaps memory returnd by ::cuIpcOpenMemHandle. The original allocation in the exporting process as well as imported mappings in other processes will be unaffected. Any resources used to enable peer access will be freed if this is the last mapping using them. IPC functionality is restricted to devices with support for unified addressing on Linux and Windows operating systems. IPC functionality on Windows is restricted to GPUs in TCC mode

Parameters:

dptr - - Device pointer returned by ::cuIpcOpenMemHandle

Returns:

::CUDA_SUCCESS, ::CUDA_ERROR_INVALID_CONTEXT, ::CUDA_ERROR_MAP_FAILED, ::CUDA_ERROR_INVALID_HANDLE, ::CUDA_ERROR_INVALID_VALUE

cuMemHostRegister
```
@Cast("CUresult")
public static int cuMemHostRegister(Pointer p,
                                    @Cast("size_t")
                                    long bytesize,
                                    @Cast("unsigned int")
                                    int Flags)
```
\brief Registers an existing host memory range for use by CUDA Page-locks the memory range specified by \p p and \p bytesize and maps it for the device(s) as specified by \p Flags. This memory range also is added to the same tracking mechanism as ::cuMemHostAlloc to automatically accelerate calls to functions such as ::cuMemcpyHtoD(). Since the memory can be accessed directly by the device, it can be read or written with much higher bandwidth than pageable memory that has not been registered. Page-locking excessive amounts of memory may degrade system performance, since it reduces the amount of memory available to the system for paging. As a result, this function is best used sparingly to register staging areas for data exchange between host and device. This function has limited support on Mac OS X. OS 10.7 or higher is required. The \p Flags parameter enables different options to be specified that affect the allocation, as follows. - ::CU_MEMHOSTREGISTER_PORTABLE: The memory returned by this call will be considered as pinned memory by all CUDA contexts, not just the one that performed the allocation. - ::CU_MEMHOSTREGISTER_DEVICEMAP: Maps the allocation into the CUDA address space. The device pointer to the memory may be obtained by calling ::cuMemHostGetDevicePointer(). - ::CU_MEMHOSTREGISTER_IOMEMORY: The pointer is treated as pointing to some I/O memory space, e.g. the PCI Express resource of a 3rd party device. All of these flags are orthogonal to one another: a developer may page-lock memory that is portable or mapped with no restrictions. The CUDA context must have been created with the ::CU_CTX_MAP_HOST flag in order for the ::CU_MEMHOSTREGISTER_DEVICEMAP flag to have any effect. The ::CU_MEMHOSTREGISTER_DEVICEMAP flag may be specified on CUDA contexts for devices that do not support mapped pinned memory. The failure is deferred to ::cuMemHostGetDevicePointer() because the memory may be mapped into other CUDA contexts via the ::CU_MEMHOSTREGISTER_PORTABLE flag. For devices that have a non-zero value for the device attribute ::CU_DEVICE_ATTRIBUTE_CAN_USE_HOST_POINTER_FOR_REGISTERED_MEM, the memory can also be accessed from the device using the host pointer \p p. The device pointer returned by ::cuMemHostGetDevicePointer() may or may not match the original host pointer \p ptr and depends on the devices visible to the application. If all devices visible to the application have a non-zero value for the device attribute, the device pointer returned by ::cuMemHostGetDevicePointer() will match the original pointer \p ptr. If any device visible to the application has a zero value for the device attribute, the device pointer returned by ::cuMemHostGetDevicePointer() will not match the original host pointer \p ptr, but it will be suitable for use on all devices provided Unified Virtual Addressing is enabled. In such systems, it is valid to access the memory using either pointer on devices that have a non-zero value for the device attribute. Note however that such devices should access the memory using only of the two pointers and not both. The memory page-locked by this function must be unregistered with ::cuMemHostUnregister().

Parameters:

p - - Host pointer to memory to page-lock

bytesize - - Size in bytes of the address range to page-lock

Flags - - Flags for allocation request

Returns:

::CUDA_SUCCESS, ::CUDA_ERROR_DEINITIALIZED, ::CUDA_ERROR_NOT_INITIALIZED, ::CUDA_ERROR_INVALID_CONTEXT, ::CUDA_ERROR_INVALID_VALUE, ::CUDA_ERROR_OUT_OF_MEMORY, ::CUDA_ERROR_HOST_MEMORY_ALREADY_REGISTERED, ::CUDA_ERROR_NOT_PERMITTED, ::CUDA_ERROR_NOT_SUPPORTED \notefnerr

cuMemHostUnregister
```
@Cast("CUresult")
public static int cuMemHostUnregister(Pointer p)
```
\brief Unregisters a memory range that was registered with cuMemHostRegister. Unmaps the memory range whose base address is specified by \p p, and makes it pageable again. The base address must be the same one specified to ::cuMemHostRegister().

Parameters:

p - - Host pointer to memory to unregister

Returns:

::CUDA_SUCCESS, ::CUDA_ERROR_DEINITIALIZED, ::CUDA_ERROR_NOT_INITIALIZED, ::CUDA_ERROR_INVALID_CONTEXT, ::CUDA_ERROR_INVALID_VALUE, ::CUDA_ERROR_OUT_OF_MEMORY, ::CUDA_ERROR_HOST_MEMORY_NOT_REGISTERED, \notefnerr

cuMemcpy
```
@Cast("CUresult")
public static int cuMemcpy(@Cast("CUdeviceptr")
                           long dst,
                           @Cast("CUdeviceptr")
                           long src,
                           @Cast("size_t")
                           long ByteCount)
```
\brief Copies memory Copies data between two pointers. \p dst and \p src are base pointers of the destination and source, respectively. \p ByteCount specifies the number of bytes to copy. Note that this function infers the type of the transfer (host to host, host to device, device to device, or device to host) from the pointer values. This function is only allowed in contexts which support unified addressing.

Parameters:

dst - - Destination unified virtual address space pointer

src - - Source unified virtual address space pointer

ByteCount - - Size of memory copy in bytes

Returns:

::CUDA_SUCCESS, ::CUDA_ERROR_DEINITIALIZED, ::CUDA_ERROR_NOT_INITIALIZED, ::CUDA_ERROR_INVALID_CONTEXT, ::CUDA_ERROR_INVALID_VALUE \notefnerr \note_sync

cuMemcpyPeer
```
@Cast("CUresult")
public static int cuMemcpyPeer(@Cast("CUdeviceptr")
                               long dstDevice,
                               CUctx_st dstContext,
                               @Cast("CUdeviceptr")
                               long srcDevice,
                               CUctx_st srcContext,
                               @Cast("size_t")
                               long ByteCount)
```
\brief Copies device memory between two contexts Copies from device memory in one context to device memory in another context. \p dstDevice is the base device pointer of the destination memory and \p dstContext is the destination context. \p srcDevice is the base device pointer of the source memory and \p srcContext is the source pointer. \p ByteCount specifies the number of bytes to copy.

Parameters:

dstDevice - - Destination device pointer

dstContext - - Destination context

srcDevice - - Source device pointer

srcContext - - Source context

ByteCount - - Size of memory copy in bytes

Returns:

::CUDA_SUCCESS, ::CUDA_ERROR_DEINITIALIZED, ::CUDA_ERROR_NOT_INITIALIZED, ::CUDA_ERROR_INVALID_CONTEXT, ::CUDA_ERROR_INVALID_VALUE \notefnerr \note_sync

cuMemcpyHtoD
```
@Cast("CUresult")
public static int cuMemcpyHtoD(@Cast("CUdeviceptr")
                               long dstDevice,
                               @Const
                               Pointer srcHost,
                               @Cast("size_t")
                               long ByteCount)
```
\brief Copies memory from Host to Device Copies from host memory to device memory. \p dstDevice and \p srcHost are the base addresses of the destination and source, respectively. \p ByteCount specifies the number of bytes to copy.

Parameters:

dstDevice - - Destination device pointer

srcHost - - Source host pointer

ByteCount - - Size of memory copy in bytes

Returns:

::CUDA_SUCCESS, ::CUDA_ERROR_DEINITIALIZED, ::CUDA_ERROR_NOT_INITIALIZED, ::CUDA_ERROR_INVALID_CONTEXT, ::CUDA_ERROR_INVALID_VALUE \notefnerr \note_sync

cuMemcpyDtoH
```
@Cast("CUresult")
public static int cuMemcpyDtoH(Pointer dstHost,
                               @Cast("CUdeviceptr")
                               long srcDevice,
                               @Cast("size_t")
                               long ByteCount)
```
\brief Copies memory from Device to Host Copies from device to host memory. \p dstHost and \p srcDevice specify the base pointers of the destination and source, respectively. \p ByteCount specifies the number of bytes to copy.

Parameters:

dstHost - - Destination host pointer

srcDevice - - Source device pointer

ByteCount - - Size of memory copy in bytes

Returns:

::CUDA_SUCCESS, ::CUDA_ERROR_DEINITIALIZED, ::CUDA_ERROR_NOT_INITIALIZED, ::CUDA_ERROR_INVALID_CONTEXT, ::CUDA_ERROR_INVALID_VALUE \notefnerr \note_sync

cuMemcpyDtoD
```
@Cast("CUresult")
public static int cuMemcpyDtoD(@Cast("CUdeviceptr")
                               long dstDevice,
                               @Cast("CUdeviceptr")
                               long srcDevice,
                               @Cast("size_t")
                               long ByteCount)
```
\brief Copies memory from Device to Device Copies from device memory to device memory. \p dstDevice and \p srcDevice are the base pointers of the destination and source, respectively. \p ByteCount specifies the number of bytes to copy.

Parameters:

dstDevice - - Destination device pointer

srcDevice - - Source device pointer

ByteCount - - Size of memory copy in bytes

Returns:

::CUDA_SUCCESS, ::CUDA_ERROR_DEINITIALIZED, ::CUDA_ERROR_NOT_INITIALIZED, ::CUDA_ERROR_INVALID_CONTEXT, ::CUDA_ERROR_INVALID_VALUE \notefnerr \note_sync

cuMemcpyDtoA
```
@Cast("CUresult")
public static int cuMemcpyDtoA(CUarray_st dstArray,
                               @Cast("size_t")
                               long dstOffset,
                               @Cast("CUdeviceptr")
                               long srcDevice,
                               @Cast("size_t")
                               long ByteCount)
```
\brief Copies memory from Device to Array Copies from device memory to a 1D CUDA array. \p dstArray and \p dstOffset specify the CUDA array handle and starting index of the destination data. \p srcDevice specifies the base pointer of the source. \p ByteCount specifies the number of bytes to copy.

Parameters:

dstArray - - Destination array

dstOffset - - Offset in bytes of destination array

srcDevice - - Source device pointer

ByteCount - - Size of memory copy in bytes

Returns:

::CUDA_SUCCESS, ::CUDA_ERROR_DEINITIALIZED, ::CUDA_ERROR_NOT_INITIALIZED, ::CUDA_ERROR_INVALID_CONTEXT, ::CUDA_ERROR_INVALID_VALUE \notefnerr \note_sync

cuMemcpyAtoD
```
@Cast("CUresult")
public static int cuMemcpyAtoD(@Cast("CUdeviceptr")
                               long dstDevice,
                               CUarray_st srcArray,
                               @Cast("size_t")
                               long srcOffset,
                               @Cast("size_t")
                               long ByteCount)
```
\brief Copies memory from Array to Device Copies from one 1D CUDA array to device memory. \p dstDevice specifies the base pointer of the destination and must be naturally aligned with the CUDA array elements. \p srcArray and \p srcOffset specify the CUDA array handle and the offset in bytes into the array where the copy is to begin. \p ByteCount specifies the number of bytes to copy and must be evenly divisible by the array element size.

Parameters:

dstDevice - - Destination device pointer

srcArray - - Source array

srcOffset - - Offset in bytes of source array

ByteCount - - Size of memory copy in bytes

Returns:

::CUDA_SUCCESS, ::CUDA_ERROR_DEINITIALIZED, ::CUDA_ERROR_NOT_INITIALIZED, ::CUDA_ERROR_INVALID_CONTEXT, ::CUDA_ERROR_INVALID_VALUE \notefnerr \note_sync

cuMemcpyHtoA
```
@Cast("CUresult")
public static int cuMemcpyHtoA(CUarray_st dstArray,
                               @Cast("size_t")
                               long dstOffset,
                               @Const
                               Pointer srcHost,
                               @Cast("size_t")
                               long ByteCount)
```
\brief Copies memory from Host to Array Copies from host memory to a 1D CUDA array. \p dstArray and \p dstOffset specify the CUDA array handle and starting offset in bytes of the destination data. \p pSrc specifies the base address of the source. \p ByteCount specifies the number of bytes to copy.

Parameters:

dstArray - - Destination array

dstOffset - - Offset in bytes of destination array

srcHost - - Source host pointer

ByteCount - - Size of memory copy in bytes

Returns:

::CUDA_SUCCESS, ::CUDA_ERROR_DEINITIALIZED, ::CUDA_ERROR_NOT_INITIALIZED, ::CUDA_ERROR_INVALID_CONTEXT, ::CUDA_ERROR_INVALID_VALUE \notefnerr \note_sync

cuMemcpyAtoH
```
@Cast("CUresult")
public static int cuMemcpyAtoH(Pointer dstHost,
                               CUarray_st srcArray,
                               @Cast("size_t")
                               long srcOffset,
                               @Cast("size_t")
                               long ByteCount)
```
\brief Copies memory from Array to Host Copies from one 1D CUDA array to host memory. \p dstHost specifies the base pointer of the destination. \p srcArray and \p srcOffset specify the CUDA array handle and starting offset in bytes of the source data. \p ByteCount specifies the number of bytes to copy.

Parameters:

dstHost - - Destination device pointer

srcArray - - Source array

srcOffset - - Offset in bytes of source array

ByteCount - - Size of memory copy in bytes

Returns:

::CUDA_SUCCESS, ::CUDA_ERROR_DEINITIALIZED, ::CUDA_ERROR_NOT_INITIALIZED, ::CUDA_ERROR_INVALID_CONTEXT, ::CUDA_ERROR_INVALID_VALUE \notefnerr \note_sync

cuMemcpyAtoA
```
@Cast("CUresult")
public static int cuMemcpyAtoA(CUarray_st dstArray,
                               @Cast("size_t")
                               long dstOffset,
                               CUarray_st srcArray,
                               @Cast("size_t")
                               long srcOffset,
                               @Cast("size_t")
                               long ByteCount)
```
\brief Copies memory from Array to Array Copies from one 1D CUDA array to another. \p dstArray and \p srcArray specify the handles of the destination and source CUDA arrays for the copy, respectively. \p dstOffset and \p srcOffset specify the destination and source offsets in bytes into the CUDA arrays. \p ByteCount is the number of bytes to be copied. The size of the elements in the CUDA arrays need not be the same format, but the elements must be the same size; and count must be evenly divisible by that size.

Parameters:

dstArray - - Destination array

dstOffset - - Offset in bytes of destination array

srcArray - - Source array

srcOffset - - Offset in bytes of source array

ByteCount - - Size of memory copy in bytes

Returns:

::CUDA_SUCCESS, ::CUDA_ERROR_DEINITIALIZED, ::CUDA_ERROR_NOT_INITIALIZED, ::CUDA_ERROR_INVALID_CONTEXT, ::CUDA_ERROR_INVALID_VALUE \notefnerr \note_sync

cuMemcpy2D
```
@Cast("CUresult")
public static int cuMemcpy2D(@Const
                             CUDA_MEMCPY2D pCopy)
```
\brief Copies memory for 2D arrays Perform a 2D memory copy according to the parameters specified in \p pCopy. The ::CUDA_MEMCPY2D structure is defined as:
```
   typedef struct CUDA_MEMCPY2D_st {
      unsigned int srcXInBytes, srcY;
      CUmemorytype srcMemoryType;
          const void *srcHost;
          CUdeviceptr srcDevice;
          CUarray srcArray;
          unsigned int srcPitch;

      unsigned int dstXInBytes, dstY;
      CUmemorytype dstMemoryType;
          void *dstHost;
          CUdeviceptr dstDevice;
          CUarray dstArray;
          unsigned int dstPitch;

      unsigned int WidthInBytes;
      unsigned int Height;
   } CUDA_MEMCPY2D;
 
```
where: - ::srcMemoryType and ::dstMemoryType specify the type of memory of the source and destination, respectively; ::CUmemorytype_enum is defined as:
```
   typedef enum CUmemorytype_enum {
      CU_MEMORYTYPE_HOST = 0x01,
      CU_MEMORYTYPE_DEVICE = 0x02,
      CU_MEMORYTYPE_ARRAY = 0x03,
      CU_MEMORYTYPE_UNIFIED = 0x04
   } CUmemorytype;
 
```
\par If ::srcMemoryType is ::CU_MEMORYTYPE_UNIFIED, ::srcDevice and ::srcPitch specify the (unified virtual address space) base address of the source data and the bytes per row to apply. ::srcArray is ignored. This value may be used only if unified addressing is supported in the calling context. \par If ::srcMemoryType is ::CU_MEMORYTYPE_HOST, ::srcHost and ::srcPitch specify the (host) base address of the source data and the bytes per row to apply. ::srcArray is ignored. \par If ::srcMemoryType is ::CU_MEMORYTYPE_DEVICE, ::srcDevice and ::srcPitch specify the (device) base address of the source data and the bytes per row to apply. ::srcArray is ignored. \par If ::srcMemoryType is ::CU_MEMORYTYPE_ARRAY, ::srcArray specifies the handle of the source data. ::srcHost, ::srcDevice and ::srcPitch are ignored. \par If ::dstMemoryType is ::CU_MEMORYTYPE_HOST, ::dstHost and ::dstPitch specify the (host) base address of the destination data and the bytes per row to apply. ::dstArray is ignored. \par If ::dstMemoryType is ::CU_MEMORYTYPE_UNIFIED, ::dstDevice and ::dstPitch specify the (unified virtual address space) base address of the source data and the bytes per row to apply. ::dstArray is ignored. This value may be used only if unified addressing is supported in the calling context. \par If ::dstMemoryType is ::CU_MEMORYTYPE_DEVICE, ::dstDevice and ::dstPitch specify the (device) base address of the destination data and the bytes per row to apply. ::dstArray is ignored. \par If ::dstMemoryType is ::CU_MEMORYTYPE_ARRAY, ::dstArray specifies the handle of the destination data. ::dstHost, ::dstDevice and ::dstPitch are ignored. - ::srcXInBytes and ::srcY specify the base address of the source data for the copy. \par For host pointers, the starting address is
```
  void* Start = (void*)((char*)srcHost+srcY*srcPitch + srcXInBytes);
 
```
\par For device pointers, the starting address is
```
  CUdeviceptr Start = srcDevice+srcY*srcPitch+srcXInBytes;
 
```
\par For CUDA arrays, ::srcXInBytes must be evenly divisible by the array element size. - ::dstXInBytes and ::dstY specify the base address of the destination data for the copy. \par For host pointers, the base address is
```
  void* dstStart = (void*)((char*)dstHost+dstY*dstPitch + dstXInBytes);
 
```
\par For device pointers, the starting address is
```
  CUdeviceptr dstStart = dstDevice+dstY*dstPitch+dstXInBytes;
 
```
\par For CUDA arrays, ::dstXInBytes must be evenly divisible by the array element size. - ::WidthInBytes and ::Height specify the width (in bytes) and height of the 2D copy being performed. - If specified, ::srcPitch must be greater than or equal to ::WidthInBytes + ::srcXInBytes, and ::dstPitch must be greater than or equal to ::WidthInBytes + dstXInBytes. \par ::cuMemcpy2D() returns an error if any pitch is greater than the maximum allowed (::CU_DEVICE_ATTRIBUTE_MAX_PITCH). ::cuMemAllocPitch() passes back pitches that always work with ::cuMemcpy2D(). On intra-device memory copies (device to device, CUDA array to device, CUDA array to CUDA array), ::cuMemcpy2D() may fail for pitches not computed by ::cuMemAllocPitch(). ::cuMemcpy2DUnaligned() does not have this restriction, but may run significantly slower in the cases where ::cuMemcpy2D() would have returned an error code.
Parameters:

pCopy - - Parameters for the memory copy

Returns:

::CUDA_SUCCESS, ::CUDA_ERROR_DEINITIALIZED, ::CUDA_ERROR_NOT_INITIALIZED, ::CUDA_ERROR_INVALID_CONTEXT, ::CUDA_ERROR_INVALID_VALUE \notefnerr \note_sync

cuMemcpy2DUnaligned
```
@Cast("CUresult")
public static int cuMemcpy2DUnaligned(@Const
                                      CUDA_MEMCPY2D pCopy)
```
\brief Copies memory for 2D arrays Perform a 2D memory copy according to the parameters specified in \p pCopy. The ::CUDA_MEMCPY2D structure is defined as:
```
   typedef struct CUDA_MEMCPY2D_st {
      unsigned int srcXInBytes, srcY;
      CUmemorytype srcMemoryType;
      const void *srcHost;
      CUdeviceptr srcDevice;
      CUarray srcArray;
      unsigned int srcPitch;
      unsigned int dstXInBytes, dstY;
      CUmemorytype dstMemoryType;
      void *dstHost;
      CUdeviceptr dstDevice;
      CUarray dstArray;
      unsigned int dstPitch;
      unsigned int WidthInBytes;
      unsigned int Height;
   } CUDA_MEMCPY2D;
 
```
where: - ::srcMemoryType and ::dstMemoryType specify the type of memory of the source and destination, respectively; ::CUmemorytype_enum is defined as:
```
   typedef enum CUmemorytype_enum {
      CU_MEMORYTYPE_HOST = 0x01,
      CU_MEMORYTYPE_DEVICE = 0x02,
      CU_MEMORYTYPE_ARRAY = 0x03,
      CU_MEMORYTYPE_UNIFIED = 0x04
   } CUmemorytype;
 
```
\par If ::srcMemoryType is ::CU_MEMORYTYPE_UNIFIED, ::srcDevice and ::srcPitch specify the (unified virtual address space) base address of the source data and the bytes per row to apply. ::srcArray is ignored. This value may be used only if unified addressing is supported in the calling context. \par If ::srcMemoryType is ::CU_MEMORYTYPE_HOST, ::srcHost and ::srcPitch specify the (host) base address of the source data and the bytes per row to apply. ::srcArray is ignored. \par If ::srcMemoryType is ::CU_MEMORYTYPE_DEVICE, ::srcDevice and ::srcPitch specify the (device) base address of the source data and the bytes per row to apply. ::srcArray is ignored. \par If ::srcMemoryType is ::CU_MEMORYTYPE_ARRAY, ::srcArray specifies the handle of the source data. ::srcHost, ::srcDevice and ::srcPitch are ignored. \par If ::dstMemoryType is ::CU_MEMORYTYPE_UNIFIED, ::dstDevice and ::dstPitch specify the (unified virtual address space) base address of the source data and the bytes per row to apply. ::dstArray is ignored. This value may be used only if unified addressing is supported in the calling context. \par If ::dstMemoryType is ::CU_MEMORYTYPE_HOST, ::dstHost and ::dstPitch specify the (host) base address of the destination data and the bytes per row to apply. ::dstArray is ignored. \par If ::dstMemoryType is ::CU_MEMORYTYPE_DEVICE, ::dstDevice and ::dstPitch specify the (device) base address of the destination data and the bytes per row to apply. ::dstArray is ignored. \par If ::dstMemoryType is ::CU_MEMORYTYPE_ARRAY, ::dstArray specifies the handle of the destination data. ::dstHost, ::dstDevice and ::dstPitch are ignored. - ::srcXInBytes and ::srcY specify the base address of the source data for the copy. \par For host pointers, the starting address is
```
  void* Start = (void*)((char*)srcHost+srcY*srcPitch + srcXInBytes);
 
```
\par For device pointers, the starting address is
```
  CUdeviceptr Start = srcDevice+srcY*srcPitch+srcXInBytes;
 
```
\par For CUDA arrays, ::srcXInBytes must be evenly divisible by the array element size. - ::dstXInBytes and ::dstY specify the base address of the destination data for the copy. \par For host pointers, the base address is
```
  void* dstStart = (void*)((char*)dstHost+dstY*dstPitch + dstXInBytes);
 
```
\par For device pointers, the starting address is
```
  CUdeviceptr dstStart = dstDevice+dstY*dstPitch+dstXInBytes;
 
```
\par For CUDA arrays, ::dstXInBytes must be evenly divisible by the array element size. - ::WidthInBytes and ::Height specify the width (in bytes) and height of the 2D copy being performed. - If specified, ::srcPitch must be greater than or equal to ::WidthInBytes + ::srcXInBytes, and ::dstPitch must be greater than or equal to ::WidthInBytes + dstXInBytes. \par ::cuMemcpy2D() returns an error if any pitch is greater than the maximum allowed (::CU_DEVICE_ATTRIBUTE_MAX_PITCH). ::cuMemAllocPitch() passes back pitches that always work with ::cuMemcpy2D(). On intra-device memory copies (device to device, CUDA array to device, CUDA array to CUDA array), ::cuMemcpy2D() may fail for pitches not computed by ::cuMemAllocPitch(). ::cuMemcpy2DUnaligned() does not have this restriction, but may run significantly slower in the cases where ::cuMemcpy2D() would have returned an error code.
Parameters:

pCopy - - Parameters for the memory copy

Returns:

::CUDA_SUCCESS, ::CUDA_ERROR_DEINITIALIZED, ::CUDA_ERROR_NOT_INITIALIZED, ::CUDA_ERROR_INVALID_CONTEXT, ::CUDA_ERROR_INVALID_VALUE \notefnerr \note_sync

cuMemcpy3D
```
@Cast("CUresult")
public static int cuMemcpy3D(@Const
                             CUDA_MEMCPY3D pCopy)
```
\brief Copies memory for 3D arrays Perform a 3D memory copy according to the parameters specified in \p pCopy. The ::CUDA_MEMCPY3D structure is defined as:
```
        typedef struct CUDA_MEMCPY3D_st {

            unsigned int srcXInBytes, srcY, srcZ;
            unsigned int srcLOD;
            CUmemorytype srcMemoryType;
                const void *srcHost;
                CUdeviceptr srcDevice;
                CUarray srcArray;
                unsigned int srcPitch;  // ignored when src is array
                unsigned int srcHeight; // ignored when src is array; may be 0 if Depth==1

            unsigned int dstXInBytes, dstY, dstZ;
            unsigned int dstLOD;
            CUmemorytype dstMemoryType;
                void *dstHost;
                CUdeviceptr dstDevice;
                CUarray dstArray;
                unsigned int dstPitch;  // ignored when dst is array
                unsigned int dstHeight; // ignored when dst is array; may be 0 if Depth==1

            unsigned int WidthInBytes;
            unsigned int Height;
            unsigned int Depth;
        } CUDA_MEMCPY3D;
 
```
where: - ::srcMemoryType and ::dstMemoryType specify the type of memory of the source and destination, respectively; ::CUmemorytype_enum is defined as:
```
   typedef enum CUmemorytype_enum {
      CU_MEMORYTYPE_HOST = 0x01,
      CU_MEMORYTYPE_DEVICE = 0x02,
      CU_MEMORYTYPE_ARRAY = 0x03,
      CU_MEMORYTYPE_UNIFIED = 0x04
   } CUmemorytype;
 
```
\par If ::srcMemoryType is ::CU_MEMORYTYPE_UNIFIED, ::srcDevice and ::srcPitch specify the (unified virtual address space) base address of the source data and the bytes per row to apply. ::srcArray is ignored. This value may be used only if unified addressing is supported in the calling context. \par If ::srcMemoryType is ::CU_MEMORYTYPE_HOST, ::srcHost, ::srcPitch and ::srcHeight specify the (host) base address of the source data, the bytes per row, and the height of each 2D slice of the 3D array. ::srcArray is ignored. \par If ::srcMemoryType is ::CU_MEMORYTYPE_DEVICE, ::srcDevice, ::srcPitch and ::srcHeight specify the (device) base address of the source data, the bytes per row, and the height of each 2D slice of the 3D array. ::srcArray is ignored. \par If ::srcMemoryType is ::CU_MEMORYTYPE_ARRAY, ::srcArray specifies the handle of the source data. ::srcHost, ::srcDevice, ::srcPitch and ::srcHeight are ignored. \par If ::dstMemoryType is ::CU_MEMORYTYPE_UNIFIED, ::dstDevice and ::dstPitch specify the (unified virtual address space) base address of the source data and the bytes per row to apply. ::dstArray is ignored. This value may be used only if unified addressing is supported in the calling context. \par If ::dstMemoryType is ::CU_MEMORYTYPE_HOST, ::dstHost and ::dstPitch specify the (host) base address of the destination data, the bytes per row, and the height of each 2D slice of the 3D array. ::dstArray is ignored. \par If ::dstMemoryType is ::CU_MEMORYTYPE_DEVICE, ::dstDevice and ::dstPitch specify the (device) base address of the destination data, the bytes per row, and the height of each 2D slice of the 3D array. ::dstArray is ignored. \par If ::dstMemoryType is ::CU_MEMORYTYPE_ARRAY, ::dstArray specifies the handle of the destination data. ::dstHost, ::dstDevice, ::dstPitch and ::dstHeight are ignored. - ::srcXInBytes, ::srcY and ::srcZ specify the base address of the source data for the copy. \par For host pointers, the starting address is
```
  void* Start = (void*)((char*)srcHost+(srcZ*srcHeight+srcY)*srcPitch + srcXInBytes);
 
```
\par For device pointers, the starting address is
```
  CUdeviceptr Start = srcDevice+(srcZ*srcHeight+srcY)*srcPitch+srcXInBytes;
 
```
\par For CUDA arrays, ::srcXInBytes must be evenly divisible by the array element size. - dstXInBytes, ::dstY and ::dstZ specify the base address of the destination data for the copy. \par For host pointers, the base address is
```
  void* dstStart = (void*)((char*)dstHost+(dstZ*dstHeight+dstY)*dstPitch + dstXInBytes);
 
```
\par For device pointers, the starting address is
```
  CUdeviceptr dstStart = dstDevice+(dstZ*dstHeight+dstY)*dstPitch+dstXInBytes;
 
```
\par For CUDA arrays, ::dstXInBytes must be evenly divisible by the array element size. - ::WidthInBytes, ::Height and ::Depth specify the width (in bytes), height and depth of the 3D copy being performed. - If specified, ::srcPitch must be greater than or equal to ::WidthInBytes + ::srcXInBytes, and ::dstPitch must be greater than or equal to ::WidthInBytes + dstXInBytes. - If specified, ::srcHeight must be greater than or equal to ::Height + ::srcY, and ::dstHeight must be greater than or equal to ::Height + ::dstY. \par ::cuMemcpy3D() returns an error if any pitch is greater than the maximum allowed (::CU_DEVICE_ATTRIBUTE_MAX_PITCH). The ::srcLOD and ::dstLOD members of the ::CUDA_MEMCPY3D structure must be set to 0.
Parameters:

pCopy - - Parameters for the memory copy

Returns:

::CUDA_SUCCESS, ::CUDA_ERROR_DEINITIALIZED, ::CUDA_ERROR_NOT_INITIALIZED, ::CUDA_ERROR_INVALID_CONTEXT, ::CUDA_ERROR_INVALID_VALUE \notefnerr \note_sync

cuMemcpy3DPeer
```
@Cast("CUresult")
public static int cuMemcpy3DPeer(@Const
                                 CUDA_MEMCPY3D_PEER pCopy)
```
\brief Copies memory between contexts Perform a 3D memory copy according to the parameters specified in \p pCopy. See the definition of the ::CUDA_MEMCPY3D_PEER structure for documentation of its parameters.

Parameters:

pCopy - - Parameters for the memory copy

Returns:

::CUDA_SUCCESS, ::CUDA_ERROR_DEINITIALIZED, ::CUDA_ERROR_NOT_INITIALIZED, ::CUDA_ERROR_INVALID_CONTEXT, ::CUDA_ERROR_INVALID_VALUE \notefnerr \note_sync

cuMemcpyAsync
```
@Cast("CUresult")
public static int cuMemcpyAsync(@Cast("CUdeviceptr")
                                long dst,
                                @Cast("CUdeviceptr")
                                long src,
                                @Cast("size_t")
                                long ByteCount,
                                CUstream_st hStream)
```
\brief Copies memory asynchronously Copies data between two pointers. \p dst and \p src are base pointers of the destination and source, respectively. \p ByteCount specifies the number of bytes to copy. Note that this function infers the type of the transfer (host to host, host to device, device to device, or device to host) from the pointer values. This function is only allowed in contexts which support unified addressing.

Parameters:

dst - - Destination unified virtual address space pointer

src - - Source unified virtual address space pointer

ByteCount - - Size of memory copy in bytes

hStream - - Stream identifier

Returns:

::CUDA_SUCCESS, ::CUDA_ERROR_DEINITIALIZED, ::CUDA_ERROR_NOT_INITIALIZED, ::CUDA_ERROR_INVALID_CONTEXT, ::CUDA_ERROR_INVALID_VALUE, ::CUDA_ERROR_INVALID_HANDLE \notefnerr \note_async \note_null_stream

cuMemcpyPeerAsync
```
@Cast("CUresult")
public static int cuMemcpyPeerAsync(@Cast("CUdeviceptr")
                                    long dstDevice,
                                    CUctx_st dstContext,
                                    @Cast("CUdeviceptr")
                                    long srcDevice,
                                    CUctx_st srcContext,
                                    @Cast("size_t")
                                    long ByteCount,
                                    CUstream_st hStream)
```
\brief Copies device memory between two contexts asynchronously. Copies from device memory in one context to device memory in another context. \p dstDevice is the base device pointer of the destination memory and \p dstContext is the destination context. \p srcDevice is the base device pointer of the source memory and \p srcContext is the source pointer. \p ByteCount specifies the number of bytes to copy.

Parameters:

dstDevice - - Destination device pointer

dstContext - - Destination context

srcDevice - - Source device pointer

srcContext - - Source context

ByteCount - - Size of memory copy in bytes

hStream - - Stream identifier

Returns:

::CUDA_SUCCESS, ::CUDA_ERROR_DEINITIALIZED, ::CUDA_ERROR_NOT_INITIALIZED, ::CUDA_ERROR_INVALID_CONTEXT, ::CUDA_ERROR_INVALID_VALUE, ::CUDA_ERROR_INVALID_HANDLE \notefnerr \note_async \note_null_stream

cuMemcpyHtoDAsync
```
@Cast("CUresult")
public static int cuMemcpyHtoDAsync(@Cast("CUdeviceptr")
                                    long dstDevice,
                                    @Const
                                    Pointer srcHost,
                                    @Cast("size_t")
                                    long ByteCount,
                                    CUstream_st hStream)
```
\brief Copies memory from Host to Device Copies from host memory to device memory. \p dstDevice and \p srcHost are the base addresses of the destination and source, respectively. \p ByteCount specifies the number of bytes to copy.

Parameters:

dstDevice - - Destination device pointer

srcHost - - Source host pointer

ByteCount - - Size of memory copy in bytes

hStream - - Stream identifier

Returns:

::CUDA_SUCCESS, ::CUDA_ERROR_DEINITIALIZED, ::CUDA_ERROR_NOT_INITIALIZED, ::CUDA_ERROR_INVALID_CONTEXT, ::CUDA_ERROR_INVALID_VALUE, ::CUDA_ERROR_INVALID_HANDLE \notefnerr \note_async \note_null_stream

cuMemcpyDtoHAsync
```
@Cast("CUresult")
public static int cuMemcpyDtoHAsync(Pointer dstHost,
                                    @Cast("CUdeviceptr")
                                    long srcDevice,
                                    @Cast("size_t")
                                    long ByteCount,
                                    CUstream_st hStream)
```
\brief Copies memory from Device to Host Copies from device to host memory. \p dstHost and \p srcDevice specify the base pointers of the destination and source, respectively. \p ByteCount specifies the number of bytes to copy.

Parameters:

dstHost - - Destination host pointer

srcDevice - - Source device pointer

ByteCount - - Size of memory copy in bytes

hStream - - Stream identifier

Returns:

::CUDA_SUCCESS, ::CUDA_ERROR_DEINITIALIZED, ::CUDA_ERROR_NOT_INITIALIZED, ::CUDA_ERROR_INVALID_CONTEXT, ::CUDA_ERROR_INVALID_VALUE, ::CUDA_ERROR_INVALID_HANDLE \notefnerr \note_async \note_null_stream

cuMemcpyDtoDAsync
```
@Cast("CUresult")
public static int cuMemcpyDtoDAsync(@Cast("CUdeviceptr")
                                    long dstDevice,
                                    @Cast("CUdeviceptr")
                                    long srcDevice,
                                    @Cast("size_t")
                                    long ByteCount,
                                    CUstream_st hStream)
```
\brief Copies memory from Device to Device Copies from device memory to device memory. \p dstDevice and \p srcDevice are the base pointers of the destination and source, respectively. \p ByteCount specifies the number of bytes to copy.

Parameters:

dstDevice - - Destination device pointer

srcDevice - - Source device pointer

ByteCount - - Size of memory copy in bytes

hStream - - Stream identifier

Returns:

::CUDA_SUCCESS, ::CUDA_ERROR_DEINITIALIZED, ::CUDA_ERROR_NOT_INITIALIZED, ::CUDA_ERROR_INVALID_CONTEXT, ::CUDA_ERROR_INVALID_VALUE, ::CUDA_ERROR_INVALID_HANDLE \notefnerr \note_async \note_null_stream

cuMemcpyHtoAAsync
```
@Cast("CUresult")
public static int cuMemcpyHtoAAsync(CUarray_st dstArray,
                                    @Cast("size_t")
                                    long dstOffset,
                                    @Const
                                    Pointer srcHost,
                                    @Cast("size_t")
                                    long ByteCount,
                                    CUstream_st hStream)
```
\brief Copies memory from Host to Array Copies from host memory to a 1D CUDA array. \p dstArray and \p dstOffset specify the CUDA array handle and starting offset in bytes of the destination data. \p srcHost specifies the base address of the source. \p ByteCount specifies the number of bytes to copy.

Parameters:

dstArray - - Destination array

dstOffset - - Offset in bytes of destination array

srcHost - - Source host pointer

ByteCount - - Size of memory copy in bytes

hStream - - Stream identifier

Returns:

::CUDA_SUCCESS, ::CUDA_ERROR_DEINITIALIZED, ::CUDA_ERROR_NOT_INITIALIZED, ::CUDA_ERROR_INVALID_CONTEXT, ::CUDA_ERROR_INVALID_VALUE, ::CUDA_ERROR_INVALID_HANDLE \notefnerr \note_async \note_null_stream

cuMemcpyAtoHAsync
```
@Cast("CUresult")
public static int cuMemcpyAtoHAsync(Pointer dstHost,
                                    CUarray_st srcArray,
                                    @Cast("size_t")
                                    long srcOffset,
                                    @Cast("size_t")
                                    long ByteCount,
                                    CUstream_st hStream)
```
\brief Copies memory from Array to Host Copies from one 1D CUDA array to host memory. \p dstHost specifies the base pointer of the destination. \p srcArray and \p srcOffset specify the CUDA array handle and starting offset in bytes of the source data. \p ByteCount specifies the number of bytes to copy.

Parameters:

dstHost - - Destination pointer

srcArray - - Source array

srcOffset - - Offset in bytes of source array

ByteCount - - Size of memory copy in bytes

hStream - - Stream identifier

Returns:

::CUDA_SUCCESS, ::CUDA_ERROR_DEINITIALIZED, ::CUDA_ERROR_NOT_INITIALIZED, ::CUDA_ERROR_INVALID_CONTEXT, ::CUDA_ERROR_INVALID_VALUE, ::CUDA_ERROR_INVALID_HANDLE \notefnerr \note_async \note_null_stream

cuMemcpy2DAsync
```
@Cast("CUresult")
public static int cuMemcpy2DAsync(@Const
                                  CUDA_MEMCPY2D pCopy,
                                  CUstream_st hStream)
```
\brief Copies memory for 2D arrays Perform a 2D memory copy according to the parameters specified in \p pCopy. The ::CUDA_MEMCPY2D structure is defined as:
```
   typedef struct CUDA_MEMCPY2D_st {
      unsigned int srcXInBytes, srcY;
      CUmemorytype srcMemoryType;
      const void *srcHost;
      CUdeviceptr srcDevice;
      CUarray srcArray;
      unsigned int srcPitch;
      unsigned int dstXInBytes, dstY;
      CUmemorytype dstMemoryType;
      void *dstHost;
      CUdeviceptr dstDevice;
      CUarray dstArray;
      unsigned int dstPitch;
      unsigned int WidthInBytes;
      unsigned int Height;
   } CUDA_MEMCPY2D;
 
```
where: - ::srcMemoryType and ::dstMemoryType specify the type of memory of the source and destination, respectively; ::CUmemorytype_enum is defined as:
```
   typedef enum CUmemorytype_enum {
      CU_MEMORYTYPE_HOST = 0x01,
      CU_MEMORYTYPE_DEVICE = 0x02,
      CU_MEMORYTYPE_ARRAY = 0x03,
      CU_MEMORYTYPE_UNIFIED = 0x04
   } CUmemorytype;
 
```
\par If ::srcMemoryType is ::CU_MEMORYTYPE_HOST, ::srcHost and ::srcPitch specify the (host) base address of the source data and the bytes per row to apply. ::srcArray is ignored. \par If ::srcMemoryType is ::CU_MEMORYTYPE_UNIFIED, ::srcDevice and ::srcPitch specify the (unified virtual address space) base address of the source data and the bytes per row to apply. ::srcArray is ignored. This value may be used only if unified addressing is supported in the calling context. \par If ::srcMemoryType is ::CU_MEMORYTYPE_DEVICE, ::srcDevice and ::srcPitch specify the (device) base address of the source data and the bytes per row to apply. ::srcArray is ignored. \par If ::srcMemoryType is ::CU_MEMORYTYPE_ARRAY, ::srcArray specifies the handle of the source data. ::srcHost, ::srcDevice and ::srcPitch are ignored. \par If ::dstMemoryType is ::CU_MEMORYTYPE_UNIFIED, ::dstDevice and ::dstPitch specify the (unified virtual address space) base address of the source data and the bytes per row to apply. ::dstArray is ignored. This value may be used only if unified addressing is supported in the calling context. \par If ::dstMemoryType is ::CU_MEMORYTYPE_HOST, ::dstHost and ::dstPitch specify the (host) base address of the destination data and the bytes per row to apply. ::dstArray is ignored. \par If ::dstMemoryType is ::CU_MEMORYTYPE_DEVICE, ::dstDevice and ::dstPitch specify the (device) base address of the destination data and the bytes per row to apply. ::dstArray is ignored. \par If ::dstMemoryType is ::CU_MEMORYTYPE_ARRAY, ::dstArray specifies the handle of the destination data. ::dstHost, ::dstDevice and ::dstPitch are ignored. - ::srcXInBytes and ::srcY specify the base address of the source data for the copy. \par For host pointers, the starting address is
```
  void* Start = (void*)((char*)srcHost+srcY*srcPitch + srcXInBytes);
 
```
\par For device pointers, the starting address is
```
  CUdeviceptr Start = srcDevice+srcY*srcPitch+srcXInBytes;
 
```
\par For CUDA arrays, ::srcXInBytes must be evenly divisible by the array element size. - ::dstXInBytes and ::dstY specify the base address of the destination data for the copy. \par For host pointers, the base address is
```
  void* dstStart = (void*)((char*)dstHost+dstY*dstPitch + dstXInBytes);
 
```
\par For device pointers, the starting address is
```
  CUdeviceptr dstStart = dstDevice+dstY*dstPitch+dstXInBytes;
 
```
\par For CUDA arrays, ::dstXInBytes must be evenly divisible by the array element size. - ::WidthInBytes and ::Height specify the width (in bytes) and height of the 2D copy being performed. - If specified, ::srcPitch must be greater than or equal to ::WidthInBytes + ::srcXInBytes, and ::dstPitch must be greater than or equal to ::WidthInBytes + dstXInBytes. - If specified, ::srcPitch must be greater than or equal to ::WidthInBytes + ::srcXInBytes, and ::dstPitch must be greater than or equal to ::WidthInBytes + dstXInBytes. - If specified, ::srcHeight must be greater than or equal to ::Height + ::srcY, and ::dstHeight must be greater than or equal to ::Height + ::dstY. \par ::cuMemcpy2DAsync() returns an error if any pitch is greater than the maximum allowed (::CU_DEVICE_ATTRIBUTE_MAX_PITCH). ::cuMemAllocPitch() passes back pitches that always work with ::cuMemcpy2D(). On intra-device memory copies (device to device, CUDA array to device, CUDA array to CUDA array), ::cuMemcpy2DAsync() may fail for pitches not computed by ::cuMemAllocPitch().
Parameters:

pCopy - - Parameters for the memory copy

hStream - - Stream identifier

Returns:

::CUDA_SUCCESS, ::CUDA_ERROR_DEINITIALIZED, ::CUDA_ERROR_NOT_INITIALIZED, ::CUDA_ERROR_INVALID_CONTEXT, ::CUDA_ERROR_INVALID_VALUE, ::CUDA_ERROR_INVALID_HANDLE \notefnerr \note_async \note_null_stream

cuMemcpy3DAsync
```
@Cast("CUresult")
public static int cuMemcpy3DAsync(@Const
                                  CUDA_MEMCPY3D pCopy,
                                  CUstream_st hStream)
```
\brief Copies memory for 3D arrays Perform a 3D memory copy according to the parameters specified in \p pCopy. The ::CUDA_MEMCPY3D structure is defined as:
```
        typedef struct CUDA_MEMCPY3D_st {

            unsigned int srcXInBytes, srcY, srcZ;
            unsigned int srcLOD;
            CUmemorytype srcMemoryType;
                const void *srcHost;
                CUdeviceptr srcDevice;
                CUarray srcArray;
                unsigned int srcPitch;  // ignored when src is array
                unsigned int srcHeight; // ignored when src is array; may be 0 if Depth==1

            unsigned int dstXInBytes, dstY, dstZ;
            unsigned int dstLOD;
            CUmemorytype dstMemoryType;
                void *dstHost;
                CUdeviceptr dstDevice;
                CUarray dstArray;
                unsigned int dstPitch;  // ignored when dst is array
                unsigned int dstHeight; // ignored when dst is array; may be 0 if Depth==1

            unsigned int WidthInBytes;
            unsigned int Height;
            unsigned int Depth;
        } CUDA_MEMCPY3D;
 
```
where: - ::srcMemoryType and ::dstMemoryType specify the type of memory of the source and destination, respectively; ::CUmemorytype_enum is defined as:
```
   typedef enum CUmemorytype_enum {
      CU_MEMORYTYPE_HOST = 0x01,
      CU_MEMORYTYPE_DEVICE = 0x02,
      CU_MEMORYTYPE_ARRAY = 0x03,
      CU_MEMORYTYPE_UNIFIED = 0x04
   } CUmemorytype;
 
```
\par If ::srcMemoryType is ::CU_MEMORYTYPE_UNIFIED, ::srcDevice and ::srcPitch specify the (unified virtual address space) base address of the source data and the bytes per row to apply. ::srcArray is ignored. This value may be used only if unified addressing is supported in the calling context. \par If ::srcMemoryType is ::CU_MEMORYTYPE_HOST, ::srcHost, ::srcPitch and ::srcHeight specify the (host) base address of the source data, the bytes per row, and the height of each 2D slice of the 3D array. ::srcArray is ignored. \par If ::srcMemoryType is ::CU_MEMORYTYPE_DEVICE, ::srcDevice, ::srcPitch and ::srcHeight specify the (device) base address of the source data, the bytes per row, and the height of each 2D slice of the 3D array. ::srcArray is ignored. \par If ::srcMemoryType is ::CU_MEMORYTYPE_ARRAY, ::srcArray specifies the handle of the source data. ::srcHost, ::srcDevice, ::srcPitch and ::srcHeight are ignored. \par If ::dstMemoryType is ::CU_MEMORYTYPE_UNIFIED, ::dstDevice and ::dstPitch specify the (unified virtual address space) base address of the source data and the bytes per row to apply. ::dstArray is ignored. This value may be used only if unified addressing is supported in the calling context. \par If ::dstMemoryType is ::CU_MEMORYTYPE_HOST, ::dstHost and ::dstPitch specify the (host) base address of the destination data, the bytes per row, and the height of each 2D slice of the 3D array. ::dstArray is ignored. \par If ::dstMemoryType is ::CU_MEMORYTYPE_DEVICE, ::dstDevice and ::dstPitch specify the (device) base address of the destination data, the bytes per row, and the height of each 2D slice of the 3D array. ::dstArray is ignored. \par If ::dstMemoryType is ::CU_MEMORYTYPE_ARRAY, ::dstArray specifies the handle of the destination data. ::dstHost, ::dstDevice, ::dstPitch and ::dstHeight are ignored. - ::srcXInBytes, ::srcY and ::srcZ specify the base address of the source data for the copy. \par For host pointers, the starting address is
```
  void* Start = (void*)((char*)srcHost+(srcZ*srcHeight+srcY)*srcPitch + srcXInBytes);
 
```
\par For device pointers, the starting address is
```
  CUdeviceptr Start = srcDevice+(srcZ*srcHeight+srcY)*srcPitch+srcXInBytes;
 
```
\par For CUDA arrays, ::srcXInBytes must be evenly divisible by the array element size. - dstXInBytes, ::dstY and ::dstZ specify the base address of the destination data for the copy. \par For host pointers, the base address is
```
  void* dstStart = (void*)((char*)dstHost+(dstZ*dstHeight+dstY)*dstPitch + dstXInBytes);
 
```
\par For device pointers, the starting address is
```
  CUdeviceptr dstStart = dstDevice+(dstZ*dstHeight+dstY)*dstPitch+dstXInBytes;
 
```
\par For CUDA arrays, ::dstXInBytes must be evenly divisible by the array element size. - ::WidthInBytes, ::Height and ::Depth specify the width (in bytes), height and depth of the 3D copy being performed. - If specified, ::srcPitch must be greater than or equal to ::WidthInBytes + ::srcXInBytes, and ::dstPitch must be greater than or equal to ::WidthInBytes + dstXInBytes. - If specified, ::srcHeight must be greater than or equal to ::Height + ::srcY, and ::dstHeight must be greater than or equal to ::Height + ::dstY. \par ::cuMemcpy3DAsync() returns an error if any pitch is greater than the maximum allowed (::CU_DEVICE_ATTRIBUTE_MAX_PITCH). The ::srcLOD and ::dstLOD members of the ::CUDA_MEMCPY3D structure must be set to 0.
Parameters:

pCopy - - Parameters for the memory copy

hStream - - Stream identifier

Returns:

::CUDA_SUCCESS, ::CUDA_ERROR_DEINITIALIZED, ::CUDA_ERROR_NOT_INITIALIZED, ::CUDA_ERROR_INVALID_CONTEXT, ::CUDA_ERROR_INVALID_VALUE, ::CUDA_ERROR_INVALID_HANDLE \notefnerr \note_async \note_null_stream

cuMemcpy3DPeerAsync
```
@Cast("CUresult")
public static int cuMemcpy3DPeerAsync(@Const
                                      CUDA_MEMCPY3D_PEER pCopy,
                                      CUstream_st hStream)
```
\brief Copies memory between contexts asynchronously. Perform a 3D memory copy according to the parameters specified in \p pCopy. See the definition of the ::CUDA_MEMCPY3D_PEER structure for documentation of its parameters.

Parameters:

pCopy - - Parameters for the memory copy

hStream - - Stream identifier

Returns:

::CUDA_SUCCESS, ::CUDA_ERROR_DEINITIALIZED, ::CUDA_ERROR_NOT_INITIALIZED, ::CUDA_ERROR_INVALID_CONTEXT, ::CUDA_ERROR_INVALID_VALUE \notefnerr \note_async \note_null_stream

cuMemsetD8
```
@Cast("CUresult")
public static int cuMemsetD8(@Cast("CUdeviceptr")
                             long dstDevice,
                             @Cast("unsigned char")
                             byte uc,
                             @Cast("size_t")
                             long N)
```
\brief Initializes device memory Sets the memory range of \p N 8-bit values to the specified value \p uc.

Parameters:

dstDevice - - Destination device pointer

uc - - Value to set

N - - Number of elements

Returns:

::CUDA_SUCCESS, ::CUDA_ERROR_DEINITIALIZED, ::CUDA_ERROR_NOT_INITIALIZED, ::CUDA_ERROR_INVALID_CONTEXT, ::CUDA_ERROR_INVALID_VALUE \notefnerr \note_memset

cuMemsetD16
```
@Cast("CUresult")
public static int cuMemsetD16(@Cast("CUdeviceptr")
                              long dstDevice,
                              @Cast("unsigned short")
                              short us,
                              @Cast("size_t")
                              long N)
```
\brief Initializes device memory Sets the memory range of \p N 16-bit values to the specified value \p us. The \p dstDevice pointer must be two byte aligned.

Parameters:

dstDevice - - Destination device pointer

us - - Value to set

N - - Number of elements

Returns:

::CUDA_SUCCESS, ::CUDA_ERROR_DEINITIALIZED, ::CUDA_ERROR_NOT_INITIALIZED, ::CUDA_ERROR_INVALID_CONTEXT, ::CUDA_ERROR_INVALID_VALUE \notefnerr \note_memset

cuMemsetD32
```
@Cast("CUresult")
public static int cuMemsetD32(@Cast("CUdeviceptr")
                              long dstDevice,
                              @Cast("unsigned int")
                              int ui,
                              @Cast("size_t")
                              long N)
```
\brief Initializes device memory Sets the memory range of \p N 32-bit values to the specified value \p ui. The \p dstDevice pointer must be four byte aligned.

Parameters:

dstDevice - - Destination device pointer

ui - - Value to set

N - - Number of elements

Returns:

::CUDA_SUCCESS, ::CUDA_ERROR_DEINITIALIZED, ::CUDA_ERROR_NOT_INITIALIZED, ::CUDA_ERROR_INVALID_CONTEXT, ::CUDA_ERROR_INVALID_VALUE \notefnerr \note_memset

cuMemsetD2D8
```
@Cast("CUresult")
public static int cuMemsetD2D8(@Cast("CUdeviceptr")
                               long dstDevice,
                               @Cast("size_t")
                               long dstPitch,
                               @Cast("unsigned char")
                               byte uc,
                               @Cast("size_t")
                               long Width,
                               @Cast("size_t")
                               long Height)
```
\brief Initializes device memory Sets the 2D memory range of \p Width 8-bit values to the specified value \p uc. \p Height specifies the number of rows to set, and \p dstPitch specifies the number of bytes between each row. This function performs fastest when the pitch is one that has been passed back by ::cuMemAllocPitch().

Parameters:

dstDevice - - Destination device pointer

dstPitch - - Pitch of destination device pointer

uc - - Value to set

Width - - Width of row

Height - - Number of rows

Returns:

::CUDA_SUCCESS, ::CUDA_ERROR_DEINITIALIZED, ::CUDA_ERROR_NOT_INITIALIZED, ::CUDA_ERROR_INVALID_CONTEXT, ::CUDA_ERROR_INVALID_VALUE \notefnerr \note_memset

cuMemsetD2D16
```
@Cast("CUresult")
public static int cuMemsetD2D16(@Cast("CUdeviceptr")
                                long dstDevice,
                                @Cast("size_t")
                                long dstPitch,
                                @Cast("unsigned short")
                                short us,
                                @Cast("size_t")
                                long Width,
                                @Cast("size_t")
                                long Height)
```
\brief Initializes device memory Sets the 2D memory range of \p Width 16-bit values to the specified value \p us. \p Height specifies the number of rows to set, and \p dstPitch specifies the number of bytes between each row. The \p dstDevice pointer and \p dstPitch offset must be two byte aligned. This function performs fastest when the pitch is one that has been passed back by ::cuMemAllocPitch().

Parameters:

dstDevice - - Destination device pointer

dstPitch - - Pitch of destination device pointer

us - - Value to set

Width - - Width of row

Height - - Number of rows

Returns:

::CUDA_SUCCESS, ::CUDA_ERROR_DEINITIALIZED, ::CUDA_ERROR_NOT_INITIALIZED, ::CUDA_ERROR_INVALID_CONTEXT, ::CUDA_ERROR_INVALID_VALUE \notefnerr \note_memset

cuMemsetD2D32
```
@Cast("CUresult")
public static int cuMemsetD2D32(@Cast("CUdeviceptr")
                                long dstDevice,
                                @Cast("size_t")
                                long dstPitch,
                                @Cast("unsigned int")
                                int ui,
                                @Cast("size_t")
                                long Width,
                                @Cast("size_t")
                                long Height)
```
\brief Initializes device memory Sets the 2D memory range of \p Width 32-bit values to the specified value \p ui. \p Height specifies the number of rows to set, and \p dstPitch specifies the number of bytes between each row. The \p dstDevice pointer and \p dstPitch offset must be four byte aligned. This function performs fastest when the pitch is one that has been passed back by ::cuMemAllocPitch().

Parameters:

dstDevice - - Destination device pointer

dstPitch - - Pitch of destination device pointer

ui - - Value to set

Width - - Width of row

Height - - Number of rows

Returns:

::CUDA_SUCCESS, ::CUDA_ERROR_DEINITIALIZED, ::CUDA_ERROR_NOT_INITIALIZED, ::CUDA_ERROR_INVALID_CONTEXT, ::CUDA_ERROR_INVALID_VALUE \notefnerr \note_memset

cuMemsetD8Async

@Cast("CUresult")
public static int cuMemsetD8Async(@Cast("CUdeviceptr")
                                  long dstDevice,
                                  @Cast("unsigned char")
                                  byte uc,
                                  @Cast("size_t")
                                  long N,
                                  CUstream_st hStream)

\brief Sets device memory Sets the memory range of \p N 8-bit values to the specified value \p uc.

Parameters:: dstDevice - - Destination device pointer; uc - - Value to set; N - - Number of elements; hStream - - Stream identifier
Returns:: ::CUDA_SUCCESS, ::CUDA_ERROR_DEINITIALIZED, ::CUDA_ERROR_NOT_INITIALIZED, ::CUDA_ERROR_INVALID_CONTEXT, ::CUDA_ERROR_INVALID_VALUE \notefnerr \note_memset \note_null_stream

cuMemsetD16Async

@Cast("CUresult")
public static int cuMemsetD16Async(@Cast("CUdeviceptr")
                                   long dstDevice,
                                   @Cast("unsigned short")
                                   short us,
                                   @Cast("size_t")
                                   long N,
                                   CUstream_st hStream)

\brief Sets device memory Sets the memory range of \p N 16-bit values to the specified value \p us. The \p dstDevice pointer must be two byte aligned.

Parameters:: dstDevice - - Destination device pointer; us - - Value to set; N - - Number of elements; hStream - - Stream identifier
Returns:: ::CUDA_SUCCESS, ::CUDA_ERROR_DEINITIALIZED, ::CUDA_ERROR_NOT_INITIALIZED, ::CUDA_ERROR_INVALID_CONTEXT, ::CUDA_ERROR_INVALID_VALUE \notefnerr \note_memset \note_null_stream

cuMemsetD32Async

@Cast("CUresult")
public static int cuMemsetD32Async(@Cast("CUdeviceptr")
                                   long dstDevice,
                                   @Cast("unsigned int")
                                   int ui,
                                   @Cast("size_t")
                                   long N,
                                   CUstream_st hStream)

\brief Sets device memory Sets the memory range of \p N 32-bit values to the specified value \p ui. The \p dstDevice pointer must be four byte aligned.

Parameters:: dstDevice - - Destination device pointer; ui - - Value to set; N - - Number of elements; hStream - - Stream identifier
Returns:: ::CUDA_SUCCESS, ::CUDA_ERROR_DEINITIALIZED, ::CUDA_ERROR_NOT_INITIALIZED, ::CUDA_ERROR_INVALID_CONTEXT, ::CUDA_ERROR_INVALID_VALUE \notefnerr \note_memset \note_null_stream

cuMemsetD2D8Async

@Cast("CUresult")
public static int cuMemsetD2D8Async(@Cast("CUdeviceptr")
                                    long dstDevice,
                                    @Cast("size_t")
                                    long dstPitch,
                                    @Cast("unsigned char")
                                    byte uc,
                                    @Cast("size_t")
                                    long Width,
                                    @Cast("size_t")
                                    long Height,
                                    CUstream_st hStream)

\brief Sets device memory Sets the 2D memory range of \p Width 8-bit values to the specified value \p uc. \p Height specifies the number of rows to set, and \p dstPitch specifies the number of bytes between each row. This function performs fastest when the pitch is one that has been passed back by ::cuMemAllocPitch().

Parameters:: dstDevice - - Destination device pointer; dstPitch - - Pitch of destination device pointer; uc - - Value to set; Width - - Width of row; Height - - Number of rows; hStream - - Stream identifier
Returns:: ::CUDA_SUCCESS, ::CUDA_ERROR_DEINITIALIZED, ::CUDA_ERROR_NOT_INITIALIZED, ::CUDA_ERROR_INVALID_CONTEXT, ::CUDA_ERROR_INVALID_VALUE \notefnerr \note_memset \note_null_stream

cuMemsetD2D16Async

@Cast("CUresult")
public static int cuMemsetD2D16Async(@Cast("CUdeviceptr")
                                     long dstDevice,
                                     @Cast("size_t")
                                     long dstPitch,
                                     @Cast("unsigned short")
                                     short us,
                                     @Cast("size_t")
                                     long Width,
                                     @Cast("size_t")
                                     long Height,
                                     CUstream_st hStream)

\brief Sets device memory Sets the 2D memory range of \p Width 16-bit values to the specified value \p us. \p Height specifies the number of rows to set, and \p dstPitch specifies the number of bytes between each row. The \p dstDevice pointer and \p dstPitch offset must be two byte aligned. This function performs fastest when the pitch is one that has been passed back by ::cuMemAllocPitch().

Parameters:: dstDevice - - Destination device pointer; dstPitch - - Pitch of destination device pointer; us - - Value to set; Width - - Width of row; Height - - Number of rows; hStream - - Stream identifier
Returns:: ::CUDA_SUCCESS, ::CUDA_ERROR_DEINITIALIZED, ::CUDA_ERROR_NOT_INITIALIZED, ::CUDA_ERROR_INVALID_CONTEXT, ::CUDA_ERROR_INVALID_VALUE \notefnerr \note_memset \note_null_stream

cuMemsetD2D32Async

@Cast("CUresult")
public static int cuMemsetD2D32Async(@Cast("CUdeviceptr")
                                     long dstDevice,
                                     @Cast("size_t")
                                     long dstPitch,
                                     @Cast("unsigned int")
                                     int ui,
                                     @Cast("size_t")
                                     long Width,
                                     @Cast("size_t")
                                     long Height,
                                     CUstream_st hStream)

\brief Sets device memory Sets the 2D memory range of \p Width 32-bit values to the specified value \p ui. \p Height specifies the number of rows to set, and \p dstPitch specifies the number of bytes between each row. The \p dstDevice pointer and \p dstPitch offset must be four byte aligned. This function performs fastest when the pitch is one that has been passed back by ::cuMemAllocPitch().

Parameters:: dstDevice - - Destination device pointer; dstPitch - - Pitch of destination device pointer; ui - - Value to set; Width - - Width of row; Height - - Number of rows; hStream - - Stream identifier
Returns:: ::CUDA_SUCCESS, ::CUDA_ERROR_DEINITIALIZED, ::CUDA_ERROR_NOT_INITIALIZED, ::CUDA_ERROR_INVALID_CONTEXT, ::CUDA_ERROR_INVALID_VALUE \notefnerr \note_memset \note_null_stream

cuArrayCreate

@Cast("CUresult")
public static int cuArrayCreate(@ByPtrPtr
                                CUarray_st pHandle,
                                @Const
                                CUDA_ARRAY_DESCRIPTOR pAllocateArray)

\brief Creates a 1D or 2D CUDA array Creates a CUDA array according to the ::CUDA_ARRAY_DESCRIPTOR structure \p pAllocateArray and returns a handle to the new CUDA array in \p *pHandle. The ::CUDA_ARRAY_DESCRIPTOR is defined as:


    typedef struct {
        unsigned int Width;
        unsigned int Height;
        CUarray_format Format;
        unsigned int NumChannels;
    } CUDA_ARRAY_DESCRIPTOR;

where: - \p Width, and \p Height are the width, and height of the CUDA array (in elements); the CUDA array is one-dimensional if height is 0, two-dimensional otherwise; - ::Format specifies the format of the elements; ::CUarray_format is defined as:


    typedef enum CUarray_format_enum {
        CU_AD_FORMAT_UNSIGNED_INT8 = 0x01,
        CU_AD_FORMAT_UNSIGNED_INT16 = 0x02,
        CU_AD_FORMAT_UNSIGNED_INT32 = 0x03,
        CU_AD_FORMAT_SIGNED_INT8 = 0x08,
        CU_AD_FORMAT_SIGNED_INT16 = 0x09,
        CU_AD_FORMAT_SIGNED_INT32 = 0x0a,
        CU_AD_FORMAT_HALF = 0x10,
        CU_AD_FORMAT_FLOAT = 0x20
    } CUarray_format;

- \p NumChannels specifies the number of packed components per CUDA array element; it may be 1, 2, or 4; Here are examples of CUDA array descriptions: Description for a CUDA array of 2048 floats:


    CUDA_ARRAY_DESCRIPTOR desc;
    desc.Format = CU_AD_FORMAT_FLOAT;
    desc.NumChannels = 1;
    desc.Width = 2048;
    desc.Height = 1;

Description for a 64 x 64 CUDA array of floats:


    CUDA_ARRAY_DESCRIPTOR desc;
    desc.Format = CU_AD_FORMAT_FLOAT;
    desc.NumChannels = 1;
    desc.Width = 64;
    desc.Height = 64;

Description for a \p width x \p height CUDA array of 64-bit, 4x16-bit float16's:


    CUDA_ARRAY_DESCRIPTOR desc;
    desc.FormatFlags = CU_AD_FORMAT_HALF;
    desc.NumChannels = 4;
    desc.Width = width;
    desc.Height = height;

Description for a \p width x \p height CUDA array of 16-bit elements, each of which is two 8-bit unsigned chars:


    CUDA_ARRAY_DESCRIPTOR arrayDesc;
    desc.FormatFlags = CU_AD_FORMAT_UNSIGNED_INT8;
    desc.NumChannels = 2;
    desc.Width = width;
    desc.Height = height;

Parameters:: pHandle - - Returned array; pAllocateArray - - Array descriptor
Returns:: ::CUDA_SUCCESS, ::CUDA_ERROR_DEINITIALIZED, ::CUDA_ERROR_NOT_INITIALIZED, ::CUDA_ERROR_INVALID_CONTEXT, ::CUDA_ERROR_INVALID_VALUE, ::CUDA_ERROR_OUT_OF_MEMORY, ::CUDA_ERROR_UNKNOWN \notefnerr

cuArrayGetDescriptor
```
@Cast("CUresult")
public static int cuArrayGetDescriptor(CUDA_ARRAY_DESCRIPTOR pArrayDescriptor,
                                       CUarray_st hArray)
```
\brief Get a 1D or 2D CUDA array descriptor Returns in \p *pArrayDescriptor a descriptor containing information on the format and dimensions of the CUDA array \p hArray. It is useful for subroutines that have been passed a CUDA array, but need to know the CUDA array parameters for validation or other purposes.

Parameters:

pArrayDescriptor - - Returned array descriptor

hArray - - Array to get descriptor of

Returns:

::CUDA_SUCCESS, ::CUDA_ERROR_DEINITIALIZED, ::CUDA_ERROR_NOT_INITIALIZED, ::CUDA_ERROR_INVALID_CONTEXT, ::CUDA_ERROR_INVALID_VALUE, ::CUDA_ERROR_INVALID_HANDLE \notefnerr

cuArrayDestroy
```
@Cast("CUresult")
public static int cuArrayDestroy(CUarray_st hArray)
```
\brief Destroys a CUDA array Destroys the CUDA array \p hArray.

Parameters:

hArray - - Array to destroy

Returns:

::CUDA_SUCCESS, ::CUDA_ERROR_DEINITIALIZED, ::CUDA_ERROR_NOT_INITIALIZED, ::CUDA_ERROR_INVALID_CONTEXT, ::CUDA_ERROR_INVALID_HANDLE, ::CUDA_ERROR_ARRAY_IS_MAPPED, ::CUDA_ERROR_CONTEXT_IS_DESTROYED \notefnerr

cuArray3DCreate

@Cast("CUresult")
public static int cuArray3DCreate(@ByPtrPtr
                                  CUarray_st pHandle,
                                  @Const
                                  CUDA_ARRAY3D_DESCRIPTOR pAllocateArray)

\brief Creates a 3D CUDA array Creates a CUDA array according to the ::CUDA_ARRAY3D_DESCRIPTOR structure \p pAllocateArray and returns a handle to the new CUDA array in \p *pHandle. The ::CUDA_ARRAY3D_DESCRIPTOR is defined as:


    typedef struct {
        unsigned int Width;
        unsigned int Height;
        unsigned int Depth;
        CUarray_format Format;
        unsigned int NumChannels;
        unsigned int Flags;
    } CUDA_ARRAY3D_DESCRIPTOR;

where: - \p Width, \p Height, and \p Depth are the width, height, and depth of the CUDA array (in elements); the following types of CUDA arrays can be allocated: - A 1D array is allocated if \p Height and \p Depth extents are both zero. - A 2D array is allocated if only \p Depth extent is zero. - A 3D array is allocated if all three extents are non-zero. - A 1D layered CUDA array is allocated if only \p Height is zero and the ::CUDA_ARRAY3D_LAYERED flag is set. Each layer is a 1D array. The number of layers is determined by the depth extent. - A 2D layered CUDA array is allocated if all three extents are non-zero and the ::CUDA_ARRAY3D_LAYERED flag is set. Each layer is a 2D array. The number of layers is determined by the depth extent. - A cubemap CUDA array is allocated if all three extents are non-zero and the ::CUDA_ARRAY3D_CUBEMAP flag is set. \p Width must be equal to \p Height, and \p Depth must be six. A cubemap is a special type of 2D layered CUDA array, where the six layers represent the six faces of a cube. The order of the six layers in memory is the same as that listed in ::CUarray_cubemap_face. - A cubemap layered CUDA array is allocated if all three extents are non-zero, and both, ::CUDA_ARRAY3D_CUBEMAP and ::CUDA_ARRAY3D_LAYERED flags are set. \p Width must be equal to \p Height, and \p Depth must be a multiple of six. A cubemap layered CUDA array is a special type of 2D layered CUDA array that consists of a collection of cubemaps. The first six layers represent the first cubemap, the next six layers form the second cubemap, and so on. - ::Format specifies the format of the elements; ::CUarray_format is defined as:


    typedef enum CUarray_format_enum {
        CU_AD_FORMAT_UNSIGNED_INT8 = 0x01,
        CU_AD_FORMAT_UNSIGNED_INT16 = 0x02,
        CU_AD_FORMAT_UNSIGNED_INT32 = 0x03,
        CU_AD_FORMAT_SIGNED_INT8 = 0x08,
        CU_AD_FORMAT_SIGNED_INT16 = 0x09,
        CU_AD_FORMAT_SIGNED_INT32 = 0x0a,
        CU_AD_FORMAT_HALF = 0x10,
        CU_AD_FORMAT_FLOAT = 0x20
    } CUarray_format;

- \p NumChannels specifies the number of packed components per CUDA array element; it may be 1, 2, or 4; - ::Flags may be set to - ::CUDA_ARRAY3D_LAYERED to enable creation of layered CUDA arrays. If this flag is set, \p Depth specifies the number of layers, not the depth of a 3D array. - ::CUDA_ARRAY3D_SURFACE_LDST to enable surface references to be bound to the CUDA array. If this flag is not set, ::cuSurfRefSetArray will fail when attempting to bind the CUDA array to a surface reference. - ::CUDA_ARRAY3D_CUBEMAP to enable creation of cubemaps. If this flag is set, \p Width must be equal to \p Height, and \p Depth must be six. If the ::CUDA_ARRAY3D_LAYERED flag is also set, then \p Depth must be a multiple of six. - ::CUDA_ARRAY3D_TEXTURE_GATHER to indicate that the CUDA array will be used for texture gather. Texture gather can only be performed on 2D CUDA arrays. \p Width, \p Height and \p Depth must meet certain size requirements as listed in the following table. All values are specified in elements. Note that for brevity's sake, the full name of the device attribute is not specified. For ex., TEXTURE1D_WIDTH refers to the device attribute ::CU_DEVICE_ATTRIBUTE_MAXIMUM_TEXTURE1D_WIDTH. Note that 2D CUDA arrays have different size requirements if the ::CUDA_ARRAY3D_TEXTURE_GATHER flag is set. \p Width and \p Height must not be greater than ::CU_DEVICE_ATTRIBUTE_MAXIMUM_TEXTURE2D_GATHER_WIDTH and ::CU_DEVICE_ATTRIBUTE_MAXIMUM_TEXTURE2D_GATHER_HEIGHT respectively, in that case.

CUDA array type	Valid extents that must always be met {(width range in elements), (height range), (depth range)}	Valid extents with CUDA_ARRAY3D_SURFACE_LDST set {(width range in elements), (height range), (depth range)}
1D	{ (1,TEXTURE1D_WIDTH), 0, 0 }	{ (1,SURFACE1D_WIDTH), 0, 0 }
2D	{ (1,TEXTURE2D_WIDTH), (1,TEXTURE2D_HEIGHT), 0 }	{ (1,SURFACE2D_WIDTH), (1,SURFACE2D_HEIGHT), 0 }
3D	{ (1,TEXTURE3D_WIDTH), (1,TEXTURE3D_HEIGHT), (1,TEXTURE3D_DEPTH) } OR { (1,TEXTURE3D_WIDTH_ALTERNATE), (1,TEXTURE3D_HEIGHT_ALTERNATE), (1,TEXTURE3D_DEPTH_ALTERNATE) }	{ (1,SURFACE3D_WIDTH), (1,SURFACE3D_HEIGHT), (1,SURFACE3D_DEPTH) }
1D Layered	{ (1,TEXTURE1D_LAYERED_WIDTH), 0, (1,TEXTURE1D_LAYERED_LAYERS) }	{ (1,SURFACE1D_LAYERED_WIDTH), 0, (1,SURFACE1D_LAYERED_LAYERS) }
2D Layered	{ (1,TEXTURE2D_LAYERED_WIDTH), (1,TEXTURE2D_LAYERED_HEIGHT), (1,TEXTURE2D_LAYERED_LAYERS) }	{ (1,SURFACE2D_LAYERED_WIDTH), (1,SURFACE2D_LAYERED_HEIGHT), (1,SURFACE2D_LAYERED_LAYERS) }
Cubemap	{ (1,TEXTURECUBEMAP_WIDTH), (1,TEXTURECUBEMAP_WIDTH), 6 }	{ (1,SURFACECUBEMAP_WIDTH), (1,SURFACECUBEMAP_WIDTH), 6 }
Cubemap Layered	{ (1,TEXTURECUBEMAP_LAYERED_WIDTH), (1,TEXTURECUBEMAP_LAYERED_WIDTH), (1,TEXTURECUBEMAP_LAYERED_LAYERS) }	{ (1,SURFACECUBEMAP_LAYERED_WIDTH), (1,SURFACECUBEMAP_LAYERED_WIDTH), (1,SURFACECUBEMAP_LAYERED_LAYERS) }

Here are examples of CUDA array descriptions: Description for a CUDA array of 2048 floats:


    CUDA_ARRAY3D_DESCRIPTOR desc;
    desc.Format = CU_AD_FORMAT_FLOAT;
    desc.NumChannels = 1;
    desc.Width = 2048;
    desc.Height = 0;
    desc.Depth = 0;

Description for a 64 x 64 CUDA array of floats:


    CUDA_ARRAY3D_DESCRIPTOR desc;
    desc.Format = CU_AD_FORMAT_FLOAT;
    desc.NumChannels = 1;
    desc.Width = 64;
    desc.Height = 64;
    desc.Depth = 0;

Description for a \p width x \p height x \p depth CUDA array of 64-bit, 4x16-bit float16's:


    CUDA_ARRAY3D_DESCRIPTOR desc;
    desc.FormatFlags = CU_AD_FORMAT_HALF;
    desc.NumChannels = 4;
    desc.Width = width;
    desc.Height = height;
    desc.Depth = depth;

Parameters:: pHandle - - Returned array; pAllocateArray - - 3D array descriptor
Returns:: ::CUDA_SUCCESS, ::CUDA_ERROR_DEINITIALIZED, ::CUDA_ERROR_NOT_INITIALIZED, ::CUDA_ERROR_INVALID_CONTEXT, ::CUDA_ERROR_INVALID_VALUE, ::CUDA_ERROR_OUT_OF_MEMORY, ::CUDA_ERROR_UNKNOWN \notefnerr

cuArray3DGetDescriptor
```
@Cast("CUresult")
public static int cuArray3DGetDescriptor(CUDA_ARRAY3D_DESCRIPTOR pArrayDescriptor,
                                         CUarray_st hArray)
```
\brief Get a 3D CUDA array descriptor Returns in \p *pArrayDescriptor a descriptor containing information on the format and dimensions of the CUDA array \p hArray. It is useful for subroutines that have been passed a CUDA array, but need to know the CUDA array parameters for validation or other purposes. This function may be called on 1D and 2D arrays, in which case the \p Height and/or \p Depth members of the descriptor struct will be set to 0.

Parameters:

pArrayDescriptor - - Returned 3D array descriptor

hArray - - 3D array to get descriptor of

Returns:

::CUDA_SUCCESS, ::CUDA_ERROR_DEINITIALIZED, ::CUDA_ERROR_NOT_INITIALIZED, ::CUDA_ERROR_INVALID_CONTEXT, ::CUDA_ERROR_INVALID_VALUE, ::CUDA_ERROR_INVALID_HANDLE, ::CUDA_ERROR_CONTEXT_IS_DESTROYED \notefnerr

cuMipmappedArrayCreate

@Cast("CUresult")
public static int cuMipmappedArrayCreate(@ByPtrPtr
                                         CUmipmappedArray_st pHandle,
                                         @Const
                                         CUDA_ARRAY3D_DESCRIPTOR pMipmappedArrayDesc,
                                         @Cast("unsigned int")
                                         int numMipmapLevels)

\brief Creates a CUDA mipmapped array Creates a CUDA mipmapped array according to the ::CUDA_ARRAY3D_DESCRIPTOR structure \p pMipmappedArrayDesc and returns a handle to the new CUDA mipmapped array in \p *pHandle. \p numMipmapLevels specifies the number of mipmap levels to be allocated. This value is clamped to the range [1, 1 + floor(log2(max(width, height, depth)))]. The ::CUDA_ARRAY3D_DESCRIPTOR is defined as:


    typedef struct {
        unsigned int Width;
        unsigned int Height;
        unsigned int Depth;
        CUarray_format Format;
        unsigned int NumChannels;
        unsigned int Flags;
    } CUDA_ARRAY3D_DESCRIPTOR;

where: - \p Width, \p Height, and \p Depth are the width, height, and depth of the CUDA array (in elements); the following types of CUDA arrays can be allocated: - A 1D mipmapped array is allocated if \p Height and \p Depth extents are both zero. - A 2D mipmapped array is allocated if only \p Depth extent is zero. - A 3D mipmapped array is allocated if all three extents are non-zero. - A 1D layered CUDA mipmapped array is allocated if only \p Height is zero and the ::CUDA_ARRAY3D_LAYERED flag is set. Each layer is a 1D array. The number of layers is determined by the depth extent. - A 2D layered CUDA mipmapped array is allocated if all three extents are non-zero and the ::CUDA_ARRAY3D_LAYERED flag is set. Each layer is a 2D array. The number of layers is determined by the depth extent. - A cubemap CUDA mipmapped array is allocated if all three extents are non-zero and the ::CUDA_ARRAY3D_CUBEMAP flag is set. \p Width must be equal to \p Height, and \p Depth must be six. A cubemap is a special type of 2D layered CUDA array, where the six layers represent the six faces of a cube. The order of the six layers in memory is the same as that listed in ::CUarray_cubemap_face. - A cubemap layered CUDA mipmapped array is allocated if all three extents are non-zero, and both, ::CUDA_ARRAY3D_CUBEMAP and ::CUDA_ARRAY3D_LAYERED flags are set. \p Width must be equal to \p Height, and \p Depth must be a multiple of six. A cubemap layered CUDA array is a special type of 2D layered CUDA array that consists of a collection of cubemaps. The first six layers represent the first cubemap, the next six layers form the second cubemap, and so on. - ::Format specifies the format of the elements; ::CUarray_format is defined as:


    typedef enum CUarray_format_enum {
        CU_AD_FORMAT_UNSIGNED_INT8 = 0x01,
        CU_AD_FORMAT_UNSIGNED_INT16 = 0x02,
        CU_AD_FORMAT_UNSIGNED_INT32 = 0x03,
        CU_AD_FORMAT_SIGNED_INT8 = 0x08,
        CU_AD_FORMAT_SIGNED_INT16 = 0x09,
        CU_AD_FORMAT_SIGNED_INT32 = 0x0a,
        CU_AD_FORMAT_HALF = 0x10,
        CU_AD_FORMAT_FLOAT = 0x20
    } CUarray_format;

- \p NumChannels specifies the number of packed components per CUDA array element; it may be 1, 2, or 4; - ::Flags may be set to - ::CUDA_ARRAY3D_LAYERED to enable creation of layered CUDA mipmapped arrays. If this flag is set, \p Depth specifies the number of layers, not the depth of a 3D array. - ::CUDA_ARRAY3D_SURFACE_LDST to enable surface references to be bound to individual mipmap levels of the CUDA mipmapped array. If this flag is not set, ::cuSurfRefSetArray will fail when attempting to bind a mipmap level of the CUDA mipmapped array to a surface reference. - ::CUDA_ARRAY3D_CUBEMAP to enable creation of mipmapped cubemaps. If this flag is set, \p Width must be equal to \p Height, and \p Depth must be six. If the ::CUDA_ARRAY3D_LAYERED flag is also set, then \p Depth must be a multiple of six. - ::CUDA_ARRAY3D_TEXTURE_GATHER to indicate that the CUDA mipmapped array will be used for texture gather. Texture gather can only be performed on 2D CUDA mipmapped arrays. \p Width, \p Height and \p Depth must meet certain size requirements as listed in the following table. All values are specified in elements. Note that for brevity's sake, the full name of the device attribute is not specified. For ex., TEXTURE1D_MIPMAPPED_WIDTH refers to the device attribute ::CU_DEVICE_ATTRIBUTE_MAXIMUM_TEXTURE1D_MIPMAPPED_WIDTH.

CUDA array type	Valid extents that must always be met {(width range in elements), (height range), (depth range)}	Valid extents with CUDA_ARRAY3D_SURFACE_LDST set {(width range in elements), (height range), (depth range)}
1D	{ (1,TEXTURE1D_MIPMAPPED_WIDTH), 0, 0 }	{ (1,SURFACE1D_WIDTH), 0, 0 }
2D	{ (1,TEXTURE2D_MIPMAPPED_WIDTH), (1,TEXTURE2D_MIPMAPPED_HEIGHT), 0 }	{ (1,SURFACE2D_WIDTH), (1,SURFACE2D_HEIGHT), 0 }
3D	{ (1,TEXTURE3D_WIDTH), (1,TEXTURE3D_HEIGHT), (1,TEXTURE3D_DEPTH) } OR { (1,TEXTURE3D_WIDTH_ALTERNATE), (1,TEXTURE3D_HEIGHT_ALTERNATE), (1,TEXTURE3D_DEPTH_ALTERNATE) }	{ (1,SURFACE3D_WIDTH), (1,SURFACE3D_HEIGHT), (1,SURFACE3D_DEPTH) }
1D Layered	{ (1,TEXTURE1D_LAYERED_WIDTH), 0, (1,TEXTURE1D_LAYERED_LAYERS) }	{ (1,SURFACE1D_LAYERED_WIDTH), 0, (1,SURFACE1D_LAYERED_LAYERS) }
2D Layered	{ (1,TEXTURE2D_LAYERED_WIDTH), (1,TEXTURE2D_LAYERED_HEIGHT), (1,TEXTURE2D_LAYERED_LAYERS) }	{ (1,SURFACE2D_LAYERED_WIDTH), (1,SURFACE2D_LAYERED_HEIGHT), (1,SURFACE2D_LAYERED_LAYERS) }
Cubemap	{ (1,TEXTURECUBEMAP_WIDTH), (1,TEXTURECUBEMAP_WIDTH), 6 }	{ (1,SURFACECUBEMAP_WIDTH), (1,SURFACECUBEMAP_WIDTH), 6 }
Cubemap Layered	{ (1,TEXTURECUBEMAP_LAYERED_WIDTH), (1,TEXTURECUBEMAP_LAYERED_WIDTH), (1,TEXTURECUBEMAP_LAYERED_LAYERS) }	{ (1,SURFACECUBEMAP_LAYERED_WIDTH), (1,SURFACECUBEMAP_LAYERED_WIDTH), (1,SURFACECUBEMAP_LAYERED_LAYERS) }

Parameters:: pHandle - - Returned mipmapped array; pMipmappedArrayDesc - - mipmapped array descriptor; numMipmapLevels - - Number of mipmap levels
Returns:: ::CUDA_SUCCESS, ::CUDA_ERROR_DEINITIALIZED, ::CUDA_ERROR_NOT_INITIALIZED, ::CUDA_ERROR_INVALID_CONTEXT, ::CUDA_ERROR_INVALID_VALUE, ::CUDA_ERROR_OUT_OF_MEMORY, ::CUDA_ERROR_UNKNOWN \notefnerr

cuMipmappedArrayGetLevel
```
@Cast("CUresult")
public static int cuMipmappedArrayGetLevel(@ByPtrPtr
                                           CUarray_st pLevelArray,
                                           CUmipmappedArray_st hMipmappedArray,
                                           @Cast("unsigned int")
                                           int level)
```
\brief Gets a mipmap level of a CUDA mipmapped array Returns in \p *pLevelArray a CUDA array that represents a single mipmap level of the CUDA mipmapped array \p hMipmappedArray. If \p level is greater than the maximum number of levels in this mipmapped array, ::CUDA_ERROR_INVALID_VALUE is returned.

Parameters:

pLevelArray - - Returned mipmap level CUDA array

hMipmappedArray - - CUDA mipmapped array

level - - Mipmap level

Returns:

::CUDA_SUCCESS, ::CUDA_ERROR_DEINITIALIZED, ::CUDA_ERROR_NOT_INITIALIZED, ::CUDA_ERROR_INVALID_CONTEXT, ::CUDA_ERROR_INVALID_VALUE, ::CUDA_ERROR_INVALID_HANDLE \notefnerr

cuMipmappedArrayDestroy
```
@Cast("CUresult")
public static int cuMipmappedArrayDestroy(CUmipmappedArray_st hMipmappedArray)
```
\brief Destroys a CUDA mipmapped array Destroys the CUDA mipmapped array \p hMipmappedArray.

Parameters:

hMipmappedArray - - Mipmapped array to destroy

Returns:

::CUDA_SUCCESS, ::CUDA_ERROR_DEINITIALIZED, ::CUDA_ERROR_NOT_INITIALIZED, ::CUDA_ERROR_INVALID_CONTEXT, ::CUDA_ERROR_INVALID_HANDLE, ::CUDA_ERROR_ARRAY_IS_MAPPED, ::CUDA_ERROR_CONTEXT_IS_DESTROYED \notefnerr

cuMemAddressReserve
```
@Cast("CUresult")
public static int cuMemAddressReserve(@Cast("CUdeviceptr*")
                                      LongPointer ptr,
                                      @Cast("size_t")
                                      long size,
                                      @Cast("size_t")
                                      long alignment,
                                      @Cast("CUdeviceptr")
                                      long addr,
                                      @Cast("unsigned long long")
                                      long flags)
```
\brief Allocate an address range reservation. Reserves a virtual address range based on the given parameters, giving the starting address of the range in \p ptr. This API requires a system that supports UVA. The size and address parameters must be a multiple of the host page size and the alignment must be a power of two or zero for default alignment.

Parameters:

ptr - [out] - Resulting pointer to start of virtual address range allocated

size - [in] - Size of the reserved virtual address range requested

alignment - [in] - Alignment of the reserved virtual address range requested

addr - [in] - Fixed starting address range requested

flags - [in] - Currently unused, must be zero

Returns:

::CUDA_SUCCESS, ::CUDA_ERROR_INVALID_VALUE, ::CUDA_ERROR_OUT_OF_MEMORY, ::CUDA_ERROR_NOT_INITIALIZED, ::CUDA_ERROR_DEINITIALIZED, ::CUDA_ERROR_NOT_PERMITTED, ::CUDA_ERROR_NOT_SUPPORTED

cuMemAddressReserve

@Cast("CUresult")
public static int cuMemAddressReserve(@Cast("CUdeviceptr*")
                                      LongBuffer ptr,
                                      @Cast("size_t")
                                      long size,
                                      @Cast("size_t")
                                      long alignment,
                                      @Cast("CUdeviceptr")
                                      long addr,
                                      @Cast("unsigned long long")
                                      long flags)

cuMemAddressReserve

@Cast("CUresult")
public static int cuMemAddressReserve(@Cast("CUdeviceptr*")
                                      long[] ptr,
                                      @Cast("size_t")
                                      long size,
                                      @Cast("size_t")
                                      long alignment,
                                      @Cast("CUdeviceptr")
                                      long addr,
                                      @Cast("unsigned long long")
                                      long flags)

cuMemAddressFree
```
@Cast("CUresult")
public static int cuMemAddressFree(@Cast("CUdeviceptr")
                                   long ptr,
                                   @Cast("size_t")
                                   long size)
```
\brief Free an address range reservation. Frees a virtual address range reserved by cuMemAddressReserve. The size must match what was given to memAddressReserve and the ptr given must match what was returned from memAddressReserve.

Parameters:

ptr - [in] - Starting address of the virtual address range to free

size - [in] - Size of the virtual address region to free

Returns:

::CUDA_SUCCESS, ::CUDA_ERROR_INVALID_VALUE, ::CUDA_ERROR_NOT_INITIALIZED, ::CUDA_ERROR_DEINITIALIZED, ::CUDA_ERROR_NOT_PERMITTED, ::CUDA_ERROR_NOT_SUPPORTED

cuMemCreate
```
@Cast("CUresult")
public static int cuMemCreate(@Cast("CUmemGenericAllocationHandle*")
                              LongPointer handle,
                              @Cast("size_t")
                              long size,
                              @Const
                              CUmemAllocationProp prop,
                              @Cast("unsigned long long")
                              long flags)
```
\brief Create a shareable memory handle representing a memory allocation of a given size described by the given properties This creates a memory allocation on the target device specified through the \p prop strcuture. The created allocation will not have any device or host mappings. The generic memory \p handle for the allocation can be mapped to the address space of calling process via ::cuMemMap. This handle cannot be transmitted directly to other processes (see ::cuMemExportToShareableHandle). On Windows, the caller must also pass an LPSECURITYATTRIBUTE in \p prop to be associated with this handle which limits or allows access to this handle for a recepient process (see ::CUmemAllocationProp::win32HandleMetaData for more). The \p size of this allocation must be a multiple of the the value given via ::cuMemGetAllocationGranularity with the ::CU_MEM_ALLOC_GRANULARITY_MINIMUM flag.

Parameters:

handle - [out] - Value of handle returned. All operations on this allocation are to be performed using this handle.

size - [in] - Size of the allocation requested

prop - [in] - Properties of the allocation to create.

flags - [in] - flags for future use, must be zero now.

Returns:

::CUDA_SUCCESS, ::CUDA_ERROR_INVALID_VALUE, ::CUDA_ERROR_OUT_OF_MEMORY, ::CUDA_ERROR_INVALID_DEVICE, ::CUDA_ERROR_NOT_INITIALIZED, ::CUDA_ERROR_DEINITIALIZED, ::CUDA_ERROR_NOT_PERMITTED, ::CUDA_ERROR_NOT_SUPPORTED \notefnerr

cuMemCreate

@Cast("CUresult")
public static int cuMemCreate(@Cast("CUmemGenericAllocationHandle*")
                              LongBuffer handle,
                              @Cast("size_t")
                              long size,
                              @Const
                              CUmemAllocationProp prop,
                              @Cast("unsigned long long")
                              long flags)

cuMemCreate

@Cast("CUresult")
public static int cuMemCreate(@Cast("CUmemGenericAllocationHandle*")
                              long[] handle,
                              @Cast("size_t")
                              long size,
                              @Const
                              CUmemAllocationProp prop,
                              @Cast("unsigned long long")
                              long flags)

cuMemRelease
```
@Cast("CUresult")
public static int cuMemRelease(@Cast("CUmemGenericAllocationHandle")
                               long handle)
```
\brief Release a memory handle representing a memory allocation which was previously allocated through cuMemCreate. Frees the memory that was allocated on a device through cuMemCreate. The memory allocation will be freed when all outstanding mappings to the memory are unmapped and when all outstanding references to the handle (including it's shareable counterparts) are also released. The generic memory handle can be freed when there are still outstanding mappings made with this handle. Each time a recepient process imports a shareable handle, it needs to pair it with ::cuMemRelease for the handle to be freed. If \p handle is not a valid handle the behavior is undefined.

Parameters:

handle - [in] Value of handle which was returned previously by cuMemCreate.

Returns:

::CUDA_SUCCESS, ::CUDA_ERROR_INVALID_VALUE, ::CUDA_ERROR_NOT_INITIALIZED, ::CUDA_ERROR_DEINITIALIZED, ::CUDA_ERROR_NOT_PERMITTED, ::CUDA_ERROR_NOT_SUPPORTED \notefnerr

cuMemMap
```
@Cast("CUresult")
public static int cuMemMap(@Cast("CUdeviceptr")
                           long ptr,
                           @Cast("size_t")
                           long size,
                           @Cast("size_t")
                           long offset,
                           @Cast("CUmemGenericAllocationHandle")
                           long handle,
                           @Cast("unsigned long long")
                           long flags)
```
\brief Maps an allocation handle to a reserved virtual address range. Maps bytes of memory represented by \p handle starting from byte \p offset to \p size to address range [\p addr, \p addr + \p size]. This range must be an address reservation previously reserved with ::cuMemAddressReserve, and \p offset + \p size must be less than the size of the memory allocation. Both \p ptr, \p size, and \p offset must be a multiple of the value given via ::cuMemGetAllocationGranularity with the ::CU_MEM_ALLOC_GRANULARITY_MINIMUM flag. Please note calling ::cuMemMap does not make the address accessible, the caller needs to update accessibility of a contiguous mapped VA range by calling ::cuMemSetAccess. Once a recipient process obtains a shareable memory handle from ::cuMemImportFromShareableHandle, the process must use ::cuMemMap to map the memory into its address ranges before setting accessibility with ::cuMemSetAccess. ::cuMemMap can only create mappings on VA range reservations that are not currently mapped.

Parameters:

ptr - [in] - Address where memory will be mapped.

size - [in] - Size of the memory mapping.

offset - [in] - Offset into the memory represented by - \p handle from which to start mapping - Note: currently must be zero.

handle - [in] - Handle to a shareable memory

flags - [in] - flags for future use, must be zero now.

Returns:

::CUDA_SUCCESS, ::CUDA_ERROR_INVALID_VALUE, ::CUDA_ERROR_INVALID_DEVICE, ::CUDA_ERROR_OUT_OF_MEMORY, ::CUDA_ERROR_NOT_INITIALIZED, ::CUDA_ERROR_DEINITIALIZED, ::CUDA_ERROR_NOT_PERMITTED, ::CUDA_ERROR_NOT_SUPPORTED \notefnerr

cuMemUnmap
```
@Cast("CUresult")
public static int cuMemUnmap(@Cast("CUdeviceptr")
                             long ptr,
                             @Cast("size_t")
                             long size)
```
\brief Unmap the backing memory of a given address range. The range must be the entire contiguous address range that was mapped to. In other words, ::cuMemUnmap cannot unmap a sub-range of an address range mapped by ::cuMemCreate / ::cuMemMap. Any backing memory allocations will be freed if there are no existing mappings and there are no unreleased memory handles. When ::cuMemUnmap returns successfully the address range is converted to an address reservation and can be used for a future calls to ::cuMemMap. Any new mapping to this virtual address will need to have access granted through ::cuMemSetAccess, as all mappings start with no accessibility setup.

Parameters:

ptr - [in] - Starting address for the virtual address range to unmap

size - [in] - Size of the virtual address range to unmap

Returns:

::CUDA_SUCCESS, ::CUDA_ERROR_INVALID_VALUE, ::CUDA_ERROR_NOT_INITIALIZED, ::CUDA_ERROR_DEINITIALIZED, ::CUDA_ERROR_NOT_PERMITTED, ::CUDA_ERROR_NOT_SUPPORTED \notefnerr \note_sync

cuMemSetAccess
```
@Cast("CUresult")
public static int cuMemSetAccess(@Cast("CUdeviceptr")
                                 long ptr,
                                 @Cast("size_t")
                                 long size,
                                 @Const
                                 CUmemAccessDesc desc,
                                 @Cast("size_t")
                                 long count)
```
\brief Set the access flags for each location specified in \p desc for the given virtual address range Given the virtual address range via \p ptr and \p size, and the locations in the array given by \p desc and \p count, set the access flags for the target locations. The range must be a fully mapped address range containing all allocations created by ::cuMemMap / ::cuMemCreate.

Parameters:

ptr - [in] - Starting address for the virtual address range

size - [in] - Length of the virtual address range

desc - [in] - Array of ::CUmemAccessDesc that describe how to change the - mapping for each location specified

count - [in] - Number of ::CUmemAccessDesc in \p desc

Returns:

::CUDA_SUCCESS, ::CUDA_ERROR_INVALID_VALUE, ::CUDA_ERROR_INVALID_DEVICE, ::CUDA_ERROR_NOT_SUPPORTED \notefnerr \note_sync

cuMemGetAccess

@Cast("CUresult")
public static int cuMemGetAccess(@Cast("unsigned long long*")
                                 LongPointer flags,
                                 @Const
                                 CUmemLocation location,
                                 @Cast("CUdeviceptr")
                                 long ptr)

\brief Get the access \p flags set for the given \p location and \p ptr

Parameters:: flags - [out] - Flags set for this location; location - [in] - Location in which to check the flags for; ptr - [in] - Address in which to check the access flags for
Returns:: ::CUDA_SUCCESS, ::CUDA_ERROR_INVALID_VALUE, ::CUDA_ERROR_INVALID_DEVICE, ::CUDA_ERROR_NOT_INITIALIZED, ::CUDA_ERROR_DEINITIALIZED, ::CUDA_ERROR_NOT_PERMITTED, ::CUDA_ERROR_NOT_SUPPORTED

cuMemGetAccess

@Cast("CUresult")
public static int cuMemGetAccess(@Cast("unsigned long long*")
                                 LongBuffer flags,
                                 @Const
                                 CUmemLocation location,
                                 @Cast("CUdeviceptr")
                                 long ptr)

cuMemGetAccess

@Cast("CUresult")
public static int cuMemGetAccess(@Cast("unsigned long long*")
                                 long[] flags,
                                 @Const
                                 CUmemLocation location,
                                 @Cast("CUdeviceptr")
                                 long ptr)

cuMemExportToShareableHandle
```
@Cast("CUresult")
public static int cuMemExportToShareableHandle(Pointer shareableHandle,
                                               @Cast("CUmemGenericAllocationHandle")
                                               long handle,
                                               @Cast("CUmemAllocationHandleType")
                                               int handleType,
                                               @Cast("unsigned long long")
                                               long flags)
```
\brief Exports an allocation to a requested shareable handle type Given a CUDA memory handle, create a shareable memory allocation handle that can be used to share the memory with other processes. The recipient process can convert the shareable handle back into a CUDA memory handle using ::cuMemImportFromShareableHandle and map it with ::cuMemMap. The implementation of what this handle is and how it can be transferred is defined by the requested handle type in \p handleType Once all shareable handles are closed and the allocation is released, the allocated memory referenced will be released back to the OS and uses of the CUDA handle afterward will lead to undefined behavior. This API can also be used in conjunction with other APIs (e.g. Vulkan, OpenGL) that support importing memory from the shareable type

Parameters:

shareableHandle - [out] - Pointer to the location in which to store the requested handle type

handle - [in] - CUDA handle for the memory allocation

handleType - [in] - Type of shareable handle requested (defines type and size of the \p shareableHandle output parameter)

flags - [in] - Reserved, must be zero

Returns:

::CUDA_SUCCESS, ::CUDA_ERROR_INVALID_VALUE, ::CUDA_ERROR_NOT_INITIALIZED, ::CUDA_ERROR_DEINITIALIZED, ::CUDA_ERROR_NOT_PERMITTED, ::CUDA_ERROR_NOT_SUPPORTED

cuMemImportFromShareableHandle
```
@Cast("CUresult")
public static int cuMemImportFromShareableHandle(@Cast("CUmemGenericAllocationHandle*")
                                                 LongPointer handle,
                                                 Pointer osHandle,
                                                 @Cast("CUmemAllocationHandleType")
                                                 int shHandleType)
```
\brief Imports an allocation from a requested shareable handle type. If the current process cannot support the memory described by this shareable handle, this API will error as CUDA_ERROR_NOT_SUPPORTED. \note Importing shareable handles exported from some graphics APIs(Vulkan, OpenGL, etc) created on devices under an SLI group may not be supported, and thus this API will return CUDA_ERROR_NOT_SUPPORTED. There is no guarantee that the contents of \p handle will be the same CUDA memory handle for the same given OS shareable handle, or the same underlying allocation.

Parameters:

handle - [out] - CUDA Memory handle for the memory allocation.

osHandle - [in] - Shareable Handle representing the memory allocation that is to be imported.

shHandleType - [in] - handle type of the exported handle ::CUmemAllocationHandleType.

Returns:

::CUDA_SUCCESS, ::CUDA_ERROR_INVALID_VALUE, ::CUDA_ERROR_NOT_INITIALIZED, ::CUDA_ERROR_DEINITIALIZED, ::CUDA_ERROR_NOT_PERMITTED, ::CUDA_ERROR_NOT_SUPPORTED

cuMemImportFromShareableHandle

@Cast("CUresult")
public static int cuMemImportFromShareableHandle(@Cast("CUmemGenericAllocationHandle*")
                                                 LongBuffer handle,
                                                 Pointer osHandle,
                                                 @Cast("CUmemAllocationHandleType")
                                                 int shHandleType)

cuMemImportFromShareableHandle

@Cast("CUresult")
public static int cuMemImportFromShareableHandle(@Cast("CUmemGenericAllocationHandle*")
                                                 long[] handle,
                                                 Pointer osHandle,
                                                 @Cast("CUmemAllocationHandleType")
                                                 int shHandleType)

cuMemGetAllocationGranularity

@Cast("CUresult")
public static int cuMemGetAllocationGranularity(@Cast("size_t*")
                                                SizeTPointer granularity,
                                                @Const
                                                CUmemAllocationProp prop,
                                                @Cast("CUmemAllocationGranularity_flags")
                                                int option)

\brief Calculates either the minimal or recommended granularity Calculates either the minimal or recommended granularity for a given allocation specification and returns it in granularity. This granularity can be used as a multiple for alignment, size, or address mapping.

Parameters:: granularity - [out] Returned granularity.; prop - [in] Property for which to determine the granularity for; option - [in] Determines which granularity to return
Returns:: ::CUDA_SUCCESS, ::CUDA_ERROR_INVALID_VALUE, ::CUDA_ERROR_NOT_INITIALIZED, ::CUDA_ERROR_DEINITIALIZED, ::CUDA_ERROR_NOT_PERMITTED, ::CUDA_ERROR_NOT_SUPPORTED

cuMemGetAllocationPropertiesFromHandle
```
@Cast("CUresult")
public static int cuMemGetAllocationPropertiesFromHandle(CUmemAllocationProp prop,
                                                         @Cast("CUmemGenericAllocationHandle")
                                                         long handle)
```
\brief Retrieve the contents of the property structure defining properties for this handle

Parameters:

prop - [out] - Pointer to a properties structure which will hold the information about this handle

handle - [in] - Handle which to perform the query on

Returns:

::CUDA_SUCCESS, ::CUDA_ERROR_INVALID_VALUE, ::CUDA_ERROR_NOT_INITIALIZED, ::CUDA_ERROR_DEINITIALIZED, ::CUDA_ERROR_NOT_PERMITTED, ::CUDA_ERROR_NOT_SUPPORTED

cuPointerGetAttribute
```
@Cast("CUresult")
public static int cuPointerGetAttribute(Pointer data,
                                        @Cast("CUpointer_attribute")
                                        int attribute,
                                        @Cast("CUdeviceptr")
                                        long ptr)
```
\brief Returns information about a pointer The supported attributes are: - ::CU_POINTER_ATTRIBUTE_CONTEXT: Returns in \p *data the ::CUcontext in which \p ptr was allocated or registered. The type of \p data must be ::CUcontext *. If \p ptr was not allocated by, mapped by, or registered with a ::CUcontext which uses unified virtual addressing then ::CUDA_ERROR_INVALID_VALUE is returned. - ::CU_POINTER_ATTRIBUTE_MEMORY_TYPE: Returns in \p *data the physical memory type of the memory that \p ptr addresses as a ::CUmemorytype enumerated value. The type of \p data must be unsigned int. If \p ptr addresses device memory then \p *data is set to ::CU_MEMORYTYPE_DEVICE. The particular ::CUdevice on which the memory resides is the ::CUdevice of the ::CUcontext returned by the ::CU_POINTER_ATTRIBUTE_CONTEXT attribute of \p ptr. If \p ptr addresses host memory then \p *data is set to ::CU_MEMORYTYPE_HOST. If \p ptr was not allocated by, mapped by, or registered with a ::CUcontext which uses unified virtual addressing then ::CUDA_ERROR_INVALID_VALUE is returned. If the current ::CUcontext does not support unified virtual addressing then ::CUDA_ERROR_INVALID_CONTEXT is returned. - ::CU_POINTER_ATTRIBUTE_DEVICE_POINTER: Returns in \p *data the device pointer value through which \p ptr may be accessed by kernels running in the current ::CUcontext. The type of \p data must be CUdeviceptr *. If there exists no device pointer value through which kernels running in the current ::CUcontext may access \p ptr then ::CUDA_ERROR_INVALID_VALUE is returned. If there is no current ::CUcontext then ::CUDA_ERROR_INVALID_CONTEXT is returned. Except in the exceptional disjoint addressing cases discussed below, the value returned in \p *data will equal the input value \p ptr. - ::CU_POINTER_ATTRIBUTE_HOST_POINTER: Returns in \p *data the host pointer value through which \p ptr may be accessed by by the host program. The type of \p data must be void **. If there exists no host pointer value through which the host program may directly access \p ptr then ::CUDA_ERROR_INVALID_VALUE is returned. Except in the exceptional disjoint addressing cases discussed below, the value returned in \p *data will equal the input value \p ptr. - ::CU_POINTER_ATTRIBUTE_P2P_TOKENS: Returns in \p *data two tokens for use with the nv-p2p.h Linux kernel interface. \p data must be a struct of type CUDA_POINTER_ATTRIBUTE_P2P_TOKENS. \p ptr must be a pointer to memory obtained from :cuMemAlloc(). Note that p2pToken and vaSpaceToken are only valid for the lifetime of the source allocation. A subsequent allocation at the same address may return completely different tokens. Querying this attribute has a side effect of setting the attribute ::CU_POINTER_ATTRIBUTE_SYNC_MEMOPS for the region of memory that \p ptr points to. - ::CU_POINTER_ATTRIBUTE_SYNC_MEMOPS: A boolean attribute which when set, ensures that synchronous memory operations initiated on the region of memory that \p ptr points to will always synchronize. See further documentation in the section titled "API synchronization behavior" to learn more about cases when synchronous memory operations can exhibit asynchronous behavior. - ::CU_POINTER_ATTRIBUTE_BUFFER_ID: Returns in \p *data a buffer ID which is guaranteed to be unique within the process. \p data must point to an unsigned long long. \p ptr must be a pointer to memory obtained from a CUDA memory allocation API. Every memory allocation from any of the CUDA memory allocation APIs will have a unique ID over a process lifetime. Subsequent allocations do not reuse IDs from previous freed allocations. IDs are only unique within a single process. - ::CU_POINTER_ATTRIBUTE_IS_MANAGED: Returns in \p *data a boolean that indicates whether the pointer points to managed memory or not. - ::CU_POINTER_ATTRIBUTE_DEVICE_ORDINAL: Returns in \p *data an integer representing a device ordinal of a device against which the memory was allocated or registered. - ::CU_POINTER_ATTRIBUTE_IS_LEGACY_CUDA_IPC_CAPABLE: Returns in \p *data a boolean that indicates if this pointer maps to an allocation that is suitable for ::cudaIpcGetMemHandle. - ::CU_POINTER_ATTRIBUTE_RANGE_START_ADDR: Returns in \p *data the starting address for the allocation referenced by the device pointer \p ptr. Note that this is not necessarily the address of the mapped region, but the address of the mappable address range \p ptr references (e.g. from ::cuMemAddressReserve). - ::CU_POINTER_ATTRIBUTE_RANGE_SIZE: Returns in \p *data the size for the allocation referenced by the device pointer \p ptr. Note that this is not necessarily the size of the mapped region, but the size of the mappable address range \p ptr references (e.g. from ::cuMemAddressReserve). To retrieve the size of the mapped region, see ::cuMemGetAllocationPropertyForAddress. - ::CU_POINTER_ATTRIBUTE_MAPPED: Returns in \p *data a boolean that indicates if this pointer is in a valid address range that is mapped to a backing allocation. - ::CU_POINTER_ATTRIBUTE_ALLOWED_HANDLE_TYPES: Returns a bitmask of the allowed handle types for an allocation that may be passed to ::cuMemExportToShareableHandle. \par Note that for most allocations in the unified virtual address space the host and device pointer for accessing the allocation will be the same. The exceptions to this are - user memory registered using ::cuMemHostRegister - host memory allocated using ::cuMemHostAlloc with the ::CU_MEMHOSTALLOC_WRITECOMBINED flag For these types of allocation there will exist separate, disjoint host and device addresses for accessing the allocation. In particular - The host address will correspond to an invalid unmapped device address (which will result in an exception if accessed from the device) - The device address will correspond to an invalid unmapped host address (which will result in an exception if accessed from the host). For these types of allocations, querying ::CU_POINTER_ATTRIBUTE_HOST_POINTER and ::CU_POINTER_ATTRIBUTE_DEVICE_POINTER may be used to retrieve the host and device addresses from either address.

Parameters:

data - - Returned pointer attribute value

attribute - - Pointer attribute to query

ptr - - Pointer

Returns:

::CUDA_SUCCESS, ::CUDA_ERROR_DEINITIALIZED, ::CUDA_ERROR_NOT_INITIALIZED, ::CUDA_ERROR_INVALID_CONTEXT, ::CUDA_ERROR_INVALID_VALUE, ::CUDA_ERROR_INVALID_DEVICE \notefnerr

cuMemPrefetchAsync
```
@Cast("CUresult")
public static int cuMemPrefetchAsync(@Cast("CUdeviceptr")
                                     long devPtr,
                                     @Cast("size_t")
                                     long count,
                                     @Cast("CUdevice")
                                     int dstDevice,
                                     CUstream_st hStream)
```
\brief Prefetches memory to the specified destination device Prefetches memory to the specified destination device. \p devPtr is the base device pointer of the memory to be prefetched and \p dstDevice is the destination device. \p count specifies the number of bytes to copy. \p hStream is the stream in which the operation is enqueued. The memory range must refer to managed memory allocated via ::cuMemAllocManaged or declared via __managed__ variables. Passing in CU_DEVICE_CPU for \p dstDevice will prefetch the data to host memory. If \p dstDevice is a GPU, then the device attribute ::CU_DEVICE_ATTRIBUTE_CONCURRENT_MANAGED_ACCESS must be non-zero. Additionally, \p hStream must be associated with a device that has a non-zero value for the device attribute ::CU_DEVICE_ATTRIBUTE_CONCURRENT_MANAGED_ACCESS. The start address and end address of the memory range will be rounded down and rounded up respectively to be aligned to CPU page size before the prefetch operation is enqueued in the stream. If no physical memory has been allocated for this region, then this memory region will be populated and mapped on the destination device. If there's insufficient memory to prefetch the desired region, the Unified Memory driver may evict pages from other ::cuMemAllocManaged allocations to host memory in order to make room. Device memory allocated using ::cuMemAlloc or ::cuArrayCreate will not be evicted. By default, any mappings to the previous location of the migrated pages are removed and mappings for the new location are only setup on \p dstDevice. The exact behavior however also depends on the settings applied to this memory range via ::cuMemAdvise as described below: If ::CU_MEM_ADVISE_SET_READ_MOSTLY was set on any subset of this memory range, then that subset will create a read-only copy of the pages on \p dstDevice. If ::CU_MEM_ADVISE_SET_PREFERRED_LOCATION was called on any subset of this memory range, then the pages will be migrated to \p dstDevice even if \p dstDevice is not the preferred location of any pages in the memory range. If ::CU_MEM_ADVISE_SET_ACCESSED_BY was called on any subset of this memory range, then mappings to those pages from all the appropriate processors are updated to refer to the new location if establishing such a mapping is possible. Otherwise, those mappings are cleared. Note that this API is not required for functionality and only serves to improve performance by allowing the application to migrate data to a suitable location before it is accessed. Memory accesses to this range are always coherent and are allowed even when the data is actively being migrated. Note that this function is asynchronous with respect to the host and all work on other devices.

Parameters:

devPtr - - Pointer to be prefetched

count - - Size in bytes

dstDevice - - Destination device to prefetch to

hStream - - Stream to enqueue prefetch operation

Returns:

::CUDA_SUCCESS, ::CUDA_ERROR_INVALID_VALUE, ::CUDA_ERROR_INVALID_DEVICE \notefnerr \note_async \note_null_stream

cuMemAdvise
```
@Cast("CUresult")
public static int cuMemAdvise(@Cast("CUdeviceptr")
                              long devPtr,
                              @Cast("size_t")
                              long count,
                              @Cast("CUmem_advise")
                              int advice,
                              @Cast("CUdevice")
                              int device)
```
\brief Advise about the usage of a given memory range Advise the Unified Memory subsystem about the usage pattern for the memory range starting at \p devPtr with a size of \p count bytes. The start address and end address of the memory range will be rounded down and rounded up respectively to be aligned to CPU page size before the advice is applied. The memory range must refer to managed memory allocated via ::cuMemAllocManaged or declared via __managed__ variables. The memory range could also refer to system-allocated pageable memory provided it represents a valid, host-accessible region of memory and all additional constraints imposed by \p advice as outlined below are also satisfied. Specifying an invalid system-allocated pageable memory range results in an error being returned. The \p advice parameter can take the following values: - ::CU_MEM_ADVISE_SET_READ_MOSTLY: This implies that the data is mostly going to be read from and only occasionally written to. Any read accesses from any processor to this region will create a read-only copy of at least the accessed pages in that processor's memory. Additionally, if ::cuMemPrefetchAsync is called on this region, it will create a read-only copy of the data on the destination processor. If any processor writes to this region, all copies of the corresponding page will be invalidated except for the one where the write occurred. The \p device argument is ignored for this advice. Note that for a page to be read-duplicated, the accessing processor must either be the CPU or a GPU that has a non-zero value for the device attribute ::CU_DEVICE_ATTRIBUTE_CONCURRENT_MANAGED_ACCESS. Also, if a context is created on a device that does not have the device attribute ::CU_DEVICE_ATTRIBUTE_CONCURRENT_MANAGED_ACCESS set, then read-duplication will not occur until all such contexts are destroyed. If the memory region refers to valid system-allocated pageable memory, then the accessing device must have a non-zero value for the device attribute ::CU_DEVICE_ATTRIBUTE_PAGEABLE_MEMORY_ACCESS for a read-only copy to be created on that device. Note however that if the accessing device also has a non-zero value for the device attribute ::CU_DEVICE_ATTRIBUTE_PAGEABLE_MEMORY_ACCESS_USES_HOST_PAGE_TABLES, then setting this advice will not create a read-only copy when that device accesses this memory region. - ::CU_MEM_ADVISE_UNSET_READ_MOSTLY: Undoes the effect of ::CU_MEM_ADVISE_SET_READ_MOSTLY and also prevents the Unified Memory driver from attempting heuristic read-duplication on the memory range. Any read-duplicated copies of the data will be collapsed into a single copy. The location for the collapsed copy will be the preferred location if the page has a preferred location and one of the read-duplicated copies was resident at that location. Otherwise, the location chosen is arbitrary. - ::CU_MEM_ADVISE_SET_PREFERRED_LOCATION: This advice sets the preferred location for the data to be the memory belonging to \p device. Passing in CU_DEVICE_CPU for \p device sets the preferred location as host memory. If \p device is a GPU, then it must have a non-zero value for the device attribute ::CU_DEVICE_ATTRIBUTE_CONCURRENT_MANAGED_ACCESS. Setting the preferred location does not cause data to migrate to that location immediately. Instead, it guides the migration policy when a fault occurs on that memory region. If the data is already in its preferred location and the faulting processor can establish a mapping without requiring the data to be migrated, then data migration will be avoided. On the other hand, if the data is not in its preferred location or if a direct mapping cannot be established, then it will be migrated to the processor accessing it. It is important to note that setting the preferred location does not prevent data prefetching done using ::cuMemPrefetchAsync. Having a preferred location can override the page thrash detection and resolution logic in the Unified Memory driver. Normally, if a page is detected to be constantly thrashing between for example host and device memory, the page may eventually be pinned to host memory by the Unified Memory driver. But if the preferred location is set as device memory, then the page will continue to thrash indefinitely. If ::CU_MEM_ADVISE_SET_READ_MOSTLY is also set on this memory region or any subset of it, then the policies associated with that advice will override the policies of this advice, unless read accesses from \p device will not result in a read-only copy being created on that device as outlined in description for the advice ::CU_MEM_ADVISE_SET_READ_MOSTLY. If the memory region refers to valid system-allocated pageable memory, then \p device must have a non-zero value for the device attribute ::CU_DEVICE_ATTRIBUTE_PAGEABLE_MEMORY_ACCESS. Additionally, if \p device has a non-zero value for the device attribute ::CU_DEVICE_ATTRIBUTE_PAGEABLE_MEMORY_ACCESS_USES_HOST_PAGE_TABLES, then this call has no effect. Note however that this behavior may change in the future. - ::CU_MEM_ADVISE_UNSET_PREFERRED_LOCATION: Undoes the effect of ::CU_MEM_ADVISE_SET_PREFERRED_LOCATION and changes the preferred location to none. - ::CU_MEM_ADVISE_SET_ACCESSED_BY: This advice implies that the data will be accessed by \p device. Passing in ::CU_DEVICE_CPU for \p device will set the advice for the CPU. If \p device is a GPU, then the device attribute ::CU_DEVICE_ATTRIBUTE_CONCURRENT_MANAGED_ACCESS must be non-zero. This advice does not cause data migration and has no impact on the location of the data per se. Instead, it causes the data to always be mapped in the specified processor's page tables, as long as the location of the data permits a mapping to be established. If the data gets migrated for any reason, the mappings are updated accordingly. This advice is recommended in scenarios where data locality is not important, but avoiding faults is. Consider for example a system containing multiple GPUs with peer-to-peer access enabled, where the data located on one GPU is occasionally accessed by peer GPUs. In such scenarios, migrating data over to the other GPUs is not as important because the accesses are infrequent and the overhead of migration may be too high. But preventing faults can still help improve performance, and so having a mapping set up in advance is useful. Note that on CPU access of this data, the data may be migrated to host memory because the CPU typically cannot access device memory directly. Any GPU that had the ::CU_MEM_ADVISE_SET_ACCESSED_BY flag set for this data will now have its mapping updated to point to the page in host memory. If ::CU_MEM_ADVISE_SET_READ_MOSTLY is also set on this memory region or any subset of it, then the policies associated with that advice will override the policies of this advice. Additionally, if the preferred location of this memory region or any subset of it is also \p device, then the policies associated with ::CU_MEM_ADVISE_SET_PREFERRED_LOCATION will override the policies of this advice. If the memory region refers to valid system-allocated pageable memory, then \p device must have a non-zero value for the device attribute ::CU_DEVICE_ATTRIBUTE_PAGEABLE_MEMORY_ACCESS. Additionally, if \p device has a non-zero value for the device attribute ::CU_DEVICE_ATTRIBUTE_PAGEABLE_MEMORY_ACCESS_USES_HOST_PAGE_TABLES, then this call has no effect. - ::CU_MEM_ADVISE_UNSET_ACCESSED_BY: Undoes the effect of ::CU_MEM_ADVISE_SET_ACCESSED_BY. Any mappings to the data from \p device may be removed at any time causing accesses to result in non-fatal page faults. If the memory region refers to valid system-allocated pageable memory, then \p device must have a non-zero value for the device attribute ::CU_DEVICE_ATTRIBUTE_PAGEABLE_MEMORY_ACCESS. Additionally, if \p device has a non-zero value for the device attribute ::CU_DEVICE_ATTRIBUTE_PAGEABLE_MEMORY_ACCESS_USES_HOST_PAGE_TABLES, then this call has no effect.

Parameters:

devPtr - - Pointer to memory to set the advice for

count - - Size in bytes of the memory range

advice - - Advice to be applied for the specified memory range

device - - Device to apply the advice for

Returns:

::CUDA_SUCCESS, ::CUDA_ERROR_INVALID_VALUE, ::CUDA_ERROR_INVALID_DEVICE \notefnerr \note_async \note_null_stream

cuPointerSetAttribute
```
@Cast("CUresult")
public static int cuPointerSetAttribute(@Const
                                        Pointer value,
                                        @Cast("CUpointer_attribute")
                                        int attribute,
                                        @Cast("CUdeviceptr")
                                        long ptr)
```
\brief Set attributes on a previously allocated memory region The supported attributes are: - ::CU_POINTER_ATTRIBUTE_SYNC_MEMOPS: A boolean attribute that can either be set (1) or unset (0). When set, the region of memory that \p ptr points to is guaranteed to always synchronize memory operations that are synchronous. If there are some previously initiated synchronous memory operations that are pending when this attribute is set, the function does not return until those memory operations are complete. See further documentation in the section titled "API synchronization behavior" to learn more about cases when synchronous memory operations can exhibit asynchronous behavior. \p value will be considered as a pointer to an unsigned integer to which this attribute is to be set.

Parameters:

value - - Pointer to memory containing the value to be set

attribute - - Pointer attribute to set

ptr - - Pointer to a memory region allocated using CUDA memory allocation APIs

Returns:

::CUDA_SUCCESS, ::CUDA_ERROR_DEINITIALIZED, ::CUDA_ERROR_NOT_INITIALIZED, ::CUDA_ERROR_INVALID_CONTEXT, ::CUDA_ERROR_INVALID_VALUE, ::CUDA_ERROR_INVALID_DEVICE \notefnerr

cuPointerGetAttributes
```
@Cast("CUresult")
public static int cuPointerGetAttributes(@Cast("unsigned int")
                                         int numAttributes,
                                         @Cast("CUpointer_attribute*")
                                         IntPointer attributes,
                                         @Cast("void**")
                                         PointerPointer data,
                                         @Cast("CUdeviceptr")
                                         long ptr)
```
\brief Returns information about a pointer. The supported attributes are (refer to ::cuPointerGetAttribute for attribute descriptions and restrictions): - ::CU_POINTER_ATTRIBUTE_CONTEXT - ::CU_POINTER_ATTRIBUTE_MEMORY_TYPE - ::CU_POINTER_ATTRIBUTE_DEVICE_POINTER - ::CU_POINTER_ATTRIBUTE_HOST_POINTER - ::CU_POINTER_ATTRIBUTE_SYNC_MEMOPS - ::CU_POINTER_ATTRIBUTE_BUFFER_ID - ::CU_POINTER_ATTRIBUTE_IS_MANAGED - ::CU_POINTER_ATTRIBUTE_DEVICE_ORDINAL - ::CU_POINTER_ATTRIBUTE_RANGE_START_ADDR - ::CU_POINTER_ATTRIBUTE_RANGE_SIZE - ::CU_POINTER_ATTRIBUTE_MAPPED - ::CU_POINTER_ATTRIBUTE_IS_LEGACY_CUDA_IPC_CAPABLE - ::CU_POINTER_ATTRIBUTE_ALLOWED_HANDLE_TYPES

Parameters:

numAttributes - - Number of attributes to query

attributes - - An array of attributes to query (numAttributes and the number of attributes in this array should match)

data - - A two-dimensional array containing pointers to memory locations where the result of each attribute query will be written to.

ptr - - Pointer to query Unlike ::cuPointerGetAttribute, this function will not return an error when the \p ptr encountered is not a valid CUDA pointer. Instead, the attributes are assigned default NULL values and CUDA_SUCCESS is returned. If \p ptr was not allocated by, mapped by, or registered with a ::CUcontext which uses UVA (Unified Virtual Addressing), ::CUDA_ERROR_INVALID_CONTEXT is returned.

Returns:

::CUDA_SUCCESS, ::CUDA_ERROR_DEINITIALIZED, ::CUDA_ERROR_INVALID_CONTEXT, ::CUDA_ERROR_INVALID_VALUE, ::CUDA_ERROR_INVALID_DEVICE \notefnerr

cuPointerGetAttributes

@Cast("CUresult")
public static int cuPointerGetAttributes(@Cast("unsigned int")
                                         int numAttributes,
                                         @Cast("CUpointer_attribute*")
                                         IntPointer attributes,
                                         @Cast("void**") @ByPtrPtr
                                         Pointer data,
                                         @Cast("CUdeviceptr")
                                         long ptr)

cuPointerGetAttributes

@Cast("CUresult")
public static int cuPointerGetAttributes(@Cast("unsigned int")
                                         int numAttributes,
                                         @Cast("CUpointer_attribute*")
                                         IntBuffer attributes,
                                         @Cast("void**") @ByPtrPtr
                                         Pointer data,
                                         @Cast("CUdeviceptr")
                                         long ptr)

cuPointerGetAttributes

@Cast("CUresult")
public static int cuPointerGetAttributes(@Cast("unsigned int")
                                         int numAttributes,
                                         @Cast("CUpointer_attribute*")
                                         int[] attributes,
                                         @Cast("void**") @ByPtrPtr
                                         Pointer data,
                                         @Cast("CUdeviceptr")
                                         long ptr)

cuStreamCreate
```
@Cast("CUresult")
public static int cuStreamCreate(@ByPtrPtr
                                 CUstream_st phStream,
                                 @Cast("unsigned int")
                                 int Flags)
```
\brief Create a stream Creates a stream and returns a handle in \p phStream. The \p Flags argument determines behaviors of the stream. Valid values for \p Flags are: - ::CU_STREAM_DEFAULT: Default stream creation flag. - ::CU_STREAM_NON_BLOCKING: Specifies that work running in the created stream may run concurrently with work in stream 0 (the NULL stream), and that the created stream should perform no implicit synchronization with stream 0.

Parameters:

phStream - - Returned newly created stream

Flags - - Parameters for stream creation

Returns:

::CUDA_SUCCESS, ::CUDA_ERROR_DEINITIALIZED, ::CUDA_ERROR_NOT_INITIALIZED, ::CUDA_ERROR_INVALID_CONTEXT, ::CUDA_ERROR_INVALID_VALUE, ::CUDA_ERROR_OUT_OF_MEMORY \notefnerr

cuStreamCreateWithPriority
```
@Cast("CUresult")
public static int cuStreamCreateWithPriority(@ByPtrPtr
                                             CUstream_st phStream,
                                             @Cast("unsigned int")
                                             int flags,
                                             int priority)
```
\brief Create a stream with the given priority Creates a stream with the specified priority and returns a handle in \p phStream. This API alters the scheduler priority of work in the stream. Work in a higher priority stream may preempt work already executing in a low priority stream. \p priority follows a convention where lower numbers represent higher priorities. '0' represents default priority. The range of meaningful numerical priorities can be queried using ::cuCtxGetStreamPriorityRange. If the specified priority is outside the numerical range returned by ::cuCtxGetStreamPriorityRange, it will automatically be clamped to the lowest or the highest number in the range.

Parameters:

phStream - - Returned newly created stream

flags - - Flags for stream creation. See ::cuStreamCreate for a list of valid flags

priority - - Stream priority. Lower numbers represent higher priorities. See ::cuCtxGetStreamPriorityRange for more information about meaningful stream priorities that can be passed.

Returns:

::CUDA_SUCCESS, ::CUDA_ERROR_DEINITIALIZED, ::CUDA_ERROR_NOT_INITIALIZED, ::CUDA_ERROR_INVALID_CONTEXT, ::CUDA_ERROR_INVALID_VALUE, ::CUDA_ERROR_OUT_OF_MEMORY \notefnerr \note Stream priorities are supported only on GPUs with compute capability 3.5 or higher. \note In the current implementation, only compute kernels launched in priority streams are affected by the stream's priority. Stream priorities have no effect on host-to-device and device-to-host memory operations.

cuStreamGetPriority
```
@Cast("CUresult")
public static int cuStreamGetPriority(CUstream_st hStream,
                                      IntPointer priority)
```
\brief Query the priority of a given stream Query the priority of a stream created using ::cuStreamCreate or ::cuStreamCreateWithPriority and return the priority in \p priority. Note that if the stream was created with a priority outside the numerical range returned by ::cuCtxGetStreamPriorityRange, this function returns the clamped priority. See ::cuStreamCreateWithPriority for details about priority clamping.

Parameters:

hStream - - Handle to the stream to be queried

priority - - Pointer to a signed integer in which the stream's priority is returned

Returns:

::CUDA_SUCCESS, ::CUDA_ERROR_DEINITIALIZED, ::CUDA_ERROR_NOT_INITIALIZED, ::CUDA_ERROR_INVALID_CONTEXT, ::CUDA_ERROR_INVALID_VALUE, ::CUDA_ERROR_INVALID_HANDLE, ::CUDA_ERROR_OUT_OF_MEMORY \notefnerr

cuStreamGetPriority

@Cast("CUresult")
public static int cuStreamGetPriority(CUstream_st hStream,
                                      IntBuffer priority)

cuStreamGetPriority

@Cast("CUresult")
public static int cuStreamGetPriority(CUstream_st hStream,
                                      int[] priority)

cuStreamGetFlags
```
@Cast("CUresult")
public static int cuStreamGetFlags(CUstream_st hStream,
                                   @Cast("unsigned int*")
                                   IntPointer flags)
```
\brief Query the flags of a given stream Query the flags of a stream created using ::cuStreamCreate or ::cuStreamCreateWithPriority and return the flags in \p flags.

Parameters:

hStream - - Handle to the stream to be queried

flags - - Pointer to an unsigned integer in which the stream's flags are returned The value returned in \p flags is a logical 'OR' of all flags that were used while creating this stream. See ::cuStreamCreate for the list of valid flags

Returns:

::CUDA_SUCCESS, ::CUDA_ERROR_DEINITIALIZED, ::CUDA_ERROR_NOT_INITIALIZED, ::CUDA_ERROR_INVALID_CONTEXT, ::CUDA_ERROR_INVALID_VALUE, ::CUDA_ERROR_INVALID_HANDLE, ::CUDA_ERROR_OUT_OF_MEMORY \notefnerr

cuStreamGetFlags

@Cast("CUresult")
public static int cuStreamGetFlags(CUstream_st hStream,
                                   @Cast("unsigned int*")
                                   IntBuffer flags)

cuStreamGetFlags

@Cast("CUresult")
public static int cuStreamGetFlags(CUstream_st hStream,
                                   @Cast("unsigned int*")
                                   int[] flags)

cuStreamGetCtx
```
@Cast("CUresult")
public static int cuStreamGetCtx(CUstream_st hStream,
                                 @ByPtrPtr
                                 CUctx_st pctx)
```
\brief Query the context associated with a stream Returns the CUDA context that the stream is associated with. The stream handle \p hStream can refer to any of the following:
- a stream created via any of the CUDA driver APIs such as ::cuStreamCreate and ::cuStreamCreateWithPriority, or their runtime API equivalents such as ::cudaStreamCreate, ::cudaStreamCreateWithFlags and ::cudaStreamCreateWithPriority. The returned context is the context that was active in the calling thread when the stream was created. Passing an invalid handle will result in undefined behavior.
- any of the special streams such as the NULL stream, ::CU_STREAM_LEGACY and ::CU_STREAM_PER_THREAD. The runtime API equivalents of these are also accepted, which are NULL, ::cudaStreamLegacy and ::cudaStreamPerThread respectively. Specifying any of the special handles will return the context current to the calling thread. If no context is current to the calling thread, ::CUDA_ERROR_INVALID_CONTEXT is returned.
Parameters:

hStream - - Handle to the stream to be queried

pctx - - Returned context associated with the stream

Returns:

::CUDA_SUCCESS, ::CUDA_ERROR_DEINITIALIZED, ::CUDA_ERROR_NOT_INITIALIZED, ::CUDA_ERROR_INVALID_CONTEXT, ::CUDA_ERROR_INVALID_HANDLE, \notefnerr

cuStreamWaitEvent
```
@Cast("CUresult")
public static int cuStreamWaitEvent(CUstream_st hStream,
                                    CUevent_st hEvent,
                                    @Cast("unsigned int")
                                    int Flags)
```
\brief Make a compute stream wait on an event Makes all future work submitted to \p hStream wait for all work captured in \p hEvent. See ::cuEventRecord() for details on what is captured by an event. The synchronization will be performed efficiently on the device when applicable. \p hEvent may be from a different context or device than \p hStream.

Parameters:

hStream - - Stream to wait

hEvent - - Event to wait on (may not be NULL)

Flags - - Parameters for the operation (must be 0)

Returns:

::CUDA_SUCCESS, ::CUDA_ERROR_DEINITIALIZED, ::CUDA_ERROR_NOT_INITIALIZED, ::CUDA_ERROR_INVALID_CONTEXT, ::CUDA_ERROR_INVALID_HANDLE, \note_null_stream \notefnerr

cuStreamAddCallback
```
@Cast("CUresult")
public static int cuStreamAddCallback(CUstream_st hStream,
                                      CUstreamCallback callback,
                                      Pointer userData,
                                      @Cast("unsigned int")
                                      int flags)
```
\brief Add a callback to a compute stream \note This function is slated for eventual deprecation and removal. If you do not require the callback to execute in case of a device error, consider using ::cuLaunchHostFunc. Additionally, this function is not supported with ::cuStreamBeginCapture and ::cuStreamEndCapture, unlike ::cuLaunchHostFunc. Adds a callback to be called on the host after all currently enqueued items in the stream have completed. For each cuStreamAddCallback call, the callback will be executed exactly once. The callback will block later work in the stream until it is finished. The callback may be passed ::CUDA_SUCCESS or an error code. In the event of a device error, all subsequently executed callbacks will receive an appropriate ::CUresult. Callbacks must not make any CUDA API calls. Attempting to use a CUDA API will result in ::CUDA_ERROR_NOT_PERMITTED. Callbacks must not perform any synchronization that may depend on outstanding device work or other callbacks that are not mandated to run earlier. Callbacks without a mandated order (in independent streams) execute in undefined order and may be serialized. For the purposes of Unified Memory, callback execution makes a number of guarantees:
- The callback stream is considered idle for the duration of the callback. Thus, for example, a callback may always use memory attached to the callback stream.
- The start of execution of a callback has the same effect as synchronizing an event recorded in the same stream immediately prior to the callback. It thus synchronizes streams which have been "joined" prior to the callback.
- Adding device work to any stream does not have the effect of making the stream active until all preceding host functions and stream callbacks have executed. Thus, for example, a callback might use global attached memory even if work has been added to another stream, if the work has been ordered behind the callback with an event.
- Completion of a callback does not cause a stream to become active except as described above. The callback stream will remain idle if no device work follows the callback, and will remain idle across consecutive callbacks without device work in between. Thus, for example, stream synchronization can be done by signaling from a callback at the end of the stream.
Parameters:

hStream - - Stream to add callback to

callback - - The function to call once preceding stream operations are complete

userData - - User specified data to be passed to the callback function

flags - - Reserved for future use, must be 0

Returns:

::CUDA_SUCCESS, ::CUDA_ERROR_DEINITIALIZED, ::CUDA_ERROR_NOT_INITIALIZED, ::CUDA_ERROR_INVALID_CONTEXT, ::CUDA_ERROR_INVALID_HANDLE, ::CUDA_ERROR_NOT_SUPPORTED \note_null_stream \notefnerr

cuStreamBeginCapture
```
@Cast("CUresult")
public static int cuStreamBeginCapture(CUstream_st hStream,
                                       @Cast("CUstreamCaptureMode")
                                       int mode)
```
\brief Begins graph capture on a stream Begin graph capture on \p hStream. When a stream is in capture mode, all operations pushed into the stream will not be executed, but will instead be captured into a graph, which will be returned via ::cuStreamEndCapture. Capture may not be initiated if \p stream is CU_STREAM_LEGACY. Capture must be ended on the same stream in which it was initiated, and it may only be initiated if the stream is not already in capture mode. The capture mode may be queried via ::cuStreamIsCapturing. A unique id representing the capture sequence may be queried via ::cuStreamGetCaptureInfo. If \p mode is not ::CU_STREAM_CAPTURE_MODE_RELAXED, ::cuStreamEndCapture must be called on this stream from the same thread.

Parameters:

hStream - - Stream in which to initiate capture

mode - - Controls the interaction of this capture sequence with other API calls that are potentially unsafe. For more details see ::cuThreadExchangeStreamCaptureMode. \note Kernels captured using this API must not use texture and surface references. Reading or writing through any texture or surface reference is undefined behavior. This restriction does not apply to texture and surface objects.

Returns:

::CUDA_SUCCESS, ::CUDA_ERROR_DEINITIALIZED, ::CUDA_ERROR_NOT_INITIALIZED, ::CUDA_ERROR_INVALID_VALUE \notefnerr

cuThreadExchangeStreamCaptureMode
```
@Cast("CUresult")
public static int cuThreadExchangeStreamCaptureMode(@Cast("CUstreamCaptureMode*")
                                                    IntPointer mode)
```
\brief Swaps the stream capture interaction mode for a thread Sets the calling thread's stream capture interaction mode to the value contained in \p *mode, and overwrites \p *mode with the previous mode for the thread. To facilitate deterministic behavior across function or module boundaries, callers are encouraged to use this API in a push-pop fashion:
```
     CUstreamCaptureMode mode = desiredMode;
     cuThreadExchangeStreamCaptureMode(&mode);
     ...
     cuThreadExchangeStreamCaptureMode(&mode); // restore previous mode
 
```
During stream capture (see ::cuStreamBeginCapture), some actions, such as a call to ::cudaMalloc, may be unsafe. In the case of ::cudaMalloc, the operation is not enqueued asynchronously to a stream, and is not observed by stream capture. Therefore, if the sequence of operations captured via ::cuStreamBeginCapture depended on the allocation being replayed whenever the graph is launched, the captured graph would be invalid. Therefore, stream capture places restrictions on API calls that can be made within or concurrently to a ::cuStreamBeginCapture-::cuStreamEndCapture sequence. This behavior can be controlled via this API and flags to ::cuStreamBeginCapture. A thread's mode is one of the following: - \p CU_STREAM_CAPTURE_MODE_GLOBAL: This is the default mode. If the local thread has an ongoing capture sequence that was not initiated with \p CU_STREAM_CAPTURE_MODE_RELAXED at \p cuStreamBeginCapture, or if any other thread has a concurrent capture sequence initiated with \p CU_STREAM_CAPTURE_MODE_GLOBAL, this thread is prohibited from potentially unsafe API calls. - \p CU_STREAM_CAPTURE_MODE_THREAD_LOCAL: If the local thread has an ongoing capture sequence not initiated with \p CU_STREAM_CAPTURE_MODE_RELAXED, it is prohibited from potentially unsafe API calls. Concurrent capture sequences in other threads are ignored. - \p CU_STREAM_CAPTURE_MODE_RELAXED: The local thread is not prohibited from potentially unsafe API calls. Note that the thread is still prohibited from API calls which necessarily conflict with stream capture, for example, attempting ::cuEventQuery on an event that was last recorded inside a capture sequence.
Parameters:

mode - - Pointer to mode value to swap with the current mode

Returns:

::CUDA_SUCCESS, ::CUDA_ERROR_DEINITIALIZED, ::CUDA_ERROR_NOT_INITIALIZED, ::CUDA_ERROR_INVALID_VALUE \notefnerr

cuThreadExchangeStreamCaptureMode

@Cast("CUresult")
public static int cuThreadExchangeStreamCaptureMode(@Cast("CUstreamCaptureMode*")
                                                    IntBuffer mode)

cuThreadExchangeStreamCaptureMode

@Cast("CUresult")
public static int cuThreadExchangeStreamCaptureMode(@Cast("CUstreamCaptureMode*")
                                                    int[] mode)

cuStreamEndCapture
```
@Cast("CUresult")
public static int cuStreamEndCapture(CUstream_st hStream,
                                     @ByPtrPtr
                                     CUgraph_st phGraph)
```
\brief Ends capture on a stream, returning the captured graph End capture on \p hStream, returning the captured graph via \p phGraph. Capture must have been initiated on \p hStream via a call to ::cuStreamBeginCapture. If capture was invalidated, due to a violation of the rules of stream capture, then a NULL graph will be returned. If the \p mode argument to ::cuStreamBeginCapture was not ::CU_STREAM_CAPTURE_MODE_RELAXED, this call must be from the same thread as ::cuStreamBeginCapture.

Parameters:

hStream - - Stream to query

phGraph - - The captured graph

Returns:

::CUDA_SUCCESS, ::CUDA_ERROR_DEINITIALIZED, ::CUDA_ERROR_NOT_INITIALIZED, ::CUDA_ERROR_INVALID_VALUE, ::CUDA_ERROR_STREAM_CAPTURE_WRONG_THREAD \notefnerr

cuStreamIsCapturing
```
@Cast("CUresult")
public static int cuStreamIsCapturing(CUstream_st hStream,
                                      @Cast("CUstreamCaptureStatus*")
                                      IntPointer captureStatus)
```
\brief Returns a stream's capture status Return the capture status of \p hStream via \p captureStatus. After a successful call, \p *captureStatus will contain one of the following: - ::CU_STREAM_CAPTURE_STATUS_NONE: The stream is not capturing. - ::CU_STREAM_CAPTURE_STATUS_ACTIVE: The stream is capturing. - ::CU_STREAM_CAPTURE_STATUS_INVALIDATED: The stream was capturing but an error has invalidated the capture sequence. The capture sequence must be terminated with ::cuStreamEndCapture on the stream where it was initiated in order to continue using \p hStream. Note that, if this is called on ::CU_STREAM_LEGACY (the "null stream") while a blocking stream in the same context is capturing, it will return ::CUDA_ERROR_STREAM_CAPTURE_IMPLICIT and \p *captureStatus is unspecified after the call. The blocking stream capture is not invalidated. When a blocking stream is capturing, the legacy stream is in an unusable state until the blocking stream capture is terminated. The legacy stream is not supported for stream capture, but attempted use would have an implicit dependency on the capturing stream(s).

Parameters:

hStream - - Stream to query

captureStatus - - Returns the stream's capture status

Returns:

::CUDA_SUCCESS, ::CUDA_ERROR_DEINITIALIZED, ::CUDA_ERROR_NOT_INITIALIZED, ::CUDA_ERROR_INVALID_VALUE, ::CUDA_ERROR_STREAM_CAPTURE_IMPLICIT \notefnerr

cuStreamIsCapturing

@Cast("CUresult")
public static int cuStreamIsCapturing(CUstream_st hStream,
                                      @Cast("CUstreamCaptureStatus*")
                                      IntBuffer captureStatus)

cuStreamIsCapturing

@Cast("CUresult")
public static int cuStreamIsCapturing(CUstream_st hStream,
                                      @Cast("CUstreamCaptureStatus*")
                                      int[] captureStatus)

cuStreamGetCaptureInfo
```
@Cast("CUresult")
public static int cuStreamGetCaptureInfo(CUstream_st hStream,
                                         @Cast("CUstreamCaptureStatus*")
                                         IntPointer captureStatus,
                                         @Cast("cuuint64_t*")
                                         IntPointer id)
```
\brief Query capture status of a stream Query the capture status of a stream and and get an id for the capture sequence, which is unique over the lifetime of the process. If called on ::CU_STREAM_LEGACY (the "null stream") while a stream not created with ::CU_STREAM_NON_BLOCKING is capturing, returns ::CUDA_ERROR_STREAM_CAPTURE_IMPLICIT. A valid id is returned only if both of the following are true: - the call returns CUDA_SUCCESS - captureStatus is set to ::CU_STREAM_CAPTURE_STATUS_ACTIVE

Returns:

::CUDA_SUCCESS, ::CUDA_ERROR_STREAM_CAPTURE_IMPLICIT \notefnerr

cuStreamGetCaptureInfo

@Cast("CUresult")
public static int cuStreamGetCaptureInfo(CUstream_st hStream,
                                         @Cast("CUstreamCaptureStatus*")
                                         IntBuffer captureStatus,
                                         @Cast("cuuint64_t*")
                                         IntBuffer id)

cuStreamGetCaptureInfo

@Cast("CUresult")
public static int cuStreamGetCaptureInfo(CUstream_st hStream,
                                         @Cast("CUstreamCaptureStatus*")
                                         int[] captureStatus,
                                         @Cast("cuuint64_t*")
                                         int[] id)

cuStreamAttachMemAsync
```
@Cast("CUresult")
public static int cuStreamAttachMemAsync(CUstream_st hStream,
                                         @Cast("CUdeviceptr")
                                         long dptr,
                                         @Cast("size_t")
                                         long length,
                                         @Cast("unsigned int")
                                         int flags)
```
\brief Attach memory to a stream asynchronously Enqueues an operation in \p hStream to specify stream association of \p length bytes of memory starting from \p dptr. This function is a stream-ordered operation, meaning that it is dependent on, and will only take effect when, previous work in stream has completed. Any previous association is automatically replaced. \p dptr must point to one of the following types of memories: - managed memory declared using the __managed__ keyword or allocated with ::cuMemAllocManaged. - a valid host-accessible region of system-allocated pageable memory. This type of memory may only be specified if the device associated with the stream reports a non-zero value for the device attribute ::CU_DEVICE_ATTRIBUTE_PAGEABLE_MEMORY_ACCESS. For managed allocations, \p length must be either zero or the entire allocation's size. Both indicate that the entire allocation's stream association is being changed. Currently, it is not possible to change stream association for a portion of a managed allocation. For pageable host allocations, \p length must be non-zero. The stream association is specified using \p flags which must be one of ::CUmemAttach_flags. If the ::CU_MEM_ATTACH_GLOBAL flag is specified, the memory can be accessed by any stream on any device. If the ::CU_MEM_ATTACH_HOST flag is specified, the program makes a guarantee that it won't access the memory on the device from any stream on a device that has a zero value for the device attribute ::CU_DEVICE_ATTRIBUTE_CONCURRENT_MANAGED_ACCESS. If the ::CU_MEM_ATTACH_SINGLE flag is specified and \p hStream is associated with a device that has a zero value for the device attribute ::CU_DEVICE_ATTRIBUTE_CONCURRENT_MANAGED_ACCESS, the program makes a guarantee that it will only access the memory on the device from \p hStream. It is illegal to attach singly to the NULL stream, because the NULL stream is a virtual global stream and not a specific stream. An error will be returned in this case. When memory is associated with a single stream, the Unified Memory system will allow CPU access to this memory region so long as all operations in \p hStream have completed, regardless of whether other streams are active. In effect, this constrains exclusive ownership of the managed memory region by an active GPU to per-stream activity instead of whole-GPU activity. Accessing memory on the device from streams that are not associated with it will produce undefined results. No error checking is performed by the Unified Memory system to ensure that kernels launched into other streams do not access this region. It is a program's responsibility to order calls to ::cuStreamAttachMemAsync via events, synchronization or other means to ensure legal access to memory at all times. Data visibility and coherency will be changed appropriately for all kernels which follow a stream-association change. If \p hStream is destroyed while data is associated with it, the association is removed and the association reverts to the default visibility of the allocation as specified at ::cuMemAllocManaged. For __managed__ variables, the default association is always ::CU_MEM_ATTACH_GLOBAL. Note that destroying a stream is an asynchronous operation, and as a result, the change to default association won't happen until all work in the stream has completed.

Parameters:

hStream - - Stream in which to enqueue the attach operation

dptr - - Pointer to memory (must be a pointer to managed memory or to a valid host-accessible region of system-allocated pageable memory)

length - - Length of memory

flags - - Must be one of ::CUmemAttach_flags

Returns:

::CUDA_SUCCESS, ::CUDA_ERROR_DEINITIALIZED, ::CUDA_ERROR_NOT_INITIALIZED, ::CUDA_ERROR_INVALID_CONTEXT, ::CUDA_ERROR_INVALID_HANDLE, ::CUDA_ERROR_NOT_SUPPORTED \note_null_stream \notefnerr

cuStreamQuery
```
@Cast("CUresult")
public static int cuStreamQuery(CUstream_st hStream)
```
\brief Determine status of a compute stream Returns ::CUDA_SUCCESS if all operations in the stream specified by \p hStream have completed, or ::CUDA_ERROR_NOT_READY if not. For the purposes of Unified Memory, a return value of ::CUDA_SUCCESS is equivalent to having called ::cuStreamSynchronize().

Parameters:

hStream - - Stream to query status of

Returns:

::CUDA_SUCCESS, ::CUDA_ERROR_DEINITIALIZED, ::CUDA_ERROR_NOT_INITIALIZED, ::CUDA_ERROR_INVALID_CONTEXT, ::CUDA_ERROR_INVALID_HANDLE, ::CUDA_ERROR_NOT_READY \note_null_stream \notefnerr

cuStreamSynchronize
```
@Cast("CUresult")
public static int cuStreamSynchronize(CUstream_st hStream)
```
\brief Wait until a stream's tasks are completed Waits until the device has completed all operations in the stream specified by \p hStream. If the context was created with the ::CU_CTX_SCHED_BLOCKING_SYNC flag, the CPU thread will block until the stream is finished with all of its tasks.

Parameters:

hStream - - Stream to wait for

Returns:

::CUDA_SUCCESS, ::CUDA_ERROR_DEINITIALIZED, ::CUDA_ERROR_NOT_INITIALIZED, ::CUDA_ERROR_INVALID_CONTEXT, ::CUDA_ERROR_INVALID_HANDLE
\note_null_stream \notefnerr

cuStreamDestroy
```
@Cast("CUresult")
public static int cuStreamDestroy(CUstream_st hStream)
```
\brief Destroys a stream Destroys the stream specified by \p hStream. In case the device is still doing work in the stream \p hStream when ::cuStreamDestroy() is called, the function will return immediately and the resources associated with \p hStream will be released automatically once the device has completed all work in \p hStream.

Parameters:

hStream - - Stream to destroy

Returns:

::CUDA_SUCCESS, ::CUDA_ERROR_DEINITIALIZED, ::CUDA_ERROR_NOT_INITIALIZED, ::CUDA_ERROR_INVALID_CONTEXT, ::CUDA_ERROR_INVALID_VALUE, ::CUDA_ERROR_INVALID_HANDLE \notefnerr

cuEventCreate
```
@Cast("CUresult")
public static int cuEventCreate(@ByPtrPtr
                                CUevent_st phEvent,
                                @Cast("unsigned int")
                                int Flags)
```
\brief Creates an event Creates an event *phEvent for the current context with the flags specified via \p Flags. Valid flags include: - ::CU_EVENT_DEFAULT: Default event creation flag. - ::CU_EVENT_BLOCKING_SYNC: Specifies that the created event should use blocking synchronization. A CPU thread that uses ::cuEventSynchronize() to wait on an event created with this flag will block until the event has actually been recorded. - ::CU_EVENT_DISABLE_TIMING: Specifies that the created event does not need to record timing data. Events created with this flag specified and the ::CU_EVENT_BLOCKING_SYNC flag not specified will provide the best performance when used with ::cuStreamWaitEvent() and ::cuEventQuery(). - ::CU_EVENT_INTERPROCESS: Specifies that the created event may be used as an interprocess event by ::cuIpcGetEventHandle(). ::CU_EVENT_INTERPROCESS must be specified along with ::CU_EVENT_DISABLE_TIMING.

Parameters:

phEvent - - Returns newly created event

Flags - - Event creation flags

Returns:

::CUDA_SUCCESS, ::CUDA_ERROR_DEINITIALIZED, ::CUDA_ERROR_NOT_INITIALIZED, ::CUDA_ERROR_INVALID_CONTEXT, ::CUDA_ERROR_INVALID_VALUE, ::CUDA_ERROR_OUT_OF_MEMORY \notefnerr

cuEventRecord
```
@Cast("CUresult")
public static int cuEventRecord(CUevent_st hEvent,
                                CUstream_st hStream)
```
\brief Records an event Captures in \p hEvent the contents of \p hStream at the time of this call. \p hEvent and \p hStream must be from the same context. Calls such as ::cuEventQuery() or ::cuStreamWaitEvent() will then examine or wait for completion of the work that was captured. Uses of \p hStream after this call do not modify \p hEvent. See note on default stream behavior for what is captured in the default case. ::cuEventRecord() can be called multiple times on the same event and will overwrite the previously captured state. Other APIs such as ::cuStreamWaitEvent() use the most recently captured state at the time of the API call, and are not affected by later calls to ::cuEventRecord(). Before the first call to ::cuEventRecord(), an event represents an empty set of work, so for example ::cuEventQuery() would return ::CUDA_SUCCESS.

Parameters:

hEvent - - Event to record

hStream - - Stream to record event for

Returns:

::CUDA_SUCCESS, ::CUDA_ERROR_DEINITIALIZED, ::CUDA_ERROR_NOT_INITIALIZED, ::CUDA_ERROR_INVALID_CONTEXT, ::CUDA_ERROR_INVALID_HANDLE, ::CUDA_ERROR_INVALID_VALUE \note_null_stream \notefnerr

cuEventQuery
```
@Cast("CUresult")
public static int cuEventQuery(CUevent_st hEvent)
```
\brief Queries an event's status Queries the status of all work currently captured by \p hEvent. See ::cuEventRecord() for details on what is captured by an event. Returns ::CUDA_SUCCESS if all captured work has been completed, or ::CUDA_ERROR_NOT_READY if any captured work is incomplete. For the purposes of Unified Memory, a return value of ::CUDA_SUCCESS is equivalent to having called ::cuEventSynchronize().

Parameters:

hEvent - - Event to query

Returns:

::CUDA_SUCCESS, ::CUDA_ERROR_DEINITIALIZED, ::CUDA_ERROR_NOT_INITIALIZED, ::CUDA_ERROR_INVALID_HANDLE, ::CUDA_ERROR_INVALID_VALUE, ::CUDA_ERROR_NOT_READY \notefnerr

cuEventSynchronize
```
@Cast("CUresult")
public static int cuEventSynchronize(CUevent_st hEvent)
```
\brief Waits for an event to complete Waits until the completion of all work currently captured in \p hEvent. See ::cuEventRecord() for details on what is captured by an event. Waiting for an event that was created with the ::CU_EVENT_BLOCKING_SYNC flag will cause the calling CPU thread to block until the event has been completed by the device. If the ::CU_EVENT_BLOCKING_SYNC flag has not been set, then the CPU thread will busy-wait until the event has been completed by the device.

Parameters:

hEvent - - Event to wait for

Returns:

::CUDA_SUCCESS, ::CUDA_ERROR_DEINITIALIZED, ::CUDA_ERROR_NOT_INITIALIZED, ::CUDA_ERROR_INVALID_CONTEXT, ::CUDA_ERROR_INVALID_HANDLE \notefnerr

cuEventDestroy
```
@Cast("CUresult")
public static int cuEventDestroy(CUevent_st hEvent)
```
\brief Destroys an event Destroys the event specified by \p hEvent. An event may be destroyed before it is complete (i.e., while ::cuEventQuery() would return ::CUDA_ERROR_NOT_READY). In this case, the call does not block on completion of the event, and any associated resources will automatically be released asynchronously at completion.

Parameters:

hEvent - - Event to destroy

Returns:

::CUDA_SUCCESS, ::CUDA_ERROR_DEINITIALIZED, ::CUDA_ERROR_NOT_INITIALIZED, ::CUDA_ERROR_INVALID_CONTEXT, ::CUDA_ERROR_INVALID_HANDLE \notefnerr

cuEventElapsedTime
```
@Cast("CUresult")
public static int cuEventElapsedTime(FloatPointer pMilliseconds,
                                     CUevent_st hStart,
                                     CUevent_st hEnd)
```
\brief Computes the elapsed time between two events Computes the elapsed time between two events (in milliseconds with a resolution of around 0.5 microseconds). If either event was last recorded in a non-NULL stream, the resulting time may be greater than expected (even if both used the same stream handle). This happens because the ::cuEventRecord() operation takes place asynchronously and there is no guarantee that the measured latency is actually just between the two events. Any number of other different stream operations could execute in between the two measured events, thus altering the timing in a significant way. If ::cuEventRecord() has not been called on either event then ::CUDA_ERROR_INVALID_HANDLE is returned. If ::cuEventRecord() has been called on both events but one or both of them has not yet been completed (that is, ::cuEventQuery() would return ::CUDA_ERROR_NOT_READY on at least one of the events), ::CUDA_ERROR_NOT_READY is returned. If either event was created with the ::CU_EVENT_DISABLE_TIMING flag, then this function will return ::CUDA_ERROR_INVALID_HANDLE.

Parameters:

pMilliseconds - - Time between \p hStart and \p hEnd in ms

hStart - - Starting event

hEnd - - Ending event

Returns:

::CUDA_SUCCESS, ::CUDA_ERROR_DEINITIALIZED, ::CUDA_ERROR_NOT_INITIALIZED, ::CUDA_ERROR_INVALID_CONTEXT, ::CUDA_ERROR_INVALID_HANDLE, ::CUDA_ERROR_NOT_READY \notefnerr

cuEventElapsedTime

@Cast("CUresult")
public static int cuEventElapsedTime(FloatBuffer pMilliseconds,
                                     CUevent_st hStart,
                                     CUevent_st hEnd)

cuEventElapsedTime

@Cast("CUresult")
public static int cuEventElapsedTime(float[] pMilliseconds,
                                     CUevent_st hStart,
                                     CUevent_st hEnd)

cuImportExternalMemory
```
@Cast("CUresult")
public static int cuImportExternalMemory(@ByPtrPtr
                                         CUextMemory_st extMem_out,
                                         @Const
                                         CUDA_EXTERNAL_MEMORY_HANDLE_DESC memHandleDesc)
```
\brief Imports an external memory object Imports an externally allocated memory object and returns a handle to that in \p extMem_out. The properties of the handle being imported must be described in \p memHandleDesc. The ::CUDA_EXTERNAL_MEMORY_HANDLE_DESC structure is defined as follows:
```
        typedef struct CUDA_EXTERNAL_MEMORY_HANDLE_DESC_st {
            CUexternalMemoryHandleType type;
            union {
                int fd;
                struct {
                    void *handle;
                    const void *name;
                } win32;
                const void *nvSciBufObject;
            } handle;
            unsigned long long size;
            unsigned int flags;
        } CUDA_EXTERNAL_MEMORY_HANDLE_DESC;
 
```
where ::CUDA_EXTERNAL_MEMORY_HANDLE_DESC::type specifies the type of handle being imported. ::CUexternalMemoryHandleType is defined as:
```
        typedef enum CUexternalMemoryHandleType_enum {
            CU_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_FD          = 1,
            CU_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32       = 2,
            CU_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_KMT   = 3,
            CU_EXTERNAL_MEMORY_HANDLE_TYPE_D3D12_HEAP         = 4,
            CU_EXTERNAL_MEMORY_HANDLE_TYPE_D3D12_RESOURCE     = 5,
            CU_EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_RESOURCE     = 6,
            CU_EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_RESOURCE_KMT = 7,
            CU_EXTERNAL_MEMORY_HANDLE_TYPE_NVSCIBUF           = 8
        } CUexternalMemoryHandleType;
 
```
If ::CUDA_EXTERNAL_MEMORY_HANDLE_DESC::type is ::CU_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_FD, then ::CUDA_EXTERNAL_MEMORY_HANDLE_DESC::handle::fd must be a valid file descriptor referencing a memory object. Ownership of the file descriptor is transferred to the CUDA driver when the handle is imported successfully. Performing any operations on the file descriptor after it is imported results in undefined behavior. If ::CUDA_EXTERNAL_MEMORY_HANDLE_DESC::type is ::CU_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32, then exactly one of ::CUDA_EXTERNAL_MEMORY_HANDLE_DESC::handle::win32::handle and ::CUDA_EXTERNAL_MEMORY_HANDLE_DESC::handle::win32::name must not be NULL. If ::CUDA_EXTERNAL_MEMORY_HANDLE_DESC::handle::win32::handle is not NULL, then it must represent a valid shared NT handle that references a memory object. Ownership of this handle is not transferred to CUDA after the import operation, so the application must release the handle using the appropriate system call. If ::CUDA_EXTERNAL_MEMORY_HANDLE_DESC::handle::win32::name is not NULL, then it must point to a NULL-terminated array of UTF-16 characters that refers to a memory object. If ::CUDA_EXTERNAL_MEMORY_HANDLE_DESC::type is ::CU_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_KMT, then ::CUDA_EXTERNAL_MEMORY_HANDLE_DESC::handle::win32::handle must be non-NULL and ::CUDA_EXTERNAL_MEMORY_HANDLE_DESC::handle::win32::name must be NULL. The handle specified must be a globally shared KMT handle. This handle does not hold a reference to the underlying object, and thus will be invalid when all references to the memory object are destroyed. If ::CUDA_EXTERNAL_MEMORY_HANDLE_DESC::type is ::CU_EXTERNAL_MEMORY_HANDLE_TYPE_D3D12_HEAP, then exactly one of ::CUDA_EXTERNAL_MEMORY_HANDLE_DESC::handle::win32::handle and ::CUDA_EXTERNAL_MEMORY_HANDLE_DESC::handle::win32::name must not be NULL. If ::CUDA_EXTERNAL_MEMORY_HANDLE_DESC::handle::win32::handle is not NULL, then it must represent a valid shared NT handle that is returned by ID3D12Device::CreateSharedHandle when referring to a ID3D12Heap object. This handle holds a reference to the underlying object. If ::CUDA_EXTERNAL_MEMORY_HANDLE_DESC::handle::win32::name is not NULL, then it must point to a NULL-terminated array of UTF-16 characters that refers to a ID3D12Heap object. If ::CUDA_EXTERNAL_MEMORY_HANDLE_DESC::type is ::CU_EXTERNAL_MEMORY_HANDLE_TYPE_D3D12_RESOURCE, then exactly one of ::CUDA_EXTERNAL_MEMORY_HANDLE_DESC::handle::win32::handle and ::CUDA_EXTERNAL_MEMORY_HANDLE_DESC::handle::win32::name must not be NULL. If ::CUDA_EXTERNAL_MEMORY_HANDLE_DESC::handle::win32::handle is not NULL, then it must represent a valid shared NT handle that is returned by ID3D12Device::CreateSharedHandle when referring to a ID3D12Resource object. This handle holds a reference to the underlying object. If ::CUDA_EXTERNAL_MEMORY_HANDLE_DESC::handle::win32::name is not NULL, then it must point to a NULL-terminated array of UTF-16 characters that refers to a ID3D12Resource object. If ::CUDA_EXTERNAL_MEMORY_HANDLE_DESC::type is ::CU_EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_RESOURCE, then ::CUDA_EXTERNAL_MEMORY_HANDLE_DESC::handle::win32::handle must represent a valid shared NT handle that is returned by IDXGIResource1::CreateSharedHandle when referring to a ID3D11Resource object. If ::CUDA_EXTERNAL_MEMORY_HANDLE_DESC::handle::win32::name is not NULL, then it must point to a NULL-terminated array of UTF-16 characters that refers to a ID3D11Resource object. If ::CUDA_EXTERNAL_MEMORY_HANDLE_DESC::type is ::CU_EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_RESOURCE_KMT, then ::CUDA_EXTERNAL_MEMORY_HANDLE_DESC::handle::win32::handle must represent a valid shared KMT handle that is returned by IDXGIResource::GetSharedHandle when referring to a ID3D11Resource object and ::CUDA_EXTERNAL_MEMORY_HANDLE_DESC::handle::win32::name must be NULL. If ::CUDA_EXTERNAL_MEMORY_HANDLE_DESC::type is ::CU_EXTERNAL_MEMORY_HANDLE_TYPE_NVSCIBUF, then ::CUDA_EXTERNAL_MEMORY_HANDLE_DESC::handle::nvSciBufObject must be non-NULL and reference a valid NvSciBuf object. If the NvSciBuf object imported into CUDA is also mapped by other drivers, then the application must use ::cuWaitExternalSemaphoresAsync or ::cuSignalExternalSemaphoresAsync as appropriate barriers to maintain coherence between CUDA and the other drivers. The size of the memory object must be specified in ::CUDA_EXTERNAL_MEMORY_HANDLE_DESC::size. Specifying the flag ::CUDA_EXTERNAL_MEMORY_DEDICATED in ::CUDA_EXTERNAL_MEMORY_HANDLE_DESC::flags indicates that the resource is a dedicated resource. The definition of what a dedicated resource is outside the scope of this extension. This flag must be set if ::CUDA_EXTERNAL_MEMORY_HANDLE_DESC::type is one of the following: ::CU_EXTERNAL_MEMORY_HANDLE_TYPE_D3D12_RESOURCE ::CU_EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_RESOURCE ::CU_EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_RESOURCE_KMT
Parameters:

extMem_out - - Returned handle to an external memory object

memHandleDesc - - Memory import handle descriptor

Returns:

::CUDA_SUCCESS, ::CUDA_ERROR_NOT_INITIALIZED, ::CUDA_ERROR_INVALID_HANDLE \notefnerr \note If the Vulkan memory imported into CUDA is mapped on the CPU then the application must use vkInvalidateMappedMemoryRanges/vkFlushMappedMemoryRanges as well as appropriate Vulkan pipeline barriers to maintain coherence between CPU and GPU. For more information on these APIs, please refer to "Synchronization and Cache Control" chapter from Vulkan specification.

cuExternalMemoryGetMappedBuffer
```
@Cast("CUresult")
public static int cuExternalMemoryGetMappedBuffer(@Cast("CUdeviceptr*")
                                                  LongPointer devPtr,
                                                  CUextMemory_st extMem,
                                                  @Const
                                                  CUDA_EXTERNAL_MEMORY_BUFFER_DESC bufferDesc)
```
\brief Maps a buffer onto an imported memory object Maps a buffer onto an imported memory object and returns a device pointer in \p devPtr. The properties of the buffer being mapped must be described in \p bufferDesc. The ::CUDA_EXTERNAL_MEMORY_BUFFER_DESC structure is defined as follows:
```
        typedef struct CUDA_EXTERNAL_MEMORY_BUFFER_DESC_st {
            unsigned long long offset;
            unsigned long long size;
            unsigned int flags;
        } CUDA_EXTERNAL_MEMORY_BUFFER_DESC;
 
```
where ::CUDA_EXTERNAL_MEMORY_BUFFER_DESC::offset is the offset in the memory object where the buffer's base address is. ::CUDA_EXTERNAL_MEMORY_BUFFER_DESC::size is the size of the buffer. ::CUDA_EXTERNAL_MEMORY_BUFFER_DESC::flags must be zero. The offset and size have to be suitably aligned to match the requirements of the external API. Mapping two buffers whose ranges overlap may or may not result in the same virtual address being returned for the overlapped portion. In such cases, the application must ensure that all accesses to that region from the GPU are volatile. Otherwise writes made via one address are not guaranteed to be visible via the other address, even if they're issued by the same thread. It is recommended that applications map the combined range instead of mapping separate buffers and then apply the appropriate offsets to the returned pointer to derive the individual buffers. The returned pointer \p devPtr must be freed using ::cuMemFree.
Parameters:

devPtr - - Returned device pointer to buffer

extMem - - Handle to external memory object

bufferDesc - - Buffer descriptor

Returns:

::CUDA_SUCCESS, ::CUDA_ERROR_NOT_INITIALIZED, ::CUDA_ERROR_INVALID_HANDLE \notefnerr

cuExternalMemoryGetMappedBuffer

@Cast("CUresult")
public static int cuExternalMemoryGetMappedBuffer(@Cast("CUdeviceptr*")
                                                  LongBuffer devPtr,
                                                  CUextMemory_st extMem,
                                                  @Const
                                                  CUDA_EXTERNAL_MEMORY_BUFFER_DESC bufferDesc)

cuExternalMemoryGetMappedBuffer

@Cast("CUresult")
public static int cuExternalMemoryGetMappedBuffer(@Cast("CUdeviceptr*")
                                                  long[] devPtr,
                                                  CUextMemory_st extMem,
                                                  @Const
                                                  CUDA_EXTERNAL_MEMORY_BUFFER_DESC bufferDesc)

cuExternalMemoryGetMappedMipmappedArray
```
@Cast("CUresult")
public static int cuExternalMemoryGetMappedMipmappedArray(@ByPtrPtr
                                                          CUmipmappedArray_st mipmap,
                                                          CUextMemory_st extMem,
                                                          @Const
                                                          CUDA_EXTERNAL_MEMORY_MIPMAPPED_ARRAY_DESC mipmapDesc)
```
\brief Maps a CUDA mipmapped array onto an external memory object Maps a CUDA mipmapped array onto an external object and returns a handle to it in \p mipmap. The properties of the CUDA mipmapped array being mapped must be described in \p mipmapDesc. The structure ::CUDA_EXTERNAL_MEMORY_MIPMAPPED_ARRAY_DESC is defined as follows:
```
        typedef struct CUDA_EXTERNAL_MEMORY_MIPMAPPED_ARRAY_DESC_st {
            unsigned long long offset;
            CUDA_ARRAY3D_DESCRIPTOR arrayDesc;
            unsigned int numLevels;
        } CUDA_EXTERNAL_MEMORY_MIPMAPPED_ARRAY_DESC;
 
```
where ::CUDA_EXTERNAL_MEMORY_MIPMAPPED_ARRAY_DESC::offset is the offset in the memory object where the base level of the mipmap chain is. ::CUDA_EXTERNAL_MEMORY_MIPMAPPED_ARRAY_DESC::arrayDesc describes the format, dimensions and type of the base level of the mipmap chain. For further details on these parameters, please refer to the documentation for ::cuMipmappedArrayCreate. Note that if the mipmapped array is bound as a color target in the graphics API, then the flag ::CUDA_ARRAY3D_COLOR_ATTACHMENT must be specified in ::CUDA_EXTERNAL_MEMORY_MIPMAPPED_ARRAY_DESC::arrayDesc::Flags. ::CUDA_EXTERNAL_MEMORY_MIPMAPPED_ARRAY_DESC::numLevels specifies the total number of levels in the mipmap chain. If \p extMem was imported from a handle of type ::CU_EXTERNAL_MEMORY_HANDLE_TYPE_NVSCIBUF, then ::CUDA_EXTERNAL_MEMORY_MIPMAPPED_ARRAY_DESC::numLevels must be equal to 1. The returned CUDA mipmapped array must be freed using ::cuMipmappedArrayDestroy.
Parameters:

mipmap - - Returned CUDA mipmapped array

extMem - - Handle to external memory object

mipmapDesc - - CUDA array descriptor

Returns:

::CUDA_SUCCESS, ::CUDA_ERROR_NOT_INITIALIZED, ::CUDA_ERROR_INVALID_HANDLE \notefnerr

cuDestroyExternalMemory
```
@Cast("CUresult")
public static int cuDestroyExternalMemory(CUextMemory_st extMem)
```
\brief Destroys an external memory object. Destroys the specified external memory object. Any existing buffers and CUDA mipmapped arrays mapped onto this object must no longer be used and must be explicitly freed using ::cuMemFree and ::cuMipmappedArrayDestroy respectively.

Parameters:

extMem - - External memory object to be destroyed

Returns:

::CUDA_SUCCESS, ::CUDA_ERROR_NOT_INITIALIZED, ::CUDA_ERROR_INVALID_HANDLE \notefnerr

cuImportExternalSemaphore
```
@Cast("CUresult")
public static int cuImportExternalSemaphore(@ByPtrPtr
                                            CUextSemaphore_st extSem_out,
                                            @Const
                                            CUDA_EXTERNAL_SEMAPHORE_HANDLE_DESC semHandleDesc)
```
\brief Imports an external semaphore Imports an externally allocated synchronization object and returns a handle to that in \p extSem_out. The properties of the handle being imported must be described in \p semHandleDesc. The ::CUDA_EXTERNAL_SEMAPHORE_HANDLE_DESC is defined as follows:
```
        typedef struct CUDA_EXTERNAL_SEMAPHORE_HANDLE_DESC_st {
            CUexternalSemaphoreHandleType type;
            union {
                int fd;
                struct {
                    void *handle;
                    const void *name;
                } win32;
                const void* NvSciSyncObj;
            } handle;
            unsigned int flags;
        } CUDA_EXTERNAL_SEMAPHORE_HANDLE_DESC;
 
```
where ::CUDA_EXTERNAL_SEMAPHORE_HANDLE_DESC::type specifies the type of handle being imported. ::CUexternalSemaphoreHandleType is defined as:
```
        typedef enum CUexternalSemaphoreHandleType_enum {
            CU_EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_FD             = 1,
            CU_EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_WIN32          = 2,
            CU_EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_WIN32_KMT      = 3,
            CU_EXTERNAL_SEMAPHORE_HANDLE_TYPE_D3D12_FENCE           = 4,
            CU_EXTERNAL_SEMAPHORE_HANDLE_TYPE_D3D11_FENCE           = 5,
            CU_EXTERNAL_SEMAPHORE_HANDLE_TYPE_NVSCISYNC             = 6,
		    CU_EXTERNAL_SEMAPHORE_HANDLE_TYPE_D3D11_KEYED_MUTEX     = 7,
            CU_EXTERNAL_SEMAPHORE_HANDLE_TYPE_D3D11_KEYED_MUTEX_KMT = 8
        } CUexternalSemaphoreHandleType;
 
```
If ::CUDA_EXTERNAL_SEMAPHORE_HANDLE_DESC::type is ::CU_EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_FD, then ::CUDA_EXTERNAL_SEMAPHORE_HANDLE_DESC::handle::fd must be a valid file descriptor referencing a synchronization object. Ownership of the file descriptor is transferred to the CUDA driver when the handle is imported successfully. Performing any operations on the file descriptor after it is imported results in undefined behavior. If ::CUDA_EXTERNAL_SEMAPHORE_HANDLE_DESC::type is ::CU_EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_WIN32, then exactly one of ::CUDA_EXTERNAL_SEMAPHORE_HANDLE_DESC::handle::win32::handle and ::CUDA_EXTERNAL_SEMAPHORE_HANDLE_DESC::handle::win32::name must not be NULL. If ::CUDA_EXTERNAL_SEMAPHORE_HANDLE_DESC::handle::win32::handle is not NULL, then it must represent a valid shared NT handle that references a synchronization object. Ownership of this handle is not transferred to CUDA after the import operation, so the application must release the handle using the appropriate system call. If ::CUDA_EXTERNAL_SEMAPHORE_HANDLE_DESC::handle::win32::name is not NULL, then it must name a valid synchronization object. If ::CUDA_EXTERNAL_SEMAPHORE_HANDLE_DESC::type is ::CU_EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_WIN32_KMT, then ::CUDA_EXTERNAL_SEMAPHORE_HANDLE_DESC::handle::win32::handle must be non-NULL and ::CUDA_EXTERNAL_SEMAPHORE_HANDLE_DESC::handle::win32::name must be NULL. The handle specified must be a globally shared KMT handle. This handle does not hold a reference to the underlying object, and thus will be invalid when all references to the synchronization object are destroyed. If ::CUDA_EXTERNAL_SEMAPHORE_HANDLE_DESC::type is ::CU_EXTERNAL_SEMAPHORE_HANDLE_TYPE_D3D12_FENCE, then exactly one of ::CUDA_EXTERNAL_SEMAPHORE_HANDLE_DESC::handle::win32::handle and ::CUDA_EXTERNAL_SEMAPHORE_HANDLE_DESC::handle::win32::name must not be NULL. If ::CUDA_EXTERNAL_SEMAPHORE_HANDLE_DESC::handle::win32::handle is not NULL, then it must represent a valid shared NT handle that is returned by ID3D12Device::CreateSharedHandle when referring to a ID3D12Fence object. This handle holds a reference to the underlying object. If ::CUDA_EXTERNAL_SEMAPHORE_HANDLE_DESC::handle::win32::name is not NULL, then it must name a valid synchronization object that refers to a valid ID3D12Fence object. If ::CUDA_EXTERNAL_SEMAPHORE_HANDLE_DESC::type is ::CU_EXTERNAL_SEMAPHORE_HANDLE_TYPE_D3D11_FENCE, then ::CUDA_EXTERNAL_SEMAPHORE_HANDLE_DESC::handle::win32::handle represents a valid shared NT handle that is returned by ID3D11Fence::CreateSharedHandle. If ::CUDA_EXTERNAL_SEMAPHORE_HANDLE_DESC::handle::win32::name is not NULL, then it must name a valid synchronization object that refers to a valid ID3D11Fence object. If ::CUDA_EXTERNAL_SEMAPHORE_HANDLE_DESC::type is ::CU_EXTERNAL_SEMAPHORE_HANDLE_TYPE_NVSCISYNC, then ::CUDA_EXTERNAL_SEMAPHORE_HANDLE_DESC::handle::nvSciSyncObj represents a valid NvSciSyncObj. ::CU_EXTERNAL_SEMAPHORE_HANDLE_TYPE_D3D11_KEYED_MUTEX, then ::CUDA_EXTERNAL_SEMAPHORE_HANDLE_DESC::handle::win32::handle represents a valid shared NT handle that is returned by IDXGIResource1::CreateSharedHandle when referring to a IDXGIKeyedMutex object. If ::CUDA_EXTERNAL_SEMAPHORE_HANDLE_DESC::handle::win32::name is not NULL, then it must name a valid synchronization object that refers to a valid IDXGIKeyedMutex object. If ::CUDA_EXTERNAL_SEMAPHORE_HANDLE_DESC::type is ::CU_EXTERNAL_SEMAPHORE_HANDLE_TYPE_D3D11_KEYED_MUTEX_KMT, then ::CUDA_EXTERNAL_SEMAPHORE_HANDLE_DESC::handle::win32::handle represents a valid shared KMT handle that is returned by IDXGIResource::GetSharedHandle when referring to a IDXGIKeyedMutex object and ::CUDA_EXTERNAL_SEMAPHORE_HANDLE_DESC::handle::win32::name must be NULL.
Parameters:

extSem_out - - Returned handle to an external semaphore

semHandleDesc - - Semaphore import handle descriptor

Returns:

::CUDA_SUCCESS, ::CUDA_ERROR_NOT_INITIALIZED, ::CUDA_ERROR_NOT_SUPPORTED, ::CUDA_ERROR_INVALID_HANDLE \notefnerr

cuSignalExternalSemaphoresAsync
```
@Cast("CUresult")
public static int cuSignalExternalSemaphoresAsync(@Cast("const CUexternalSemaphore*") @ByPtrPtr
                                                  CUextSemaphore_st extSemArray,
                                                  @Const
                                                  CUDA_EXTERNAL_SEMAPHORE_SIGNAL_PARAMS paramsArray,
                                                  @Cast("unsigned int")
                                                  int numExtSems,
                                                  CUstream_st stream)
```
\brief Signals a set of external semaphore objects Enqueues a signal operation on a set of externally allocated semaphore object in the specified stream. The operations will be executed when all prior operations in the stream complete. The exact semantics of signaling a semaphore depends on the type of the object. If the semaphore object is any one of the following types: ::CU_EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_FD, ::CU_EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_WIN32, ::CU_EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_WIN32_KMT then signaling the semaphore will set it to the signaled state. If the semaphore object is any one of the following types: ::CU_EXTERNAL_SEMAPHORE_HANDLE_TYPE_D3D12_FENCE, ::CU_EXTERNAL_SEMAPHORE_HANDLE_TYPE_D3D11_FENCE then the semaphore will be set to the value specified in ::CUDA_EXTERNAL_SEMAPHORE_SIGNAL_PARAMS::params::fence::value. If the semaphore object is of the type ::CU_EXTERNAL_SEMAPHORE_HANDLE_TYPE_NVSCISYNC this API sets ::CUDA_EXTERNAL_SEMAPHORE_SIGNAL_PARAMS::params::nvSciSync::fence to a value that can be used by subsequent waiters of the same NvSciSync object to order operations with those currently submitted in \p stream. Such an update will overwrite previous contents of ::CUDA_EXTERNAL_SEMAPHORE_SIGNAL_PARAMS::params::nvSciSync::fence. By default, signaling such an external semaphore object causes appropriate memory synchronization operations to be performed over all external memory objects that are imported as ::CU_EXTERNAL_MEMORY_HANDLE_TYPE_NVSCIBUF. This ensures that any subsequent accesses made by other importers of the same set of NvSciBuf memory object(s) are coherent. These operations can be skipped by specifying the flag ::CUDA_EXTERNAL_SEMAPHORE_SIGNAL_SKIP_NVSCIBUF_MEMSYNC, which can be used as a performance optimization when data coherency is not required. But specifying this flag in scenarios where data coherency is required results in undefined behavior. Also, for semaphore object of the type ::CU_EXTERNAL_SEMAPHORE_HANDLE_TYPE_NVSCISYNC, if the NvSciSyncAttrList used to create the NvSciSyncObj had not set the flags in ::cuDeviceGetNvSciSyncAttributes to CUDA_NVSCISYNC_ATTR_SIGNAL, this API will return CUDA_ERROR_NOT_SUPPORTED. If the semaphore object is any one of the following types: ::CU_EXTERNAL_SEMAPHORE_HANDLE_TYPE_D3D11_KEYED_MUTEX, ::CU_EXTERNAL_SEMAPHORE_HANDLE_TYPE_D3D11_KEYED_MUTEX_KMT then the keyed mutex will be released with the key specified in ::CUDA_EXTERNAL_SEMAPHORE_PARAMS::params::keyedmutex::key.

Parameters:

extSemArray - - Set of external semaphores to be signaled

paramsArray - - Array of semaphore parameters

numExtSems - - Number of semaphores to signal

stream - - Stream to enqueue the signal operations in

Returns:

::CUDA_SUCCESS, ::CUDA_ERROR_NOT_INITIALIZED, ::CUDA_ERROR_INVALID_HANDLE, ::CUDA_ERROR_NOT_SUPPORTED \notefnerr

cuWaitExternalSemaphoresAsync
```
@Cast("CUresult")
public static int cuWaitExternalSemaphoresAsync(@Cast("const CUexternalSemaphore*") @ByPtrPtr
                                                CUextSemaphore_st extSemArray,
                                                @Const
                                                CUDA_EXTERNAL_SEMAPHORE_WAIT_PARAMS paramsArray,
                                                @Cast("unsigned int")
                                                int numExtSems,
                                                CUstream_st stream)
```
\brief Waits on a set of external semaphore objects Enqueues a wait operation on a set of externally allocated semaphore object in the specified stream. The operations will be executed when all prior operations in the stream complete. The exact semantics of waiting on a semaphore depends on the type of the object. If the semaphore object is any one of the following types: ::CU_EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_FD, ::CU_EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_WIN32, ::CU_EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_WIN32_KMT then waiting on the semaphore will wait until the semaphore reaches the signaled state. The semaphore will then be reset to the unsignaled state. Therefore for every signal operation, there can only be one wait operation. If the semaphore object is any one of the following types: ::CU_EXTERNAL_SEMAPHORE_HANDLE_TYPE_D3D12_FENCE, ::CU_EXTERNAL_SEMAPHORE_HANDLE_TYPE_D3D11_FENCE then waiting on the semaphore will wait until the value of the semaphore is greater than or equal to ::CUDA_EXTERNAL_SEMAPHORE_WAIT_PARAMS::params::fence::value. If the semaphore object is of the type ::CU_EXTERNAL_SEMAPHORE_HANDLE_TYPE_NVSCISYNC then, waiting on the semaphore will wait until the ::CUDA_EXTERNAL_SEMAPHORE_SIGNAL_PARAMS::params::nvSciSync::fence is signaled by the signaler of the NvSciSyncObj that was associated with this semaphore object. By default, waiting on such an external semaphore object causes appropriate memory synchronization operations to be performed over all external memory objects that are imported as ::CU_EXTERNAL_MEMORY_HANDLE_TYPE_NVSCIBUF. This ensures that any subsequent accesses made by other importers of the same set of NvSciBuf memory object(s) are coherent. These operations can be skipped by specifying the flag ::CUDA_EXTERNAL_SEMAPHORE_WAIT_SKIP_NVSCIBUF_MEMSYNC, which can be used as a performance optimization when data coherency is not required. But specifying this flag in scenarios where data coherency is required results in undefined behavior. Also, for semaphore object of the type ::CU_EXTERNAL_SEMAPHORE_HANDLE_TYPE_NVSCISYNC, if the NvSciSyncAttrList used to create the NvSciSyncObj had not set the flags in ::cuDeviceGetNvSciSyncAttributes to CUDA_NVSCISYNC_ATTR_WAIT, this API will return CUDA_ERROR_NOT_SUPPORTED. If the semaphore object is any one of the following types: ::CU_EXTERNAL_SEMAPHORE_HANDLE_TYPE_D3D11_KEYED_MUTEX, ::CU_EXTERNAL_SEMAPHORE_HANDLE_TYPE_D3D11_KEYED_MUTEX_KMT then the keyed mutex will be acquired when it is released with the key specified in ::CUDA_EXTERNAL_SEMAPHORE_WAIT_PARAMS::params::keyedmutex::key or until the timeout specified by ::CUDA_EXTERNAL_SEMAPHORE_WAIT_PARAMS::params::keyedmutex::timeoutMs has lapsed. The timeout interval can either be a finite value specified in milliseconds or an infinite value. In case an infinite value is specified the timeout never elapses. The windows INFINITE macro must be used to specify infinite timeout.

Parameters:

extSemArray - - External semaphores to be waited on

paramsArray - - Array of semaphore parameters

numExtSems - - Number of semaphores to wait on

stream - - Stream to enqueue the wait operations in

Returns:

::CUDA_SUCCESS, ::CUDA_ERROR_NOT_INITIALIZED, ::CUDA_ERROR_INVALID_HANDLE, ::CUDA_ERROR_NOT_SUPPORTED, ::CUDA_ERROR_TIMEOUT \notefnerr

cuDestroyExternalSemaphore
```
@Cast("CUresult")
public static int cuDestroyExternalSemaphore(CUextSemaphore_st extSem)
```
\brief Destroys an external semaphore Destroys an external semaphore object and releases any references to the underlying resource. Any outstanding signals or waits must have completed before the semaphore is destroyed.

Parameters:

extSem - - External semaphore to be destroyed

Returns:

::CUDA_SUCCESS, ::CUDA_ERROR_NOT_INITIALIZED, ::CUDA_ERROR_INVALID_HANDLE \notefnerr

cuStreamWaitValue32
```
@Cast("CUresult")
public static int cuStreamWaitValue32(CUstream_st stream,
                                      @Cast("CUdeviceptr")
                                      long addr,
                                      @Cast("cuuint32_t")
                                      int value,
                                      @Cast("unsigned int")
                                      int flags)
```
\brief Wait on a memory location Enqueues a synchronization of the stream on the given memory location. Work ordered after the operation will block until the given condition on the memory is satisfied. By default, the condition is to wait for (int32_t)(*addr - value) >= 0, a cyclic greater-or-equal. Other condition types can be specified via \p flags. If the memory was registered via ::cuMemHostRegister(), the device pointer should be obtained with ::cuMemHostGetDevicePointer(). This function cannot be used with managed memory (::cuMemAllocManaged). Support for this can be queried with ::cuDeviceGetAttribute() and ::CU_DEVICE_ATTRIBUTE_CAN_USE_STREAM_MEM_OPS. Support for CU_STREAM_WAIT_VALUE_NOR can be queried with ::cuDeviceGetAttribute() and ::CU_DEVICE_ATTRIBUTE_CAN_USE_STREAM_WAIT_VALUE_NOR.

Parameters:

stream - The stream to synchronize on the memory location.

addr - The memory location to wait on.

value - The value to compare with the memory location.

flags - See ::CUstreamWaitValue_flags.

Returns:

::CUDA_SUCCESS, ::CUDA_ERROR_INVALID_VALUE, ::CUDA_ERROR_NOT_SUPPORTED \notefnerr

cuStreamWaitValue64
```
@Cast("CUresult")
public static int cuStreamWaitValue64(CUstream_st stream,
                                      @Cast("CUdeviceptr")
                                      long addr,
                                      @Cast("cuuint64_t")
                                      int value,
                                      @Cast("unsigned int")
                                      int flags)
```
\brief Wait on a memory location Enqueues a synchronization of the stream on the given memory location. Work ordered after the operation will block until the given condition on the memory is satisfied. By default, the condition is to wait for (int64_t)(*addr - value) >= 0, a cyclic greater-or-equal. Other condition types can be specified via \p flags. If the memory was registered via ::cuMemHostRegister(), the device pointer should be obtained with ::cuMemHostGetDevicePointer(). Support for this can be queried with ::cuDeviceGetAttribute() and ::CU_DEVICE_ATTRIBUTE_CAN_USE_64_BIT_STREAM_MEM_OPS.

Parameters:

stream - The stream to synchronize on the memory location.

addr - The memory location to wait on.

value - The value to compare with the memory location.

flags - See ::CUstreamWaitValue_flags.

Returns:

::CUDA_SUCCESS, ::CUDA_ERROR_INVALID_VALUE, ::CUDA_ERROR_NOT_SUPPORTED \notefnerr

cuStreamWriteValue32
```
@Cast("CUresult")
public static int cuStreamWriteValue32(CUstream_st stream,
                                       @Cast("CUdeviceptr")
                                       long addr,
                                       @Cast("cuuint32_t")
                                       int value,
                                       @Cast("unsigned int")
                                       int flags)
```
\brief Write a value to memory Write a value to memory. Unless the ::CU_STREAM_WRITE_VALUE_NO_MEMORY_BARRIER flag is passed, the write is preceded by a system-wide memory fence, equivalent to a __threadfence_system() but scoped to the stream rather than a CUDA thread. If the memory was registered via ::cuMemHostRegister(), the device pointer should be obtained with ::cuMemHostGetDevicePointer(). This function cannot be used with managed memory (::cuMemAllocManaged). Support for this can be queried with ::cuDeviceGetAttribute() and ::CU_DEVICE_ATTRIBUTE_CAN_USE_STREAM_MEM_OPS.

Parameters:

stream - The stream to do the write in.

addr - The device address to write to.

value - The value to write.

flags - See ::CUstreamWriteValue_flags.

Returns:

::CUDA_SUCCESS, ::CUDA_ERROR_INVALID_VALUE, ::CUDA_ERROR_NOT_SUPPORTED \notefnerr

cuStreamWriteValue64
```
@Cast("CUresult")
public static int cuStreamWriteValue64(CUstream_st stream,
                                       @Cast("CUdeviceptr")
                                       long addr,
                                       @Cast("cuuint64_t")
                                       int value,
                                       @Cast("unsigned int")
                                       int flags)
```
\brief Write a value to memory Write a value to memory. Unless the ::CU_STREAM_WRITE_VALUE_NO_MEMORY_BARRIER flag is passed, the write is preceded by a system-wide memory fence, equivalent to a __threadfence_system() but scoped to the stream rather than a CUDA thread. If the memory was registered via ::cuMemHostRegister(), the device pointer should be obtained with ::cuMemHostGetDevicePointer(). Support for this can be queried with ::cuDeviceGetAttribute() and ::CU_DEVICE_ATTRIBUTE_CAN_USE_64_BIT_STREAM_MEM_OPS.

Parameters:

stream - The stream to do the write in.

addr - The device address to write to.

value - The value to write.

flags - See ::CUstreamWriteValue_flags.

Returns:

::CUDA_SUCCESS, ::CUDA_ERROR_INVALID_VALUE, ::CUDA_ERROR_NOT_SUPPORTED \notefnerr

cuStreamBatchMemOp
```
@Cast("CUresult")
public static int cuStreamBatchMemOp(CUstream_st stream,
                                     @Cast("unsigned int")
                                     int count,
                                     CUstreamBatchMemOpParams paramArray,
                                     @Cast("unsigned int")
                                     int flags)
```
\brief Batch operations to synchronize the stream via memory operations This is a batch version of ::cuStreamWaitValue32() and ::cuStreamWriteValue32(). Batching operations may avoid some performance overhead in both the API call and the device execution versus adding them to the stream in separate API calls. The operations are enqueued in the order they appear in the array. See ::CUstreamBatchMemOpType for the full set of supported operations, and ::cuStreamWaitValue32(), ::cuStreamWaitValue64(), ::cuStreamWriteValue32(), and ::cuStreamWriteValue64() for details of specific operations. Basic support for this can be queried with ::cuDeviceGetAttribute() and ::CU_DEVICE_ATTRIBUTE_CAN_USE_STREAM_MEM_OPS. See related APIs for details on querying support for specific operations.

Parameters:

stream - The stream to enqueue the operations in.

count - The number of operations in the array. Must be less than 256.

paramArray - The types and parameters of the individual operations.

flags - Reserved for future expansion; must be 0.

Returns:

::CUDA_SUCCESS, ::CUDA_ERROR_INVALID_VALUE, ::CUDA_ERROR_NOT_SUPPORTED \notefnerr

cuFuncGetAttribute
```
@Cast("CUresult")
public static int cuFuncGetAttribute(IntPointer pi,
                                     @Cast("CUfunction_attribute")
                                     int attrib,
                                     CUfunc_st hfunc)
```
\brief Returns information about a function Returns in \p *pi the integer value of the attribute \p attrib on the kernel given by \p hfunc. The supported attributes are: - ::CU_FUNC_ATTRIBUTE_MAX_THREADS_PER_BLOCK: The maximum number of threads per block, beyond which a launch of the function would fail. This number depends on both the function and the device on which the function is currently loaded. - ::CU_FUNC_ATTRIBUTE_SHARED_SIZE_BYTES: The size in bytes of statically-allocated shared memory per block required by this function. This does not include dynamically-allocated shared memory requested by the user at runtime. - ::CU_FUNC_ATTRIBUTE_CONST_SIZE_BYTES: The size in bytes of user-allocated constant memory required by this function. - ::CU_FUNC_ATTRIBUTE_LOCAL_SIZE_BYTES: The size in bytes of local memory used by each thread of this function. - ::CU_FUNC_ATTRIBUTE_NUM_REGS: The number of registers used by each thread of this function. - ::CU_FUNC_ATTRIBUTE_PTX_VERSION: The PTX virtual architecture version for which the function was compiled. This value is the major PTX version * 10 + the minor PTX version, so a PTX version 1.3 function would return the value 13. Note that this may return the undefined value of 0 for cubins compiled prior to CUDA 3.0. - ::CU_FUNC_ATTRIBUTE_BINARY_VERSION: The binary architecture version for which the function was compiled. This value is the major binary version * 10 + the minor binary version, so a binary version 1.3 function would return the value 13. Note that this will return a value of 10 for legacy cubins that do not have a properly-encoded binary architecture version. - ::CU_FUNC_CACHE_MODE_CA: The attribute to indicate whether the function has been compiled with user specified option "-Xptxas --dlcm=ca" set . - ::CU_FUNC_ATTRIBUTE_MAX_DYNAMIC_SHARED_SIZE_BYTES: The maximum size in bytes of dynamically-allocated shared memory. - ::CU_FUNC_ATTRIBUTE_PREFERRED_SHARED_MEMORY_CARVEOUT: Preferred shared memory-L1 cache split ratio in percent of total shared memory.

Parameters:

pi - - Returned attribute value

attrib - - Attribute requested

hfunc - - Function to query attribute of

Returns:

::CUDA_SUCCESS, ::CUDA_ERROR_DEINITIALIZED, ::CUDA_ERROR_NOT_INITIALIZED, ::CUDA_ERROR_INVALID_CONTEXT, ::CUDA_ERROR_INVALID_HANDLE, ::CUDA_ERROR_INVALID_VALUE \notefnerr

cuFuncGetAttribute

@Cast("CUresult")
public static int cuFuncGetAttribute(IntBuffer pi,
                                     @Cast("CUfunction_attribute")
                                     int attrib,
                                     CUfunc_st hfunc)

cuFuncGetAttribute

@Cast("CUresult")
public static int cuFuncGetAttribute(int[] pi,
                                     @Cast("CUfunction_attribute")
                                     int attrib,
                                     CUfunc_st hfunc)

cuFuncSetAttribute
```
@Cast("CUresult")
public static int cuFuncSetAttribute(CUfunc_st hfunc,
                                     @Cast("CUfunction_attribute")
                                     int attrib,
                                     int value)
```
\brief Sets information about a function This call sets the value of a specified attribute \p attrib on the kernel given by \p hfunc to an integer value specified by \p val This function returns CUDA_SUCCESS if the new value of the attribute could be successfully set. If the set fails, this call will return an error. Not all attributes can have values set. Attempting to set a value on a read-only attribute will result in an error (CUDA_ERROR_INVALID_VALUE) Supported attributes for the cuFuncSetAttribute call are: - ::CU_FUNC_ATTRIBUTE_MAX_DYNAMIC_SHARED_SIZE_BYTES: This maximum size in bytes of dynamically-allocated shared memory. The value should contain the requested maximum size of dynamically-allocated shared memory. The sum of this value and the function attribute ::CU_FUNC_ATTRIBUTE_SHARED_SIZE_BYTES cannot exceed the device attribute ::CU_DEVICE_ATTRIBUTE_MAX_SHARED_MEMORY_PER_BLOCK_OPTIN. The maximal size of requestable dynamic shared memory may differ by GPU architecture. - ::CU_FUNC_ATTRIBUTE_PREFERRED_SHARED_MEMORY_CARVEOUT: On devices where the L1 cache and shared memory use the same hardware resources, this sets the shared memory carveout preference, in percent of the total shared memory. See ::CU_DEVICE_ATTRIBUTE_MAX_SHARED_MEMORY_PER_MULTIPROCESSOR This is only a hint, and the driver can choose a different ratio if required to execute the function.

Parameters:

hfunc - - Function to query attribute of

attrib - - Attribute requested

value - - The value to set

Returns:

::CUDA_SUCCESS, ::CUDA_ERROR_DEINITIALIZED, ::CUDA_ERROR_NOT_INITIALIZED, ::CUDA_ERROR_INVALID_CONTEXT, ::CUDA_ERROR_INVALID_HANDLE, ::CUDA_ERROR_INVALID_VALUE \notefnerr

cuFuncSetCacheConfig
```
@Cast("CUresult")
public static int cuFuncSetCacheConfig(CUfunc_st hfunc,
                                       @Cast("CUfunc_cache")
                                       int config)
```
\brief Sets the preferred cache configuration for a device function On devices where the L1 cache and shared memory use the same hardware resources, this sets through \p config the preferred cache configuration for the device function \p hfunc. This is only a preference. The driver will use the requested configuration if possible, but it is free to choose a different configuration if required to execute \p hfunc. Any context-wide preference set via ::cuCtxSetCacheConfig() will be overridden by this per-function setting unless the per-function setting is ::CU_FUNC_CACHE_PREFER_NONE. In that case, the current context-wide setting will be used. This setting does nothing on devices where the size of the L1 cache and shared memory are fixed. Launching a kernel with a different preference than the most recent preference setting may insert a device-side synchronization point. The supported cache configurations are: - ::CU_FUNC_CACHE_PREFER_NONE: no preference for shared memory or L1 (default) - ::CU_FUNC_CACHE_PREFER_SHARED: prefer larger shared memory and smaller L1 cache - ::CU_FUNC_CACHE_PREFER_L1: prefer larger L1 cache and smaller shared memory - ::CU_FUNC_CACHE_PREFER_EQUAL: prefer equal sized L1 cache and shared memory

Parameters:

hfunc - - Kernel to configure cache for

config - - Requested cache configuration

Returns:

::CUDA_SUCCESS, ::CUDA_ERROR_INVALID_VALUE, ::CUDA_ERROR_DEINITIALIZED, ::CUDA_ERROR_NOT_INITIALIZED, ::CUDA_ERROR_INVALID_CONTEXT \notefnerr

cuFuncSetSharedMemConfig
```
@Cast("CUresult")
public static int cuFuncSetSharedMemConfig(CUfunc_st hfunc,
                                           @Cast("CUsharedconfig")
                                           int config)
```
\brief Sets the shared memory configuration for a device function. On devices with configurable shared memory banks, this function will force all subsequent launches of the specified device function to have the given shared memory bank size configuration. On any given launch of the function, the shared memory configuration of the device will be temporarily changed if needed to suit the function's preferred configuration. Changes in shared memory configuration between subsequent launches of functions, may introduce a device side synchronization point. Any per-function setting of shared memory bank size set via ::cuFuncSetSharedMemConfig will override the context wide setting set with ::cuCtxSetSharedMemConfig. Changing the shared memory bank size will not increase shared memory usage or affect occupancy of kernels, but may have major effects on performance. Larger bank sizes will allow for greater potential bandwidth to shared memory, but will change what kinds of accesses to shared memory will result in bank conflicts. This function will do nothing on devices with fixed shared memory bank size. The supported bank configurations are: - ::CU_SHARED_MEM_CONFIG_DEFAULT_BANK_SIZE: use the context's shared memory configuration when launching this function. - ::CU_SHARED_MEM_CONFIG_FOUR_BYTE_BANK_SIZE: set shared memory bank width to be natively four bytes when launching this function. - ::CU_SHARED_MEM_CONFIG_EIGHT_BYTE_BANK_SIZE: set shared memory bank width to be natively eight bytes when launching this function.

Parameters:

hfunc - - kernel to be given a shared memory config

config - - requested shared memory configuration

Returns:

::CUDA_SUCCESS, ::CUDA_ERROR_INVALID_VALUE, ::CUDA_ERROR_DEINITIALIZED, ::CUDA_ERROR_NOT_INITIALIZED, ::CUDA_ERROR_INVALID_CONTEXT \notefnerr

cuLaunchKernel
```
@Cast("CUresult")
public static int cuLaunchKernel(CUfunc_st f,
                                 @Cast("unsigned int")
                                 int gridDimX,
                                 @Cast("unsigned int")
                                 int gridDimY,
                                 @Cast("unsigned int")
                                 int gridDimZ,
                                 @Cast("unsigned int")
                                 int blockDimX,
                                 @Cast("unsigned int")
                                 int blockDimY,
                                 @Cast("unsigned int")
                                 int blockDimZ,
                                 @Cast("unsigned int")
                                 int sharedMemBytes,
                                 CUstream_st hStream,
                                 @Cast("void**")
                                 PointerPointer kernelParams,
                                 @Cast("void**")
                                 PointerPointer extra)
```
\brief Launches a CUDA function Invokes the kernel \p f on a \p gridDimX x \p gridDimY x \p gridDimZ grid of blocks. Each block contains \p blockDimX x \p blockDimY x \p blockDimZ threads. \p sharedMemBytes sets the amount of dynamic shared memory that will be available to each thread block. Kernel parameters to \p f can be specified in one of two ways: 1) Kernel parameters can be specified via \p kernelParams. If \p f has N parameters, then \p kernelParams needs to be an array of N pointers. Each of \p kernelParams[0] through \p kernelParams[N-1] must point to a region of memory from which the actual kernel parameter will be copied. The number of kernel parameters and their offsets and sizes do not need to be specified as that information is retrieved directly from the kernel's image. 2) Kernel parameters can also be packaged by the application into a single buffer that is passed in via the \p extra parameter. This places the burden on the application of knowing each kernel parameter's size and alignment/padding within the buffer. Here is an example of using the \p extra parameter in this manner:
```
    size_t argBufferSize;
    char argBuffer[256];

    // populate argBuffer and argBufferSize

    void *config[] = {
        CU_LAUNCH_PARAM_BUFFER_POINTER, argBuffer,
        CU_LAUNCH_PARAM_BUFFER_SIZE,    &argBufferSize,
        CU_LAUNCH_PARAM_END
    };
    status = cuLaunchKernel(f, gx, gy, gz, bx, by, bz, sh, s, NULL, config);
 
```
The \p extra parameter exists to allow ::cuLaunchKernel to take additional less commonly used arguments. \p extra specifies a list of names of extra settings and their corresponding values. Each extra setting name is immediately followed by the corresponding value. The list must be terminated with either NULL or ::CU_LAUNCH_PARAM_END. - ::CU_LAUNCH_PARAM_END, which indicates the end of the \p extra array; - ::CU_LAUNCH_PARAM_BUFFER_POINTER, which specifies that the next value in \p extra will be a pointer to a buffer containing all the kernel parameters for launching kernel \p f; - ::CU_LAUNCH_PARAM_BUFFER_SIZE, which specifies that the next value in \p extra will be a pointer to a size_t containing the size of the buffer specified with ::CU_LAUNCH_PARAM_BUFFER_POINTER; The error ::CUDA_ERROR_INVALID_VALUE will be returned if kernel parameters are specified with both \p kernelParams and \p extra (i.e. both \p kernelParams and \p extra are non-NULL). Calling ::cuLaunchKernel() sets persistent function state that is the same as function state set through the following deprecated APIs: ::cuFuncSetBlockShape(), ::cuFuncSetSharedSize(), ::cuParamSetSize(), ::cuParamSeti(), ::cuParamSetf(), ::cuParamSetv(). When the kernel \p f is launched via ::cuLaunchKernel(), the previous block shape, shared size and parameter info associated with \p f is overwritten. Note that to use ::cuLaunchKernel(), the kernel \p f must either have been compiled with toolchain version 3.2 or later so that it will contain kernel parameter information, or have no kernel parameters. If either of these conditions is not met, then ::cuLaunchKernel() will return ::CUDA_ERROR_INVALID_IMAGE.
Parameters:

f - - Kernel to launch

gridDimX - - Width of grid in blocks

gridDimY - - Height of grid in blocks

gridDimZ - - Depth of grid in blocks

blockDimX - - X dimension of each thread block

blockDimY - - Y dimension of each thread block

blockDimZ - - Z dimension of each thread block

sharedMemBytes - - Dynamic shared-memory size per thread block in bytes

hStream - - Stream identifier

kernelParams - - Array of pointers to kernel parameters

extra - - Extra options

Returns:

::CUDA_SUCCESS, ::CUDA_ERROR_DEINITIALIZED, ::CUDA_ERROR_NOT_INITIALIZED, ::CUDA_ERROR_INVALID_CONTEXT, ::CUDA_ERROR_INVALID_HANDLE, ::CUDA_ERROR_INVALID_IMAGE, ::CUDA_ERROR_INVALID_VALUE, ::CUDA_ERROR_LAUNCH_FAILED, ::CUDA_ERROR_LAUNCH_OUT_OF_RESOURCES, ::CUDA_ERROR_LAUNCH_TIMEOUT, ::CUDA_ERROR_LAUNCH_INCOMPATIBLE_TEXTURING, ::CUDA_ERROR_SHARED_OBJECT_INIT_FAILED \note_null_stream \notefnerr

cuLaunchKernel

@Cast("CUresult")
public static int cuLaunchKernel(CUfunc_st f,
                                 @Cast("unsigned int")
                                 int gridDimX,
                                 @Cast("unsigned int")
                                 int gridDimY,
                                 @Cast("unsigned int")
                                 int gridDimZ,
                                 @Cast("unsigned int")
                                 int blockDimX,
                                 @Cast("unsigned int")
                                 int blockDimY,
                                 @Cast("unsigned int")
                                 int blockDimZ,
                                 @Cast("unsigned int")
                                 int sharedMemBytes,
                                 CUstream_st hStream,
                                 @Cast("void**") @ByPtrPtr
                                 Pointer kernelParams,
                                 @Cast("void**") @ByPtrPtr
                                 Pointer extra)

cuLaunchCooperativeKernel
```
@Cast("CUresult")
public static int cuLaunchCooperativeKernel(CUfunc_st f,
                                            @Cast("unsigned int")
                                            int gridDimX,
                                            @Cast("unsigned int")
                                            int gridDimY,
                                            @Cast("unsigned int")
                                            int gridDimZ,
                                            @Cast("unsigned int")
                                            int blockDimX,
                                            @Cast("unsigned int")
                                            int blockDimY,
                                            @Cast("unsigned int")
                                            int blockDimZ,
                                            @Cast("unsigned int")
                                            int sharedMemBytes,
                                            CUstream_st hStream,
                                            @Cast("void**")
                                            PointerPointer kernelParams)
```
\brief Launches a CUDA function where thread blocks can cooperate and synchronize as they execute Invokes the kernel \p f on a \p gridDimX x \p gridDimY x \p gridDimZ grid of blocks. Each block contains \p blockDimX x \p blockDimY x \p blockDimZ threads. \p sharedMemBytes sets the amount of dynamic shared memory that will be available to each thread block. The device on which this kernel is invoked must have a non-zero value for the device attribute ::CU_DEVICE_ATTRIBUTE_COOPERATIVE_LAUNCH. The total number of blocks launched cannot exceed the maximum number of blocks per multiprocessor as returned by ::cuOccupancyMaxActiveBlocksPerMultiprocessor (or ::cuOccupancyMaxActiveBlocksPerMultiprocessorWithFlags) times the number of multiprocessors as specified by the device attribute ::CU_DEVICE_ATTRIBUTE_MULTIPROCESSOR_COUNT. The kernel cannot make use of CUDA dynamic parallelism. Kernel parameters must be specified via \p kernelParams. If \p f has N parameters, then \p kernelParams needs to be an array of N pointers. Each of \p kernelParams[0] through \p kernelParams[N-1] must point to a region of memory from which the actual kernel parameter will be copied. The number of kernel parameters and their offsets and sizes do not need to be specified as that information is retrieved directly from the kernel's image. Calling ::cuLaunchCooperativeKernel() sets persistent function state that is the same as function state set through ::cuLaunchKernel API When the kernel \p f is launched via ::cuLaunchCooperativeKernel(), the previous block shape, shared size and parameter info associated with \p f is overwritten. Note that to use ::cuLaunchCooperativeKernel(), the kernel \p f must either have been compiled with toolchain version 3.2 or later so that it will contain kernel parameter information, or have no kernel parameters. If either of these conditions is not met, then ::cuLaunchCooperativeKernel() will return ::CUDA_ERROR_INVALID_IMAGE.

Parameters:

f - - Kernel to launch

gridDimX - - Width of grid in blocks

gridDimY - - Height of grid in blocks

gridDimZ - - Depth of grid in blocks

blockDimX - - X dimension of each thread block

blockDimY - - Y dimension of each thread block

blockDimZ - - Z dimension of each thread block

sharedMemBytes - - Dynamic shared-memory size per thread block in bytes

hStream - - Stream identifier

kernelParams - - Array of pointers to kernel parameters

Returns:

::CUDA_SUCCESS, ::CUDA_ERROR_DEINITIALIZED, ::CUDA_ERROR_NOT_INITIALIZED, ::CUDA_ERROR_INVALID_CONTEXT, ::CUDA_ERROR_INVALID_HANDLE, ::CUDA_ERROR_INVALID_IMAGE, ::CUDA_ERROR_INVALID_VALUE, ::CUDA_ERROR_LAUNCH_FAILED, ::CUDA_ERROR_LAUNCH_OUT_OF_RESOURCES, ::CUDA_ERROR_LAUNCH_TIMEOUT, ::CUDA_ERROR_LAUNCH_INCOMPATIBLE_TEXTURING, ::CUDA_ERROR_COOPERATIVE_LAUNCH_TOO_LARGE, ::CUDA_ERROR_SHARED_OBJECT_INIT_FAILED \note_null_stream \notefnerr

cuLaunchCooperativeKernel

@Cast("CUresult")
public static int cuLaunchCooperativeKernel(CUfunc_st f,
                                            @Cast("unsigned int")
                                            int gridDimX,
                                            @Cast("unsigned int")
                                            int gridDimY,
                                            @Cast("unsigned int")
                                            int gridDimZ,
                                            @Cast("unsigned int")
                                            int blockDimX,
                                            @Cast("unsigned int")
                                            int blockDimY,
                                            @Cast("unsigned int")
                                            int blockDimZ,
                                            @Cast("unsigned int")
                                            int sharedMemBytes,
                                            CUstream_st hStream,
                                            @Cast("void**") @ByPtrPtr
                                            Pointer kernelParams)

cuLaunchCooperativeKernelMultiDevice
```
@Cast("CUresult")
public static int cuLaunchCooperativeKernelMultiDevice(CUDA_LAUNCH_PARAMS launchParamsList,
                                                       @Cast("unsigned int")
                                                       int numDevices,
                                                       @Cast("unsigned int")
                                                       int flags)
```
\brief Launches CUDA functions on multiple devices where thread blocks can cooperate and synchronize as they execute Invokes kernels as specified in the \p launchParamsList array where each element of the array specifies all the parameters required to perform a single kernel launch. These kernels can cooperate and synchronize as they execute. The size of the array is specified by \p numDevices. No two kernels can be launched on the same device. All the devices targeted by this multi-device launch must be identical. All devices must have a non-zero value for the device attribute ::CU_DEVICE_ATTRIBUTE_COOPERATIVE_MULTI_DEVICE_LAUNCH. All kernels launched must be identical with respect to the compiled code. Note that any __device__, __constant__ or __managed__ variables present in the module that owns the kernel launched on each device, are independently instantiated on every device. It is the application's responsiblity to ensure these variables are initialized and used appropriately. The size of the grids as specified in blocks, the size of the blocks themselves and the amount of shared memory used by each thread block must also match across all launched kernels. The streams used to launch these kernels must have been created via either ::cuStreamCreate or ::cuStreamCreateWithPriority. The NULL stream or ::CU_STREAM_LEGACY or ::CU_STREAM_PER_THREAD cannot be used. The total number of blocks launched per kernel cannot exceed the maximum number of blocks per multiprocessor as returned by ::cuOccupancyMaxActiveBlocksPerMultiprocessor (or ::cuOccupancyMaxActiveBlocksPerMultiprocessorWithFlags) times the number of multiprocessors as specified by the device attribute ::CU_DEVICE_ATTRIBUTE_MULTIPROCESSOR_COUNT. Since the total number of blocks launched per device has to match across all devices, the maximum number of blocks that can be launched per device will be limited by the device with the least number of multiprocessors. The kernels cannot make use of CUDA dynamic parallelism. The ::CUDA_LAUNCH_PARAMS structure is defined as:
```
        typedef struct CUDA_LAUNCH_PARAMS_st
        {
            CUfunction function;
            unsigned int gridDimX;
            unsigned int gridDimY;
            unsigned int gridDimZ;
            unsigned int blockDimX;
            unsigned int blockDimY;
            unsigned int blockDimZ;
            unsigned int sharedMemBytes;
            CUstream hStream;
            void **kernelParams;
        } CUDA_LAUNCH_PARAMS;
 
```
where: - ::CUDA_LAUNCH_PARAMS::function specifies the kernel to be launched. All functions must be identical with respect to the compiled code. - ::CUDA_LAUNCH_PARAMS::gridDimX is the width of the grid in blocks. This must match across all kernels launched. - ::CUDA_LAUNCH_PARAMS::gridDimY is the height of the grid in blocks. This must match across all kernels launched. - ::CUDA_LAUNCH_PARAMS::gridDimZ is the depth of the grid in blocks. This must match across all kernels launched. - ::CUDA_LAUNCH_PARAMS::blockDimX is the X dimension of each thread block. This must match across all kernels launched. - ::CUDA_LAUNCH_PARAMS::blockDimX is the Y dimension of each thread block. This must match across all kernels launched. - ::CUDA_LAUNCH_PARAMS::blockDimZ is the Z dimension of each thread block. This must match across all kernels launched. - ::CUDA_LAUNCH_PARAMS::sharedMemBytes is the dynamic shared-memory size per thread block in bytes. This must match across all kernels launched. - ::CUDA_LAUNCH_PARAMS::hStream is the handle to the stream to perform the launch in. This cannot be the NULL stream or ::CU_STREAM_LEGACY or ::CU_STREAM_PER_THREAD. The CUDA context associated with this stream must match that associated with ::CUDA_LAUNCH_PARAMS::function. - ::CUDA_LAUNCH_PARAMS::kernelParams is an array of pointers to kernel parameters. If ::CUDA_LAUNCH_PARAMS::function has N parameters, then ::CUDA_LAUNCH_PARAMS::kernelParams needs to be an array of N pointers. Each of ::CUDA_LAUNCH_PARAMS::kernelParams[0] through ::CUDA_LAUNCH_PARAMS::kernelParams[N-1] must point to a region of memory from which the actual kernel parameter will be copied. The number of kernel parameters and their offsets and sizes do not need to be specified as that information is retrieved directly from the kernel's image. By default, the kernel won't begin execution on any GPU until all prior work in all the specified streams has completed. This behavior can be overridden by specifying the flag ::CUDA_COOPERATIVE_LAUNCH_MULTI_DEVICE_NO_PRE_LAUNCH_SYNC. When this flag is specified, each kernel will only wait for prior work in the stream corresponding to that GPU to complete before it begins execution. Similarly, by default, any subsequent work pushed in any of the specified streams will not begin execution until the kernels on all GPUs have completed. This behavior can be overridden by specifying the flag ::CUDA_COOPERATIVE_LAUNCH_MULTI_DEVICE_NO_POST_LAUNCH_SYNC. When this flag is specified, any subsequent work pushed in any of the specified streams will only wait for the kernel launched on the GPU corresponding to that stream to complete before it begins execution. Calling ::cuLaunchCooperativeKernelMultiDevice() sets persistent function state that is the same as function state set through ::cuLaunchKernel API when called individually for each element in \p launchParamsList. When kernels are launched via ::cuLaunchCooperativeKernelMultiDevice(), the previous block shape, shared size and parameter info associated with each ::CUDA_LAUNCH_PARAMS::function in \p launchParamsList is overwritten. Note that to use ::cuLaunchCooperativeKernelMultiDevice(), the kernels must either have been compiled with toolchain version 3.2 or later so that it will contain kernel parameter information, or have no kernel parameters. If either of these conditions is not met, then ::cuLaunchCooperativeKernelMultiDevice() will return ::CUDA_ERROR_INVALID_IMAGE.
Parameters:

launchParamsList - - List of launch parameters, one per device

numDevices - - Size of the \p launchParamsList array

flags - - Flags to control launch behavior

Returns:

::CUDA_SUCCESS, ::CUDA_ERROR_DEINITIALIZED, ::CUDA_ERROR_NOT_INITIALIZED, ::CUDA_ERROR_INVALID_CONTEXT, ::CUDA_ERROR_INVALID_HANDLE, ::CUDA_ERROR_INVALID_IMAGE, ::CUDA_ERROR_INVALID_VALUE, ::CUDA_ERROR_LAUNCH_FAILED, ::CUDA_ERROR_LAUNCH_OUT_OF_RESOURCES, ::CUDA_ERROR_LAUNCH_TIMEOUT, ::CUDA_ERROR_LAUNCH_INCOMPATIBLE_TEXTURING, ::CUDA_ERROR_COOPERATIVE_LAUNCH_TOO_LARGE, ::CUDA_ERROR_SHARED_OBJECT_INIT_FAILED \note_null_stream \notefnerr

cuLaunchHostFunc
```
@Cast("CUresult")
public static int cuLaunchHostFunc(CUstream_st hStream,
                                   CUhostFn fn,
                                   Pointer userData)
```
\brief Enqueues a host function call in a stream Enqueues a host function to run in a stream. The function will be called after currently enqueued work and will block work added after it. The host function must not make any CUDA API calls. Attempting to use a CUDA API may result in ::CUDA_ERROR_NOT_PERMITTED, but this is not required. The host function must not perform any synchronization that may depend on outstanding CUDA work not mandated to run earlier. Host functions without a mandated order (such as in independent streams) execute in undefined order and may be serialized. For the purposes of Unified Memory, execution makes a number of guarantees:
- The stream is considered idle for the duration of the function's execution. Thus, for example, the function may always use memory attached to the stream it was enqueued in.
- The start of execution of the function has the same effect as synchronizing an event recorded in the same stream immediately prior to the function. It thus synchronizes streams which have been "joined" prior to the function.
- Adding device work to any stream does not have the effect of making the stream active until all preceding host functions and stream callbacks have executed. Thus, for example, a function might use global attached memory even if work has been added to another stream, if the work has been ordered behind the function call with an event.
- Completion of the function does not cause a stream to become active except as described above. The stream will remain idle if no device work follows the function, and will remain idle across consecutive host functions or stream callbacks without device work in between. Thus, for example, stream synchronization can be done by signaling from a host function at the end of the stream.
Note that, in contrast to ::cuStreamAddCallback, the function will not be called in the event of an error in the CUDA context.
Parameters:

hStream - - Stream to enqueue function call in

fn - - The function to call once preceding stream operations are complete

userData - - User-specified data to be passed to the function

Returns:

::CUDA_SUCCESS, ::CUDA_ERROR_DEINITIALIZED, ::CUDA_ERROR_NOT_INITIALIZED, ::CUDA_ERROR_INVALID_CONTEXT, ::CUDA_ERROR_INVALID_HANDLE, ::CUDA_ERROR_NOT_SUPPORTED \note_null_stream \notefnerr

cuFuncSetBlockShape
```
@Cast("CUresult")
@Deprecated
public static int cuFuncSetBlockShape(CUfunc_st hfunc,
                                      int x,
                                      int y,
                                      int z)
```
Deprecated.
Specifies the \p x, \p y, and \p z dimensions of the thread blocks that are created when the kernel given by \p hfunc is launched.

\brief Sets the block-dimensions for the function

Parameters:

hfunc - - Kernel to specify dimensions of

x - - X dimension

y - - Y dimension

z - - Z dimension

Returns:

::CUDA_SUCCESS, ::CUDA_ERROR_DEINITIALIZED, ::CUDA_ERROR_NOT_INITIALIZED, ::CUDA_ERROR_INVALID_CONTEXT, ::CUDA_ERROR_INVALID_HANDLE, ::CUDA_ERROR_INVALID_VALUE \notefnerr

cuFuncSetSharedSize
```
@Cast("CUresult")
@Deprecated
public static int cuFuncSetSharedSize(CUfunc_st hfunc,
                                      @Cast("unsigned int")
                                      int bytes)
```
Deprecated.
Sets through \p bytes the amount of dynamic shared memory that will be available to each thread block when the kernel given by \p hfunc is launched.

\brief Sets the dynamic shared-memory size for the function

Parameters:

hfunc - - Kernel to specify dynamic shared-memory size for

bytes - - Dynamic shared-memory size per thread in bytes

Returns:

::CUDA_SUCCESS, ::CUDA_ERROR_DEINITIALIZED, ::CUDA_ERROR_NOT_INITIALIZED, ::CUDA_ERROR_INVALID_CONTEXT, ::CUDA_ERROR_INVALID_HANDLE, ::CUDA_ERROR_INVALID_VALUE \notefnerr

cuParamSetSize
```
@Cast("CUresult")
@Deprecated
public static int cuParamSetSize(CUfunc_st hfunc,
                                 @Cast("unsigned int")
                                 int numbytes)
```
Deprecated.
Sets through \p numbytes the total size in bytes needed by the function parameters of the kernel corresponding to \p hfunc.

\brief Sets the parameter size for the function

Parameters:

hfunc - - Kernel to set parameter size for

numbytes - - Size of parameter list in bytes

Returns:

::CUDA_SUCCESS, ::CUDA_ERROR_DEINITIALIZED, ::CUDA_ERROR_NOT_INITIALIZED, ::CUDA_ERROR_INVALID_CONTEXT, ::CUDA_ERROR_INVALID_VALUE \notefnerr

cuParamSeti
```
@Cast("CUresult")
@Deprecated
public static int cuParamSeti(CUfunc_st hfunc,
                              int offset,
                              @Cast("unsigned int")
                              int value)
```
Deprecated.
Sets an integer parameter that will be specified the next time the kernel corresponding to \p hfunc will be invoked. \p offset is a byte offset.

\brief Adds an integer parameter to the function's argument list

Parameters:

hfunc - - Kernel to add parameter to

offset - - Offset to add parameter to argument list

value - - Value of parameter

Returns:

::CUDA_SUCCESS, ::CUDA_ERROR_DEINITIALIZED, ::CUDA_ERROR_NOT_INITIALIZED, ::CUDA_ERROR_INVALID_CONTEXT, ::CUDA_ERROR_INVALID_VALUE \notefnerr

cuParamSetf
```
@Cast("CUresult")
@Deprecated
public static int cuParamSetf(CUfunc_st hfunc,
                              int offset,
                              float value)
```
Deprecated.
Sets a floating-point parameter that will be specified the next time the kernel corresponding to \p hfunc will be invoked. \p offset is a byte offset.

\brief Adds a floating-point parameter to the function's argument list

Parameters:

hfunc - - Kernel to add parameter to

offset - - Offset to add parameter to argument list

value - - Value of parameter

Returns:

::CUDA_SUCCESS, ::CUDA_ERROR_DEINITIALIZED, ::CUDA_ERROR_NOT_INITIALIZED, ::CUDA_ERROR_INVALID_CONTEXT, ::CUDA_ERROR_INVALID_VALUE \notefnerr

cuParamSetv
```
@Cast("CUresult")
@Deprecated
public static int cuParamSetv(CUfunc_st hfunc,
                              int offset,
                              Pointer ptr,
                              @Cast("unsigned int")
                              int numbytes)
```
Deprecated.
Copies an arbitrary amount of data (specified in \p numbytes) from \p ptr into the parameter space of the kernel corresponding to \p hfunc. \p offset is a byte offset.

\brief Adds arbitrary data to the function's argument list

Parameters:

hfunc - - Kernel to add data to

offset - - Offset to add data to argument list

ptr - - Pointer to arbitrary data

numbytes - - Size of data to copy in bytes

Returns:

::CUDA_SUCCESS, ::CUDA_ERROR_DEINITIALIZED, ::CUDA_ERROR_NOT_INITIALIZED, ::CUDA_ERROR_INVALID_CONTEXT, ::CUDA_ERROR_INVALID_VALUE \notefnerr

cuLaunch
```
@Cast("CUresult")
@Deprecated
public static int cuLaunch(CUfunc_st f)
```
Deprecated.
Invokes the kernel \p f on a 1 x 1 x 1 grid of blocks. The block contains the number of threads specified by a previous call to ::cuFuncSetBlockShape().

\brief Launches a CUDA function

Parameters:

f - - Kernel to launch

Returns:

::CUDA_SUCCESS, ::CUDA_ERROR_DEINITIALIZED, ::CUDA_ERROR_NOT_INITIALIZED, ::CUDA_ERROR_INVALID_CONTEXT, ::CUDA_ERROR_INVALID_VALUE, ::CUDA_ERROR_LAUNCH_FAILED, ::CUDA_ERROR_LAUNCH_OUT_OF_RESOURCES, ::CUDA_ERROR_LAUNCH_TIMEOUT, ::CUDA_ERROR_LAUNCH_INCOMPATIBLE_TEXTURING, ::CUDA_ERROR_SHARED_OBJECT_INIT_FAILED \notefnerr

cuLaunchGrid
```
@Cast("CUresult")
@Deprecated
public static int cuLaunchGrid(CUfunc_st f,
                               int grid_width,
                               int grid_height)
```
Deprecated.
Invokes the kernel \p f on a \p grid_width x \p grid_height grid of blocks. Each block contains the number of threads specified by a previous call to ::cuFuncSetBlockShape().

\brief Launches a CUDA function

Parameters:

f - - Kernel to launch

grid_width - - Width of grid in blocks

grid_height - - Height of grid in blocks

Returns:

::CUDA_SUCCESS, ::CUDA_ERROR_DEINITIALIZED, ::CUDA_ERROR_NOT_INITIALIZED, ::CUDA_ERROR_INVALID_CONTEXT, ::CUDA_ERROR_INVALID_VALUE, ::CUDA_ERROR_LAUNCH_FAILED, ::CUDA_ERROR_LAUNCH_OUT_OF_RESOURCES, ::CUDA_ERROR_LAUNCH_TIMEOUT, ::CUDA_ERROR_LAUNCH_INCOMPATIBLE_TEXTURING, ::CUDA_ERROR_SHARED_OBJECT_INIT_FAILED \notefnerr

cuLaunchGridAsync
```
@Cast("CUresult")
@Deprecated
public static int cuLaunchGridAsync(CUfunc_st f,
                                    int grid_width,
                                    int grid_height,
                                    CUstream_st hStream)
```
Deprecated.
Invokes the kernel \p f on a \p grid_width x \p grid_height grid of blocks. Each block contains the number of threads specified by a previous call to ::cuFuncSetBlockShape().

\brief Launches a CUDA function

Parameters:

f - - Kernel to launch

grid_width - - Width of grid in blocks

grid_height - - Height of grid in blocks

hStream - - Stream identifier

Returns:

::CUDA_SUCCESS, ::CUDA_ERROR_DEINITIALIZED, ::CUDA_ERROR_NOT_INITIALIZED, ::CUDA_ERROR_INVALID_CONTEXT, ::CUDA_ERROR_INVALID_HANDLE, ::CUDA_ERROR_INVALID_VALUE, ::CUDA_ERROR_LAUNCH_FAILED, ::CUDA_ERROR_LAUNCH_OUT_OF_RESOURCES, ::CUDA_ERROR_LAUNCH_TIMEOUT, ::CUDA_ERROR_LAUNCH_INCOMPATIBLE_TEXTURING, ::CUDA_ERROR_SHARED_OBJECT_INIT_FAILED \note In certain cases where cubins are created with no ABI (i.e., using \p ptxas \p --abi-compile \p no), this function may serialize kernel launches. In order to force the CUDA driver to retain asynchronous behavior, set the ::CU_CTX_LMEM_RESIZE_TO_MAX flag during context creation (see ::cuCtxCreate). \note_null_stream \notefnerr

cuParamSetTexRef
```
@Cast("CUresult")
@Deprecated
public static int cuParamSetTexRef(CUfunc_st hfunc,
                                   int texunit,
                                   CUtexref_st hTexRef)
```
Deprecated.
Makes the CUDA array or linear memory bound to the texture reference \p hTexRef available to a device program as a texture. In this version of CUDA, the texture-reference must be obtained via ::cuModuleGetTexRef() and the \p texunit parameter must be set to ::CU_PARAM_TR_DEFAULT.

\brief Adds a texture-reference to the function's argument list

Parameters:

hfunc - - Kernel to add texture-reference to

texunit - - Texture unit (must be ::CU_PARAM_TR_DEFAULT)

hTexRef - - Texture-reference to add to argument list

Returns:

::CUDA_SUCCESS, ::CUDA_ERROR_DEINITIALIZED, ::CUDA_ERROR_NOT_INITIALIZED, ::CUDA_ERROR_INVALID_CONTEXT, ::CUDA_ERROR_INVALID_VALUE \notefnerr

cuGraphCreate
```
@Cast("CUresult")
public static int cuGraphCreate(@ByPtrPtr
                                CUgraph_st phGraph,
                                @Cast("unsigned int")
                                int flags)
```
\brief Creates a graph Creates an empty graph, which is returned via \p phGraph.

Parameters:

phGraph - - Returns newly created graph

flags - - Graph creation flags, must be 0

Returns:

::CUDA_SUCCESS, ::CUDA_ERROR_DEINITIALIZED, ::CUDA_ERROR_NOT_INITIALIZED, ::CUDA_ERROR_INVALID_VALUE, ::CUDA_ERROR_OUT_OF_MEMORY \note_graph_thread_safety \notefnerr

cuGraphAddKernelNode
```
@Cast("CUresult")
public static int cuGraphAddKernelNode(@ByPtrPtr
                                       CUgraphNode_st phGraphNode,
                                       CUgraph_st hGraph,
                                       @Cast("const CUgraphNode*") @ByPtrPtr
                                       CUgraphNode_st dependencies,
                                       @Cast("size_t")
                                       long numDependencies,
                                       @Const
                                       CUDA_KERNEL_NODE_PARAMS nodeParams)
```
\brief Creates a kernel execution node and adds it to a graph Creates a new kernel execution node and adds it to \p hGraph with \p numDependencies dependencies specified via \p dependencies and arguments specified in \p nodeParams. It is possible for \p numDependencies to be 0, in which case the node will be placed at the root of the graph. \p dependencies may not have any duplicate entries. A handle to the new node will be returned in \p phGraphNode. The CUDA_KERNEL_NODE_PARAMS structure is defined as:
```
  typedef struct CUDA_KERNEL_NODE_PARAMS_st {
      CUfunction func;
      unsigned int gridDimX;
      unsigned int gridDimY;
      unsigned int gridDimZ;
      unsigned int blockDimX;
      unsigned int blockDimY;
      unsigned int blockDimZ;
      unsigned int sharedMemBytes;
      void **kernelParams;
      void **extra;
  } CUDA_KERNEL_NODE_PARAMS;
 
```
When the graph is launched, the node will invoke kernel \p func on a (\p gridDimX x \p gridDimY x \p gridDimZ) grid of blocks. Each block contains (\p blockDimX x \p blockDimY x \p blockDimZ) threads. \p sharedMemBytes sets the amount of dynamic shared memory that will be available to each thread block. Kernel parameters to \p func can be specified in one of two ways: 1) Kernel parameters can be specified via \p kernelParams. If the kernel has N parameters, then \p kernelParams needs to be an array of N pointers. Each pointer, from \p kernelParams[0] to \p kernelParams[N-1], points to the region of memory from which the actual parameter will be copied. The number of kernel parameters and their offsets and sizes do not need to be specified as that information is retrieved directly from the kernel's image. 2) Kernel parameters can also be packaged by the application into a single buffer that is passed in via \p extra. This places the burden on the application of knowing each kernel parameter's size and alignment/padding within the buffer. The \p extra parameter exists to allow this function to take additional less commonly used arguments. \p extra specifies a list of names of extra settings and their corresponding values. Each extra setting name is immediately followed by the corresponding value. The list must be terminated with either NULL or CU_LAUNCH_PARAM_END. - ::CU_LAUNCH_PARAM_END, which indicates the end of the \p extra array; - ::CU_LAUNCH_PARAM_BUFFER_POINTER, which specifies that the next value in \p extra will be a pointer to a buffer containing all the kernel parameters for launching kernel \p func; - ::CU_LAUNCH_PARAM_BUFFER_SIZE, which specifies that the next value in \p extra will be a pointer to a size_t containing the size of the buffer specified with ::CU_LAUNCH_PARAM_BUFFER_POINTER; The error ::CUDA_ERROR_INVALID_VALUE will be returned if kernel parameters are specified with both \p kernelParams and \p extra (i.e. both \p kernelParams and \p extra are non-NULL). The \p kernelParams or \p extra array, as well as the argument values it points to, are copied during this call. \note Kernels launched using graphs must not use texture and surface references. Reading or writing through any texture or surface reference is undefined behavior. This restriction does not apply to texture and surface objects.
Parameters:

phGraphNode - - Returns newly created node

hGraph - - Graph to which to add the node

dependencies - - Dependencies of the node

numDependencies - - Number of dependencies

nodeParams - - Parameters for the GPU execution node

Returns:

::CUDA_SUCCESS, ::CUDA_ERROR_DEINITIALIZED, ::CUDA_ERROR_NOT_INITIALIZED, ::CUDA_ERROR_INVALID_VALUE \note_graph_thread_safety \notefnerr

cuGraphKernelNodeGetParams
```
@Cast("CUresult")
public static int cuGraphKernelNodeGetParams(CUgraphNode_st hNode,
                                             CUDA_KERNEL_NODE_PARAMS nodeParams)
```
\brief Returns a kernel node's parameters Returns the parameters of kernel node \p hNode in \p nodeParams. The \p kernelParams or \p extra array returned in \p nodeParams, as well as the argument values it points to, are owned by the node. This memory remains valid until the node is destroyed or its parameters are modified, and should not be modified directly. Use ::cuGraphKernelNodeSetParams to update the parameters of this node. The params will contain either \p kernelParams or \p extra, according to which of these was most recently set on the node.

Parameters:

hNode - - Node to get the parameters for

nodeParams - - Pointer to return the parameters

Returns:

::CUDA_SUCCESS, ::CUDA_ERROR_DEINITIALIZED, ::CUDA_ERROR_NOT_INITIALIZED, ::CUDA_ERROR_INVALID_VALUE \note_graph_thread_safety \notefnerr

cuGraphKernelNodeSetParams
```
@Cast("CUresult")
public static int cuGraphKernelNodeSetParams(CUgraphNode_st hNode,
                                             @Const
                                             CUDA_KERNEL_NODE_PARAMS nodeParams)
```
\brief Sets a kernel node's parameters Sets the parameters of kernel node \p hNode to \p nodeParams.

Parameters:

hNode - - Node to set the parameters for

nodeParams - - Parameters to copy

Returns:

::CUDA_SUCCESS, ::CUDA_ERROR_INVALID_VALUE, ::CUDA_ERROR_INVALID_HANDLE, ::CUDA_ERROR_OUT_OF_MEMORY \note_graph_thread_safety \notefnerr

cuGraphAddMemcpyNode
```
@Cast("CUresult")
public static int cuGraphAddMemcpyNode(@ByPtrPtr
                                       CUgraphNode_st phGraphNode,
                                       CUgraph_st hGraph,
                                       @Cast("const CUgraphNode*") @ByPtrPtr
                                       CUgraphNode_st dependencies,
                                       @Cast("size_t")
                                       long numDependencies,
                                       @Const
                                       CUDA_MEMCPY3D copyParams,
                                       CUctx_st ctx)
```
\brief Creates a memcpy node and adds it to a graph Creates a new memcpy node and adds it to \p hGraph with \p numDependencies dependencies specified via \p dependencies. It is possible for \p numDependencies to be 0, in which case the node will be placed at the root of the graph. \p dependencies may not have any duplicate entries. A handle to the new node will be returned in \p phGraphNode. When the graph is launched, the node will perform the memcpy described by \p copyParams. See ::cuMemcpy3D() for a description of the structure and its restrictions. Memcpy nodes have some additional restrictions with regards to managed memory, if the system contains at least one device which has a zero value for the device attribute ::CU_DEVICE_ATTRIBUTE_CONCURRENT_MANAGED_ACCESS. If one or more of the operands refer to managed memory, then using the memory type ::CU_MEMORYTYPE_UNIFIED is disallowed for those operand(s). The managed memory will be treated as residing on either the host or the device, depending on which memory type is specified.

Parameters:

phGraphNode - - Returns newly created node

hGraph - - Graph to which to add the node

dependencies - - Dependencies of the node

numDependencies - - Number of dependencies

copyParams - - Parameters for the memory copy

ctx - - Context on which to run the node

Returns:

::CUDA_SUCCESS, ::CUDA_ERROR_DEINITIALIZED, ::CUDA_ERROR_NOT_INITIALIZED, ::CUDA_ERROR_INVALID_VALUE \note_graph_thread_safety \notefnerr

cuGraphMemcpyNodeGetParams
```
@Cast("CUresult")
public static int cuGraphMemcpyNodeGetParams(CUgraphNode_st hNode,
                                             CUDA_MEMCPY3D nodeParams)
```
\brief Returns a memcpy node's parameters Returns the parameters of memcpy node \p hNode in \p nodeParams.

Parameters:

hNode - - Node to get the parameters for

nodeParams - - Pointer to return the parameters

Returns:

::CUDA_SUCCESS, ::CUDA_ERROR_DEINITIALIZED, ::CUDA_ERROR_NOT_INITIALIZED, ::CUDA_ERROR_INVALID_VALUE \note_graph_thread_safety \notefnerr

cuGraphMemcpyNodeSetParams
```
@Cast("CUresult")
public static int cuGraphMemcpyNodeSetParams(CUgraphNode_st hNode,
                                             @Const
                                             CUDA_MEMCPY3D nodeParams)
```
\brief Sets a memcpy node's parameters Sets the parameters of memcpy node \p hNode to \p nodeParams.

Parameters:

hNode - - Node to set the parameters for

nodeParams - - Parameters to copy

Returns:

::CUDA_SUCCESS, ::CUDA_ERROR_DEINITIALIZED, ::CUDA_ERROR_NOT_INITIALIZED, ::CUDA_ERROR_INVALID_VALUE, \note_graph_thread_safety \notefnerr

cuGraphAddMemsetNode
```
@Cast("CUresult")
public static int cuGraphAddMemsetNode(@ByPtrPtr
                                       CUgraphNode_st phGraphNode,
                                       CUgraph_st hGraph,
                                       @Cast("const CUgraphNode*") @ByPtrPtr
                                       CUgraphNode_st dependencies,
                                       @Cast("size_t")
                                       long numDependencies,
                                       @Const
                                       CUDA_MEMSET_NODE_PARAMS memsetParams,
                                       CUctx_st ctx)
```
\brief Creates a memset node and adds it to a graph Creates a new memset node and adds it to \p hGraph with \p numDependencies dependencies specified via \p dependencies. It is possible for \p numDependencies to be 0, in which case the node will be placed at the root of the graph. \p dependencies may not have any duplicate entries. A handle to the new node will be returned in \p phGraphNode. The element size must be 1, 2, or 4 bytes. When the graph is launched, the node will perform the memset described by \p memsetParams.

Parameters:

phGraphNode - - Returns newly created node

hGraph - - Graph to which to add the node

dependencies - - Dependencies of the node

numDependencies - - Number of dependencies

memsetParams - - Parameters for the memory set

ctx - - Context on which to run the node

Returns:

::CUDA_SUCCESS, ::CUDA_ERROR_DEINITIALIZED, ::CUDA_ERROR_NOT_INITIALIZED, ::CUDA_ERROR_INVALID_VALUE, ::CUDA_ERROR_INVALID_CONTEXT \note_graph_thread_safety \notefnerr

cuGraphMemsetNodeGetParams
```
@Cast("CUresult")
public static int cuGraphMemsetNodeGetParams(CUgraphNode_st hNode,
                                             CUDA_MEMSET_NODE_PARAMS nodeParams)
```
\brief Returns a memset node's parameters Returns the parameters of memset node \p hNode in \p nodeParams.

Parameters:

hNode - - Node to get the parameters for

nodeParams - - Pointer to return the parameters

Returns:

::CUDA_SUCCESS, ::CUDA_ERROR_DEINITIALIZED, ::CUDA_ERROR_NOT_INITIALIZED, ::CUDA_ERROR_INVALID_VALUE \note_graph_thread_safety \notefnerr

cuGraphMemsetNodeSetParams
```
@Cast("CUresult")
public static int cuGraphMemsetNodeSetParams(CUgraphNode_st hNode,
                                             @Const
                                             CUDA_MEMSET_NODE_PARAMS nodeParams)
```
\brief Sets a memset node's parameters Sets the parameters of memset node \p hNode to \p nodeParams.

Parameters:

hNode - - Node to set the parameters for

nodeParams - - Parameters to copy

Returns:

::CUDA_SUCCESS, ::CUDA_ERROR_DEINITIALIZED, ::CUDA_ERROR_NOT_INITIALIZED, ::CUDA_ERROR_INVALID_VALUE \note_graph_thread_safety \notefnerr

cuGraphAddHostNode
```
@Cast("CUresult")
public static int cuGraphAddHostNode(@ByPtrPtr
                                     CUgraphNode_st phGraphNode,
                                     CUgraph_st hGraph,
                                     @Cast("const CUgraphNode*") @ByPtrPtr
                                     CUgraphNode_st dependencies,
                                     @Cast("size_t")
                                     long numDependencies,
                                     @Const
                                     CUDA_HOST_NODE_PARAMS nodeParams)
```
\brief Creates a host execution node and adds it to a graph Creates a new CPU execution node and adds it to \p hGraph with \p numDependencies dependencies specified via \p dependencies and arguments specified in \p nodeParams. It is possible for \p numDependencies to be 0, in which case the node will be placed at the root of the graph. \p dependencies may not have any duplicate entries. A handle to the new node will be returned in \p phGraphNode. When the graph is launched, the node will invoke the specified CPU function. Host nodes are not supported under MPS with pre-Volta GPUs.

Parameters:

phGraphNode - - Returns newly created node

hGraph - - Graph to which to add the node

dependencies - - Dependencies of the node

numDependencies - - Number of dependencies

nodeParams - - Parameters for the host node

Returns:

::CUDA_SUCCESS, ::CUDA_ERROR_DEINITIALIZED, ::CUDA_ERROR_NOT_INITIALIZED, ::CUDA_ERROR_NOT_SUPPORTED, ::CUDA_ERROR_INVALID_VALUE \note_graph_thread_safety \notefnerr

cuGraphHostNodeGetParams
```
@Cast("CUresult")
public static int cuGraphHostNodeGetParams(CUgraphNode_st hNode,
                                           CUDA_HOST_NODE_PARAMS nodeParams)
```
\brief Returns a host node's parameters Returns the parameters of host node \p hNode in \p nodeParams.

Parameters:

hNode - - Node to get the parameters for

nodeParams - - Pointer to return the parameters

Returns:

::CUDA_SUCCESS, ::CUDA_ERROR_DEINITIALIZED, ::CUDA_ERROR_NOT_INITIALIZED, ::CUDA_ERROR_INVALID_VALUE \note_graph_thread_safety \notefnerr

cuGraphHostNodeSetParams
```
@Cast("CUresult")
public static int cuGraphHostNodeSetParams(CUgraphNode_st hNode,
                                           @Const
                                           CUDA_HOST_NODE_PARAMS nodeParams)
```
\brief Sets a host node's parameters Sets the parameters of host node \p hNode to \p nodeParams.

Parameters:

hNode - - Node to set the parameters for

nodeParams - - Parameters to copy

Returns:

::CUDA_SUCCESS, ::CUDA_ERROR_DEINITIALIZED, ::CUDA_ERROR_NOT_INITIALIZED, ::CUDA_ERROR_INVALID_VALUE \note_graph_thread_safety \notefnerr

cuGraphAddChildGraphNode
```
@Cast("CUresult")
public static int cuGraphAddChildGraphNode(@ByPtrPtr
                                           CUgraphNode_st phGraphNode,
                                           CUgraph_st hGraph,
                                           @Cast("const CUgraphNode*") @ByPtrPtr
                                           CUgraphNode_st dependencies,
                                           @Cast("size_t")
                                           long numDependencies,
                                           CUgraph_st childGraph)
```
\brief Creates a child graph node and adds it to a graph Creates a new node which executes an embedded graph, and adds it to \p hGraph with \p numDependencies dependencies specified via \p dependencies. It is possible for \p numDependencies to be 0, in which case the node will be placed at the root of the graph. \p dependencies may not have any duplicate entries. A handle to the new node will be returned in \p phGraphNode. The node executes an embedded child graph. The child graph is cloned in this call.

Parameters:

phGraphNode - - Returns newly created node

hGraph - - Graph to which to add the node

dependencies - - Dependencies of the node

numDependencies - - Number of dependencies

childGraph - - The graph to clone into this node

Returns:

::CUDA_SUCCESS, ::CUDA_ERROR_DEINITIALIZED, ::CUDA_ERROR_NOT_INITIALIZED, ::CUDA_ERROR_INVALID_VALUE, \note_graph_thread_safety \notefnerr

cuGraphChildGraphNodeGetGraph
```
@Cast("CUresult")
public static int cuGraphChildGraphNodeGetGraph(CUgraphNode_st hNode,
                                                @ByPtrPtr
                                                CUgraph_st phGraph)
```
\brief Gets a handle to the embedded graph of a child graph node Gets a handle to the embedded graph in a child graph node. This call does not clone the graph. Changes to the graph will be reflected in the node, and the node retains ownership of the graph.

Parameters:

hNode - - Node to get the embedded graph for

phGraph - - Location to store a handle to the graph

Returns:

::CUDA_SUCCESS, ::CUDA_ERROR_DEINITIALIZED, ::CUDA_ERROR_NOT_INITIALIZED, ::CUDA_ERROR_INVALID_VALUE, \note_graph_thread_safety \notefnerr

cuGraphAddEmptyNode
```
@Cast("CUresult")
public static int cuGraphAddEmptyNode(@ByPtrPtr
                                      CUgraphNode_st phGraphNode,
                                      CUgraph_st hGraph,
                                      @Cast("const CUgraphNode*") @ByPtrPtr
                                      CUgraphNode_st dependencies,
                                      @Cast("size_t")
                                      long numDependencies)
```
\brief Creates an empty node and adds it to a graph Creates a new node which performs no operation, and adds it to \p hGraph with \p numDependencies dependencies specified via \p dependencies. It is possible for \p numDependencies to be 0, in which case the node will be placed at the root of the graph. \p dependencies may not have any duplicate entries. A handle to the new node will be returned in \p phGraphNode. An empty node performs no operation during execution, but can be used for transitive ordering. For example, a phased execution graph with 2 groups of n nodes with a barrier between them can be represented using an empty node and 2*n dependency edges, rather than no empty node and n^2 dependency edges.

Parameters:

phGraphNode - - Returns newly created node

hGraph - - Graph to which to add the node

dependencies - - Dependencies of the node

numDependencies - - Number of dependencies

Returns:

::CUDA_SUCCESS, ::CUDA_ERROR_DEINITIALIZED, ::CUDA_ERROR_NOT_INITIALIZED, ::CUDA_ERROR_INVALID_VALUE, \note_graph_thread_safety \notefnerr

cuGraphClone
```
@Cast("CUresult")
public static int cuGraphClone(@ByPtrPtr
                               CUgraph_st phGraphClone,
                               CUgraph_st originalGraph)
```
\brief Clones a graph This function creates a copy of \p originalGraph and returns it in \p * phGraphClone. All parameters are copied into the cloned graph. The original graph may be modified after this call without affecting the clone. Child graph nodes in the original graph are recursively copied into the clone.

Parameters:

phGraphClone - - Returns newly created cloned graph

originalGraph - - Graph to clone

Returns:

::CUDA_SUCCESS, ::CUDA_ERROR_INVALID_VALUE, ::CUDA_ERROR_OUT_OF_MEMORY \note_graph_thread_safety \notefnerr

cuGraphNodeFindInClone
```
@Cast("CUresult")
public static int cuGraphNodeFindInClone(@ByPtrPtr
                                         CUgraphNode_st phNode,
                                         CUgraphNode_st hOriginalNode,
                                         CUgraph_st hClonedGraph)
```
\brief Finds a cloned version of a node This function returns the node in \p hClonedGraph corresponding to \p hOriginalNode in the original graph. \p hClonedGraph must have been cloned from \p hOriginalGraph via ::cuGraphClone. \p hOriginalNode must have been in \p hOriginalGraph at the time of the call to ::cuGraphClone, and the corresponding cloned node in \p hClonedGraph must not have been removed. The cloned node is then returned via \p phClonedNode.

Parameters:

phNode - - Returns handle to the cloned node

hOriginalNode - - Handle to the original node

hClonedGraph - - Cloned graph to query

Returns:

::CUDA_SUCCESS, ::CUDA_ERROR_INVALID_VALUE, \note_graph_thread_safety \notefnerr

cuGraphNodeGetType
```
@Cast("CUresult")
public static int cuGraphNodeGetType(CUgraphNode_st hNode,
                                     @Cast("CUgraphNodeType*")
                                     IntPointer type)
```
\brief Returns a node's type Returns the node type of \p hNode in \p type.

Parameters:

hNode - - Node to query

type - - Pointer to return the node type

Returns:

::CUDA_SUCCESS, ::CUDA_ERROR_DEINITIALIZED, ::CUDA_ERROR_NOT_INITIALIZED, ::CUDA_ERROR_INVALID_VALUE \note_graph_thread_safety \notefnerr

cuGraphNodeGetType

@Cast("CUresult")
public static int cuGraphNodeGetType(CUgraphNode_st hNode,
                                     @Cast("CUgraphNodeType*")
                                     IntBuffer type)

cuGraphNodeGetType

@Cast("CUresult")
public static int cuGraphNodeGetType(CUgraphNode_st hNode,
                                     @Cast("CUgraphNodeType*")
                                     int[] type)

cuGraphGetNodes
```
@Cast("CUresult")
public static int cuGraphGetNodes(CUgraph_st hGraph,
                                  @ByPtrPtr
                                  CUgraphNode_st nodes,
                                  @Cast("size_t*")
                                  SizeTPointer numNodes)
```
\brief Returns a graph's nodes Returns a list of \p hGraph's nodes. \p nodes may be NULL, in which case this function will return the number of nodes in \p numNodes. Otherwise, \p numNodes entries will be filled in. If \p numNodes is higher than the actual number of nodes, the remaining entries in \p nodes will be set to NULL, and the number of nodes actually obtained will be returned in \p numNodes.

Parameters:

hGraph - - Graph to query

nodes - - Pointer to return the nodes

numNodes - - See description

Returns:

::CUDA_SUCCESS, ::CUDA_ERROR_DEINITIALIZED, ::CUDA_ERROR_NOT_INITIALIZED, ::CUDA_ERROR_INVALID_VALUE \note_graph_thread_safety \notefnerr

cuGraphGetRootNodes
```
@Cast("CUresult")
public static int cuGraphGetRootNodes(CUgraph_st hGraph,
                                      @ByPtrPtr
                                      CUgraphNode_st rootNodes,
                                      @Cast("size_t*")
                                      SizeTPointer numRootNodes)
```
\brief Returns a graph's root nodes Returns a list of \p hGraph's root nodes. \p rootNodes may be NULL, in which case this function will return the number of root nodes in \p numRootNodes. Otherwise, \p numRootNodes entries will be filled in. If \p numRootNodes is higher than the actual number of root nodes, the remaining entries in \p rootNodes will be set to NULL, and the number of nodes actually obtained will be returned in \p numRootNodes.

Parameters:

hGraph - - Graph to query

rootNodes - - Pointer to return the root nodes

numRootNodes - - See description

Returns:

::CUDA_SUCCESS, ::CUDA_ERROR_DEINITIALIZED, ::CUDA_ERROR_NOT_INITIALIZED, ::CUDA_ERROR_INVALID_VALUE \note_graph_thread_safety \notefnerr

cuGraphGetEdges
```
@Cast("CUresult")
public static int cuGraphGetEdges(CUgraph_st hGraph,
                                  @ByPtrPtr
                                  CUgraphNode_st from,
                                  @ByPtrPtr
                                  CUgraphNode_st to,
                                  @Cast("size_t*")
                                  SizeTPointer numEdges)
```
\brief Returns a graph's dependency edges Returns a list of \p hGraph's dependency edges. Edges are returned via corresponding indices in \p from and \p to; that is, the node in \p to[i] has a dependency on the node in \p from[i]. \p from and \p to may both be NULL, in which case this function only returns the number of edges in \p numEdges. Otherwise, \p numEdges entries will be filled in. If \p numEdges is higher than the actual number of edges, the remaining entries in \p from and \p to will be set to NULL, and the number of edges actually returned will be written to \p numEdges.

Parameters:

hGraph - - Graph to get the edges from

from - - Location to return edge endpoints

to - - Location to return edge endpoints

numEdges - - See description

Returns:

::CUDA_SUCCESS, ::CUDA_ERROR_DEINITIALIZED, ::CUDA_ERROR_NOT_INITIALIZED, ::CUDA_ERROR_INVALID_VALUE \note_graph_thread_safety \notefnerr

cuGraphNodeGetDependencies
```
@Cast("CUresult")
public static int cuGraphNodeGetDependencies(CUgraphNode_st hNode,
                                             @ByPtrPtr
                                             CUgraphNode_st dependencies,
                                             @Cast("size_t*")
                                             SizeTPointer numDependencies)
```
\brief Returns a node's dependencies Returns a list of \p node's dependencies. \p dependencies may be NULL, in which case this function will return the number of dependencies in \p numDependencies. Otherwise, \p numDependencies entries will be filled in. If \p numDependencies is higher than the actual number of dependencies, the remaining entries in \p dependencies will be set to NULL, and the number of nodes actually obtained will be returned in \p numDependencies.

Parameters:

hNode - - Node to query

dependencies - - Pointer to return the dependencies

numDependencies - - See description

Returns:

::CUDA_SUCCESS, ::CUDA_ERROR_DEINITIALIZED, ::CUDA_ERROR_NOT_INITIALIZED, ::CUDA_ERROR_INVALID_VALUE \note_graph_thread_safety \notefnerr

cuGraphNodeGetDependentNodes
```
@Cast("CUresult")
public static int cuGraphNodeGetDependentNodes(CUgraphNode_st hNode,
                                               @ByPtrPtr
                                               CUgraphNode_st dependentNodes,
                                               @Cast("size_t*")
                                               SizeTPointer numDependentNodes)
```
\brief Returns a node's dependent nodes Returns a list of \p node's dependent nodes. \p dependentNodes may be NULL, in which case this function will return the number of dependent nodes in \p numDependentNodes. Otherwise, \p numDependentNodes entries will be filled in. If \p numDependentNodes is higher than the actual number of dependent nodes, the remaining entries in \p dependentNodes will be set to NULL, and the number of nodes actually obtained will be returned in \p numDependentNodes.

Parameters:

hNode - - Node to query

dependentNodes - - Pointer to return the dependent nodes

numDependentNodes - - See description

Returns:

::CUDA_SUCCESS, ::CUDA_ERROR_DEINITIALIZED, ::CUDA_ERROR_NOT_INITIALIZED, ::CUDA_ERROR_INVALID_VALUE \note_graph_thread_safety \notefnerr

cuGraphAddDependencies

@Cast("CUresult")
public static int cuGraphAddDependencies(CUgraph_st hGraph,
                                         @Cast("const CUgraphNode*") @ByPtrPtr
                                         CUgraphNode_st from,
                                         @Cast("const CUgraphNode*") @ByPtrPtr
                                         CUgraphNode_st to,
                                         @Cast("size_t")
                                         long numDependencies)

\brief Adds dependency edges to a graph The number of dependencies to be added is defined by \p numDependencies Elements in \p from and \p to at corresponding indices define a dependency. Each node in \p from and \p to must belong to \p hGraph. If \p numDependencies is 0, elements in \p from and \p to will be ignored. Specifying an existing dependency will return an error.

Parameters:: hGraph - - Graph to which dependencies are added; from - - Array of nodes that provide the dependencies; to - - Array of dependent nodes; numDependencies - - Number of dependencies to be added
Returns:: ::CUDA_SUCCESS, ::CUDA_ERROR_INVALID_VALUE \note_graph_thread_safety \notefnerr

cuGraphRemoveDependencies

@Cast("CUresult")
public static int cuGraphRemoveDependencies(CUgraph_st hGraph,
                                            @Cast("const CUgraphNode*") @ByPtrPtr
                                            CUgraphNode_st from,
                                            @Cast("const CUgraphNode*") @ByPtrPtr
                                            CUgraphNode_st to,
                                            @Cast("size_t")
                                            long numDependencies)

\brief Removes dependency edges from a graph The number of \p dependencies to be removed is defined by \p numDependencies. Elements in \p from and \p to at corresponding indices define a dependency. Each node in \p from and \p to must belong to \p hGraph. If \p numDependencies is 0, elements in \p from and \p to will be ignored. Specifying a non-existing dependency will return an error.

Parameters:: hGraph - - Graph from which to remove dependencies; from - - Array of nodes that provide the dependencies; to - - Array of dependent nodes; numDependencies - - Number of dependencies to be removed
Returns:: ::CUDA_SUCCESS, ::CUDA_ERROR_INVALID_VALUE \note_graph_thread_safety \notefnerr

cuGraphDestroyNode
```
@Cast("CUresult")
public static int cuGraphDestroyNode(CUgraphNode_st hNode)
```
\brief Remove a node from the graph Removes \p hNode from its graph. This operation also severs any dependencies of other nodes on \p hNode and vice versa.

Parameters:

hNode - - Node to remove

Returns:

::CUDA_SUCCESS, ::CUDA_ERROR_INVALID_VALUE \note_graph_thread_safety \notefnerr

cuGraphInstantiate
```
@Cast("CUresult")
public static int cuGraphInstantiate(@ByPtrPtr
                                     CUgraphExec_st phGraphExec,
                                     CUgraph_st hGraph,
                                     @ByPtrPtr
                                     CUgraphNode_st phErrorNode,
                                     @Cast("char*")
                                     BytePointer logBuffer,
                                     @Cast("size_t")
                                     long bufferSize)
```
\brief Creates an executable graph from a graph Instantiates \p hGraph as an executable graph. The graph is validated for any structural constraints or intra-node constraints which were not previously validated. If instantiation is successful, a handle to the instantiated graph is returned in \p graphExec. If there are any errors, diagnostic information may be returned in \p errorNode and \p logBuffer. This is the primary way to inspect instantiation errors. The output will be null terminated unless the diagnostics overflow the buffer. In this case, they will be truncated, and the last byte can be inspected to determine if truncation occurred.

Parameters:

phGraphExec - - Returns instantiated graph

hGraph - - Graph to instantiate

phErrorNode - - In case of an instantiation error, this may be modified to indicate a node contributing to the error

logBuffer - - A character buffer to store diagnostic messages

bufferSize - - Size of the log buffer in bytes

Returns:

::CUDA_SUCCESS, ::CUDA_ERROR_DEINITIALIZED, ::CUDA_ERROR_NOT_INITIALIZED, ::CUDA_ERROR_INVALID_VALUE \note_graph_thread_safety \notefnerr

cuGraphInstantiate

@Cast("CUresult")
public static int cuGraphInstantiate(@ByPtrPtr
                                     CUgraphExec_st phGraphExec,
                                     CUgraph_st hGraph,
                                     @ByPtrPtr
                                     CUgraphNode_st phErrorNode,
                                     @Cast("char*")
                                     ByteBuffer logBuffer,
                                     @Cast("size_t")
                                     long bufferSize)

cuGraphInstantiate

@Cast("CUresult")
public static int cuGraphInstantiate(@ByPtrPtr
                                     CUgraphExec_st phGraphExec,
                                     CUgraph_st hGraph,
                                     @ByPtrPtr
                                     CUgraphNode_st phErrorNode,
                                     @Cast("char*")
                                     byte[] logBuffer,
                                     @Cast("size_t")
                                     long bufferSize)

cuGraphExecKernelNodeSetParams
```
@Cast("CUresult")
public static int cuGraphExecKernelNodeSetParams(CUgraphExec_st hGraphExec,
                                                 CUgraphNode_st hNode,
                                                 @Const
                                                 CUDA_KERNEL_NODE_PARAMS nodeParams)
```
\brief Sets the parameters for a kernel node in the given graphExec Sets the parameters of a kernel node in an executable graph \p hGraphExec. The node is identified by the corresponding node \p hNode in the non-executable graph, from which the executable graph was instantiated. \p hNode must not have been removed from the original graph. The \p func field of \p nodeParams cannot be modified and must match the original value. All other values can be modified. The modifications only affect future launches of \p hGraphExec. Already enqueued or running launches of \p hGraphExec are not affected by this call. \p hNode is also not modified by this call.

Parameters:

hGraphExec - - The executable graph in which to set the specified node

hNode - - kernel node from the graph from which graphExec was instantiated

nodeParams - - Updated Parameters to set

Returns:

::CUDA_SUCCESS, ::CUDA_ERROR_INVALID_VALUE, \note_graph_thread_safety \notefnerr

cuGraphExecMemcpyNodeSetParams
```
@Cast("CUresult")
public static int cuGraphExecMemcpyNodeSetParams(CUgraphExec_st hGraphExec,
                                                 CUgraphNode_st hNode,
                                                 @Const
                                                 CUDA_MEMCPY3D copyParams,
                                                 CUctx_st ctx)
```
\brief Sets the parameters for a memcpy node in the given graphExec. Updates the work represented by \p hNode in \p hGraphExec as though \p hNode had contained \p copyParams at instantiation. hNode must remain in the graph which was used to instantiate \p hGraphExec. Changed edges to and from hNode are ignored. The source and destination memory in \p copyParams must be allocated from the same contexts as the original source and destination memory. Both the instantiation-time memory operands and the memory operands in \p copyParams must be 1-dimensional. Zero-length operations are not supported. The modifications only affect future launches of \p hGraphExec. Already enqueued or running launches of \p hGraphExec are not affected by this call. hNode is also not modified by this call. Returns CUDA_ERROR_INVALID_VALUE if the memory operands’ mappings changed or either the original or new memory operands are multidimensional.

Parameters:

hGraphExec - - The executable graph in which to set the specified node

hNode - - Memcpy node from the graph which was used to instantiate graphExec

copyParams - - The updated parameters to set

ctx - - Context on which to run the node

Returns:

::CUDA_SUCCESS, ::CUDA_ERROR_INVALID_VALUE, \note_graph_thread_safety \notefnerr

cuGraphExecMemsetNodeSetParams
```
@Cast("CUresult")
public static int cuGraphExecMemsetNodeSetParams(CUgraphExec_st hGraphExec,
                                                 CUgraphNode_st hNode,
                                                 @Const
                                                 CUDA_MEMSET_NODE_PARAMS memsetParams,
                                                 CUctx_st ctx)
```
\brief Sets the parameters for a memset node in the given graphExec. Updates the work represented by \p hNode in \p hGraphExec as though \p hNode had contained \p memsetParams at instantiation. hNode must remain in the graph which was used to instantiate \p hGraphExec. Changed edges to and from hNode are ignored. The destination memory in \p memsetParams must be allocated from the same contexts as the original destination memory. Both the instantiation-time memory operand and the memory operand in \p memsetParams must be 1-dimensional. Zero-length operations are not supported. The modifications only affect future launches of \p hGraphExec. Already enqueued or running launches of \p hGraphExec are not affected by this call. hNode is also not modified by this call. Returns CUDA_ERROR_INVALID_VALUE if the memory operand’s mappings changed or either the original or new memory operand are multidimensional.

Parameters:

hGraphExec - - The executable graph in which to set the specified node

hNode - - Memset node from the graph which was used to instantiate graphExec

memsetParams - - The updated parameters to set

ctx - - Context on which to run the node

Returns:

::CUDA_SUCCESS, ::CUDA_ERROR_INVALID_VALUE, \note_graph_thread_safety \notefnerr

cuGraphExecHostNodeSetParams
```
@Cast("CUresult")
public static int cuGraphExecHostNodeSetParams(CUgraphExec_st hGraphExec,
                                               CUgraphNode_st hNode,
                                               @Const
                                               CUDA_HOST_NODE_PARAMS nodeParams)
```
\brief Sets the parameters for a host node in the given graphExec. Updates the work represented by \p hNode in \p hGraphExec as though \p hNode had contained \p nodeParams at instantiation. hNode must remain in the graph which was used to instantiate \p hGraphExec. Changed edges to and from hNode are ignored. The modifications only affect future launches of \p hGraphExec. Already enqueued or running launches of \p hGraphExec are not affected by this call. hNode is also not modified by this call.

Parameters:

hGraphExec - - The executable graph in which to set the specified node

hNode - - Host node from the graph which was used to instantiate graphExec

nodeParams - - The updated parameters to set

Returns:

::CUDA_SUCCESS, ::CUDA_ERROR_INVALID_VALUE, \note_graph_thread_safety \notefnerr

cuGraphLaunch
```
@Cast("CUresult")
public static int cuGraphLaunch(CUgraphExec_st hGraphExec,
                                CUstream_st hStream)
```
\brief Launches an executable graph in a stream Executes \p hGraphExec in \p hStream. Only one instance of \p hGraphExec may be executing at a time. Each launch is ordered behind both any previous work in \p hStream and any previous launches of \p hGraphExec. To execute a graph concurrently, it must be instantiated multiple times into multiple executable graphs.

Parameters:

hGraphExec - - Executable graph to launch

hStream - - Stream in which to launch the graph

Returns:

::CUDA_SUCCESS, ::CUDA_ERROR_DEINITIALIZED, ::CUDA_ERROR_NOT_INITIALIZED, ::CUDA_ERROR_INVALID_VALUE \note_graph_thread_safety \notefnerr

cuGraphExecDestroy
```
@Cast("CUresult")
public static int cuGraphExecDestroy(CUgraphExec_st hGraphExec)
```
\brief Destroys an executable graph Destroys the executable graph specified by \p hGraphExec, as well as all of its executable nodes. If the executable graph is in-flight, it will not be terminated, but rather freed asynchronously on completion.

Parameters:

hGraphExec - - Executable graph to destroy

Returns:

::CUDA_SUCCESS, ::CUDA_ERROR_DEINITIALIZED, ::CUDA_ERROR_NOT_INITIALIZED, ::CUDA_ERROR_INVALID_VALUE \note_graph_thread_safety \notefnerr

cuGraphDestroy
```
@Cast("CUresult")
public static int cuGraphDestroy(CUgraph_st hGraph)
```
\brief Destroys a graph Destroys the graph specified by \p hGraph, as well as all of its nodes.

Parameters:

hGraph - - Graph to destroy

Returns:

::CUDA_SUCCESS, ::CUDA_ERROR_DEINITIALIZED, ::CUDA_ERROR_NOT_INITIALIZED, ::CUDA_ERROR_INVALID_VALUE \note_graph_thread_safety \notefnerr

cuGraphExecUpdate
```
@Cast("CUresult")
public static int cuGraphExecUpdate(CUgraphExec_st hGraphExec,
                                    CUgraph_st hGraph,
                                    @ByPtrPtr
                                    CUgraphNode_st hErrorNode_out,
                                    @Cast("CUgraphExecUpdateResult*")
                                    IntPointer updateResult_out)
```
\brief Check whether an executable graph can be updated with a graph and perform the update if possible Updates the node parameters in the instantiated graph specified by \p hGraphExec with the node parameters in a topologically identical graph specified by \p hGraph. Limitations: - Kernel nodes: - The function must not change (same restriction as cuGraphExecKernelNodeSetParams()) - Memset and memcpy nodes: - The CUDA device(s) to which the operand(s) was allocated/mapped cannot change. - The source/destination memory must be allocated from the same contexts as the original source/destination memory. - Only 1D memsets can be changed. - Additional memcpy node restrictions: - Changing either the source or destination memory type(i.e. CU_MEMORYTYPE_DEVICE, CU_MEMORYTYPE_ARRAY, etc.) is not supported. Note: The API may add further restrictions in future releases. The return code should always be checked. Some node types are not currently supported: - Empty graph nodes(CU_GRAPH_NODE_TYPE_EMPTY) - Child graphs(CU_GRAPH_NODE_TYPE_GRAPH). cuGraphExecUpdate sets \p updateResult_out to CU_GRAPH_EXEC_UPDATE_ERROR_TOPOLOGY_CHANGED under the following conditions: - The count of nodes directly in \p hGraphExec and \p hGraph differ, in which case \p hErrorNode_out is NULL. - A node is deleted in \p hGraph but not not its pair from \p hGraphExec, in which case \p hErrorNode_out is NULL. - A node is deleted in \p hGraphExec but not its pair from \p hGraph, in which case \p hErrorNode_out is the pairless node from \p hGraph. - The dependent nodes of a pair differ, in which case \p hErrorNode_out is the node from \p hGraph. cuGraphExecUpdate sets \p updateResult_out to: - CU_GRAPH_EXEC_UPDATE_ERROR if passed an invalid value. - CU_GRAPH_EXEC_UPDATE_ERROR_TOPOLOGY_CHANGED if the graph topology changed - CU_GRAPH_EXEC_UPDATE_ERROR_NODE_TYPE_CHANGED if the type of a node changed, in which case \p hErrorNode_out is set to the node from \p hGraph. - CU_GRAPH_EXEC_UPDATE_ERROR_FUNCTION_CHANGED if the func field of a kernel changed, in which case \p hErrorNode_out is set to the node from \p hGraph - CU_GRAPH_EXEC_UPDATE_ERROR_PARAMETERS_CHANGED if any parameters to a node changed in a way that is not supported, in which case \p hErrorNode_out is set to the node from \p hGraph. - CU_GRAPH_EXEC_UPDATE_ERROR_NOT_SUPPORTED if something about a node is unsupported, like the node’s type or configuration, in which case \p hErrorNode_out is set to the node from \p hGraph If \p updateResult_out isn’t set in one of the situations described above, the update check passes and cuGraphExecUpdate updates \p hGraphExec to match the contents of \p hGraph. If an error happens during the update, \p updateResult_out will be set to CU_GRAPH_EXEC_UPDATE_ERROR; otherwise, \p updateResult_out is set to CU_GRAPH_EXEC_UPDATE_SUCCESS. cuGraphExecUpdate returns CUDA_SUCCESS when the updated was performed successfully. It returns CUDA_ERROR_GRAPH_EXEC_UPDATE_FAILURE if the graph update was not performed because it included changes which violated constraints specific to instantiated graph update.

Parameters:

hGraphExec - The instantiated graph to be updated

hGraph - The graph containing the updated parameters

hErrorNode_out - The node which caused the permissibility check to forbid the update, if any

updateResult_out - Whether the graph update was permitted. If was forbidden, the reason why

Returns:

::CUDA_SUCCESS, ::CUDA_ERROR_GRAPH_EXEC_UPDATE_FAILURE, \note_graph_thread_safety \notefnerr

cuGraphExecUpdate

@Cast("CUresult")
public static int cuGraphExecUpdate(CUgraphExec_st hGraphExec,
                                    CUgraph_st hGraph,
                                    @ByPtrPtr
                                    CUgraphNode_st hErrorNode_out,
                                    @Cast("CUgraphExecUpdateResult*")
                                    IntBuffer updateResult_out)

cuGraphExecUpdate

@Cast("CUresult")
public static int cuGraphExecUpdate(CUgraphExec_st hGraphExec,
                                    CUgraph_st hGraph,
                                    @ByPtrPtr
                                    CUgraphNode_st hErrorNode_out,
                                    @Cast("CUgraphExecUpdateResult*")
                                    int[] updateResult_out)

cuOccupancyMaxActiveBlocksPerMultiprocessor
```
@Cast("CUresult")
public static int cuOccupancyMaxActiveBlocksPerMultiprocessor(IntPointer numBlocks,
                                                              CUfunc_st func,
                                                              int blockSize,
                                                              @Cast("size_t")
                                                              long dynamicSMemSize)
```
\brief Returns occupancy of a function Returns in \p *numBlocks the number of the maximum active blocks per streaming multiprocessor.

Parameters:

numBlocks - - Returned occupancy

func - - Kernel for which occupancy is calculated

blockSize - - Block size the kernel is intended to be launched with

dynamicSMemSize - - Per-block dynamic shared memory usage intended, in bytes

Returns:

::CUDA_SUCCESS, ::CUDA_ERROR_DEINITIALIZED, ::CUDA_ERROR_NOT_INITIALIZED, ::CUDA_ERROR_INVALID_CONTEXT, ::CUDA_ERROR_INVALID_VALUE, ::CUDA_ERROR_UNKNOWN \notefnerr

cuOccupancyMaxActiveBlocksPerMultiprocessor

@Cast("CUresult")
public static int cuOccupancyMaxActiveBlocksPerMultiprocessor(IntBuffer numBlocks,
                                                              CUfunc_st func,
                                                              int blockSize,
                                                              @Cast("size_t")
                                                              long dynamicSMemSize)

cuOccupancyMaxActiveBlocksPerMultiprocessor

@Cast("CUresult")
public static int cuOccupancyMaxActiveBlocksPerMultiprocessor(int[] numBlocks,
                                                              CUfunc_st func,
                                                              int blockSize,
                                                              @Cast("size_t")
                                                              long dynamicSMemSize)

cuOccupancyMaxActiveBlocksPerMultiprocessorWithFlags
```
@Cast("CUresult")
public static int cuOccupancyMaxActiveBlocksPerMultiprocessorWithFlags(IntPointer numBlocks,
                                                                       CUfunc_st func,
                                                                       int blockSize,
                                                                       @Cast("size_t")
                                                                       long dynamicSMemSize,
                                                                       @Cast("unsigned int")
                                                                       int flags)
```
\brief Returns occupancy of a function Returns in \p *numBlocks the number of the maximum active blocks per streaming multiprocessor. The \p Flags parameter controls how special cases are handled. The valid flags are: - ::CU_OCCUPANCY_DEFAULT, which maintains the default behavior as ::cuOccupancyMaxActiveBlocksPerMultiprocessor; - ::CU_OCCUPANCY_DISABLE_CACHING_OVERRIDE, which suppresses the default behavior on platform where global caching affects occupancy. On such platforms, if caching is enabled, but per-block SM resource usage would result in zero occupancy, the occupancy calculator will calculate the occupancy as if caching is disabled. Setting ::CU_OCCUPANCY_DISABLE_CACHING_OVERRIDE makes the occupancy calculator to return 0 in such cases. More information can be found about this feature in the "Unified L1/Texture Cache" section of the Maxwell tuning guide.

Parameters:

numBlocks - - Returned occupancy

func - - Kernel for which occupancy is calculated

blockSize - - Block size the kernel is intended to be launched with

dynamicSMemSize - - Per-block dynamic shared memory usage intended, in bytes

flags - - Requested behavior for the occupancy calculator

Returns:

::CUDA_SUCCESS, ::CUDA_ERROR_DEINITIALIZED, ::CUDA_ERROR_NOT_INITIALIZED, ::CUDA_ERROR_INVALID_CONTEXT, ::CUDA_ERROR_INVALID_VALUE, ::CUDA_ERROR_UNKNOWN \notefnerr

cuOccupancyMaxActiveBlocksPerMultiprocessorWithFlags

@Cast("CUresult")
public static int cuOccupancyMaxActiveBlocksPerMultiprocessorWithFlags(IntBuffer numBlocks,
                                                                       CUfunc_st func,
                                                                       int blockSize,
                                                                       @Cast("size_t")
                                                                       long dynamicSMemSize,
                                                                       @Cast("unsigned int")
                                                                       int flags)

cuOccupancyMaxActiveBlocksPerMultiprocessorWithFlags

@Cast("CUresult")
public static int cuOccupancyMaxActiveBlocksPerMultiprocessorWithFlags(int[] numBlocks,
                                                                       CUfunc_st func,
                                                                       int blockSize,
                                                                       @Cast("size_t")
                                                                       long dynamicSMemSize,
                                                                       @Cast("unsigned int")
                                                                       int flags)

cuOccupancyMaxPotentialBlockSize
```
@Cast("CUresult")
public static int cuOccupancyMaxPotentialBlockSize(IntPointer minGridSize,
                                                   IntPointer blockSize,
                                                   CUfunc_st func,
                                                   CUoccupancyB2DSize blockSizeToDynamicSMemSize,
                                                   @Cast("size_t")
                                                   long dynamicSMemSize,
                                                   int blockSizeLimit)
```
\brief Suggest a launch configuration with reasonable occupancy Returns in \p *blockSize a reasonable block size that can achieve the maximum occupancy (or, the maximum number of active warps with the fewest blocks per multiprocessor), and in \p *minGridSize the minimum grid size to achieve the maximum occupancy. If \p blockSizeLimit is 0, the configurator will use the maximum block size permitted by the device / function instead. If per-block dynamic shared memory allocation is not needed, the user should leave both \p blockSizeToDynamicSMemSize and \p dynamicSMemSize as 0. If per-block dynamic shared memory allocation is needed, then if the dynamic shared memory size is constant regardless of block size, the size should be passed through \p dynamicSMemSize, and \p blockSizeToDynamicSMemSize should be NULL. Otherwise, if the per-block dynamic shared memory size varies with different block sizes, the user needs to provide a unary function through \p blockSizeToDynamicSMemSize that computes the dynamic shared memory needed by \p func for any given block size. \p dynamicSMemSize is ignored. An example signature is:
```
    // Take block size, returns dynamic shared memory needed
    size_t blockToSmem(int blockSize);
 
```
Parameters:

minGridSize - - Returned minimum grid size needed to achieve the maximum occupancy

blockSize - - Returned maximum block size that can achieve the maximum occupancy

func - - Kernel for which launch configuration is calculated

blockSizeToDynamicSMemSize - - A function that calculates how much per-block dynamic shared memory \p func uses based on the block size

dynamicSMemSize - - Dynamic shared memory usage intended, in bytes

blockSizeLimit - - The maximum block size \p func is designed to handle

Returns:

::CUDA_SUCCESS, ::CUDA_ERROR_DEINITIALIZED, ::CUDA_ERROR_NOT_INITIALIZED, ::CUDA_ERROR_INVALID_CONTEXT, ::CUDA_ERROR_INVALID_VALUE, ::CUDA_ERROR_UNKNOWN \notefnerr

cuOccupancyMaxPotentialBlockSize

@Cast("CUresult")
public static int cuOccupancyMaxPotentialBlockSize(IntBuffer minGridSize,
                                                   IntBuffer blockSize,
                                                   CUfunc_st func,
                                                   CUoccupancyB2DSize blockSizeToDynamicSMemSize,
                                                   @Cast("size_t")
                                                   long dynamicSMemSize,
                                                   int blockSizeLimit)

cuOccupancyMaxPotentialBlockSize

@Cast("CUresult")
public static int cuOccupancyMaxPotentialBlockSize(int[] minGridSize,
                                                   int[] blockSize,
                                                   CUfunc_st func,
                                                   CUoccupancyB2DSize blockSizeToDynamicSMemSize,
                                                   @Cast("size_t")
                                                   long dynamicSMemSize,
                                                   int blockSizeLimit)

cuOccupancyMaxPotentialBlockSizeWithFlags
```
@Cast("CUresult")
public static int cuOccupancyMaxPotentialBlockSizeWithFlags(IntPointer minGridSize,
                                                            IntPointer blockSize,
                                                            CUfunc_st func,
                                                            CUoccupancyB2DSize blockSizeToDynamicSMemSize,
                                                            @Cast("size_t")
                                                            long dynamicSMemSize,
                                                            int blockSizeLimit,
                                                            @Cast("unsigned int")
                                                            int flags)
```
\brief Suggest a launch configuration with reasonable occupancy An extended version of ::cuOccupancyMaxPotentialBlockSize. In addition to arguments passed to ::cuOccupancyMaxPotentialBlockSize, ::cuOccupancyMaxPotentialBlockSizeWithFlags also takes a \p Flags parameter. The \p Flags parameter controls how special cases are handled. The valid flags are: - ::CU_OCCUPANCY_DEFAULT, which maintains the default behavior as ::cuOccupancyMaxPotentialBlockSize; - ::CU_OCCUPANCY_DISABLE_CACHING_OVERRIDE, which suppresses the default behavior on platform where global caching affects occupancy. On such platforms, the launch configurations that produces maximal occupancy might not support global caching. Setting ::CU_OCCUPANCY_DISABLE_CACHING_OVERRIDE guarantees that the the produced launch configuration is global caching compatible at a potential cost of occupancy. More information can be found about this feature in the "Unified L1/Texture Cache" section of the Maxwell tuning guide.

Parameters:

minGridSize - - Returned minimum grid size needed to achieve the maximum occupancy

blockSize - - Returned maximum block size that can achieve the maximum occupancy

func - - Kernel for which launch configuration is calculated

blockSizeToDynamicSMemSize - - A function that calculates how much per-block dynamic shared memory \p func uses based on the block size

dynamicSMemSize - - Dynamic shared memory usage intended, in bytes

blockSizeLimit - - The maximum block size \p func is designed to handle

flags - - Options

Returns:

::CUDA_SUCCESS, ::CUDA_ERROR_DEINITIALIZED, ::CUDA_ERROR_NOT_INITIALIZED, ::CUDA_ERROR_INVALID_CONTEXT, ::CUDA_ERROR_INVALID_VALUE, ::CUDA_ERROR_UNKNOWN \notefnerr

cuOccupancyMaxPotentialBlockSizeWithFlags

@Cast("CUresult")
public static int cuOccupancyMaxPotentialBlockSizeWithFlags(IntBuffer minGridSize,
                                                            IntBuffer blockSize,
                                                            CUfunc_st func,
                                                            CUoccupancyB2DSize blockSizeToDynamicSMemSize,
                                                            @Cast("size_t")
                                                            long dynamicSMemSize,
                                                            int blockSizeLimit,
                                                            @Cast("unsigned int")
                                                            int flags)

cuOccupancyMaxPotentialBlockSizeWithFlags

@Cast("CUresult")
public static int cuOccupancyMaxPotentialBlockSizeWithFlags(int[] minGridSize,
                                                            int[] blockSize,
                                                            CUfunc_st func,
                                                            CUoccupancyB2DSize blockSizeToDynamicSMemSize,
                                                            @Cast("size_t")
                                                            long dynamicSMemSize,
                                                            int blockSizeLimit,
                                                            @Cast("unsigned int")
                                                            int flags)

cuTexRefSetArray
```
@Cast("CUresult")
public static int cuTexRefSetArray(CUtexref_st hTexRef,
                                   CUarray_st hArray,
                                   @Cast("unsigned int")
                                   int Flags)
```
Deprecated.
Binds the CUDA array \p hArray to the texture reference \p hTexRef. Any previous address or CUDA array state associated with the texture reference is superseded by this function. \p Flags must be set to ::CU_TRSA_OVERRIDE_FORMAT. Any CUDA array previously bound to \p hTexRef is unbound.

\brief Binds an array as a texture reference

Parameters:

hTexRef - - Texture reference to bind

hArray - - Array to bind

Flags - - Options (must be ::CU_TRSA_OVERRIDE_FORMAT)

Returns:

::CUDA_SUCCESS, ::CUDA_ERROR_DEINITIALIZED, ::CUDA_ERROR_NOT_INITIALIZED, ::CUDA_ERROR_INVALID_CONTEXT, ::CUDA_ERROR_INVALID_VALUE

cuTexRefSetMipmappedArray
```
@Cast("CUresult")
public static int cuTexRefSetMipmappedArray(CUtexref_st hTexRef,
                                            CUmipmappedArray_st hMipmappedArray,
                                            @Cast("unsigned int")
                                            int Flags)
```
Deprecated.
Binds the CUDA mipmapped array \p hMipmappedArray to the texture reference \p hTexRef. Any previous address or CUDA array state associated with the texture reference is superseded by this function. \p Flags must be set to ::CU_TRSA_OVERRIDE_FORMAT. Any CUDA array previously bound to \p hTexRef is unbound.

\brief Binds a mipmapped array to a texture reference

Parameters:

hTexRef - - Texture reference to bind

hMipmappedArray - - Mipmapped array to bind

Flags - - Options (must be ::CU_TRSA_OVERRIDE_FORMAT)

Returns:

::CUDA_SUCCESS, ::CUDA_ERROR_DEINITIALIZED, ::CUDA_ERROR_NOT_INITIALIZED, ::CUDA_ERROR_INVALID_CONTEXT, ::CUDA_ERROR_INVALID_VALUE

cuTexRefSetAddress
```
@Cast("CUresult")
public static int cuTexRefSetAddress(@Cast("size_t*")
                                     SizeTPointer ByteOffset,
                                     CUtexref_st hTexRef,
                                     @Cast("CUdeviceptr")
                                     long dptr,
                                     @Cast("size_t")
                                     long bytes)
```
Deprecated.
Binds a linear address range to the texture reference \p hTexRef. Any previous address or CUDA array state associated with the texture reference is superseded by this function. Any memory previously bound to \p hTexRef is unbound. Since the hardware enforces an alignment requirement on texture base addresses, ::cuTexRefSetAddress() passes back a byte offset in \p *ByteOffset that must be applied to texture fetches in order to read from the desired memory. This offset must be divided by the texel size and passed to kernels that read from the texture so they can be applied to the ::tex1Dfetch() function. If the device memory pointer was returned from ::cuMemAlloc(), the offset is guaranteed to be 0 and NULL may be passed as the \p ByteOffset parameter. The total number of elements (or texels) in the linear address range cannot exceed ::CU_DEVICE_ATTRIBUTE_MAXIMUM_TEXTURE1D_LINEAR_WIDTH. The number of elements is computed as (\p bytes / bytesPerElement), where bytesPerElement is determined from the data format and number of components set using ::cuTexRefSetFormat().

\brief Binds an address as a texture reference

Parameters:

ByteOffset - - Returned byte offset

hTexRef - - Texture reference to bind

dptr - - Device pointer to bind

bytes - - Size of memory to bind in bytes

Returns:

::CUDA_SUCCESS, ::CUDA_ERROR_DEINITIALIZED, ::CUDA_ERROR_NOT_INITIALIZED, ::CUDA_ERROR_INVALID_CONTEXT, ::CUDA_ERROR_INVALID_VALUE

cuTexRefSetAddress2D
```
@Cast("CUresult")
public static int cuTexRefSetAddress2D(CUtexref_st hTexRef,
                                       @Const
                                       CUDA_ARRAY_DESCRIPTOR desc,
                                       @Cast("CUdeviceptr")
                                       long dptr,
                                       @Cast("size_t")
                                       long Pitch)
```
Deprecated.
Binds a linear address range to the texture reference \p hTexRef. Any previous address or CUDA array state associated with the texture reference is superseded by this function. Any memory previously bound to \p hTexRef is unbound. Using a ::tex2D() function inside a kernel requires a call to either ::cuTexRefSetArray() to bind the corresponding texture reference to an array, or ::cuTexRefSetAddress2D() to bind the texture reference to linear memory. Function calls to ::cuTexRefSetFormat() cannot follow calls to ::cuTexRefSetAddress2D() for the same texture reference. It is required that \p dptr be aligned to the appropriate hardware-specific texture alignment. You can query this value using the device attribute ::CU_DEVICE_ATTRIBUTE_TEXTURE_ALIGNMENT. If an unaligned \p dptr is supplied, ::CUDA_ERROR_INVALID_VALUE is returned. \p Pitch has to be aligned to the hardware-specific texture pitch alignment. This value can be queried using the device attribute ::CU_DEVICE_ATTRIBUTE_TEXTURE_PITCH_ALIGNMENT. If an unaligned \p Pitch is supplied, ::CUDA_ERROR_INVALID_VALUE is returned. Width and Height, which are specified in elements (or texels), cannot exceed ::CU_DEVICE_ATTRIBUTE_MAXIMUM_TEXTURE2D_LINEAR_WIDTH and ::CU_DEVICE_ATTRIBUTE_MAXIMUM_TEXTURE2D_LINEAR_HEIGHT respectively. \p Pitch, which is specified in bytes, cannot exceed ::CU_DEVICE_ATTRIBUTE_MAXIMUM_TEXTURE2D_LINEAR_PITCH.

\brief Binds an address as a 2D texture reference

Parameters:

hTexRef - - Texture reference to bind

desc - - Descriptor of CUDA array

dptr - - Device pointer to bind

Pitch - - Line pitch in bytes

Returns:

::CUDA_SUCCESS, ::CUDA_ERROR_DEINITIALIZED, ::CUDA_ERROR_NOT_INITIALIZED, ::CUDA_ERROR_INVALID_CONTEXT, ::CUDA_ERROR_INVALID_VALUE

cuTexRefSetFormat
```
@Cast("CUresult")
public static int cuTexRefSetFormat(CUtexref_st hTexRef,
                                    @Cast("CUarray_format")
                                    int fmt,
                                    int NumPackedComponents)
```
Deprecated.
Specifies the format of the data to be read by the texture reference \p hTexRef. \p fmt and \p NumPackedComponents are exactly analogous to the ::Format and ::NumChannels members of the ::CUDA_ARRAY_DESCRIPTOR structure: They specify the format of each component and the number of components per array element.

\brief Sets the format for a texture reference

Parameters:

hTexRef - - Texture reference

fmt - - Format to set

NumPackedComponents - - Number of components per array element

Returns:

::CUDA_SUCCESS, ::CUDA_ERROR_DEINITIALIZED, ::CUDA_ERROR_NOT_INITIALIZED, ::CUDA_ERROR_INVALID_CONTEXT, ::CUDA_ERROR_INVALID_VALUE

cuTexRefSetAddressMode
```
@Cast("CUresult")
public static int cuTexRefSetAddressMode(CUtexref_st hTexRef,
                                         int dim,
                                         @Cast("CUaddress_mode")
                                         int am)
```
Deprecated.
Specifies the addressing mode \p am for the given dimension \p dim of the texture reference \p hTexRef. If \p dim is zero, the addressing mode is applied to the first parameter of the functions used to fetch from the texture; if \p dim is 1, the second, and so on. ::CUaddress_mode is defined as:
```
   typedef enum CUaddress_mode_enum {
      CU_TR_ADDRESS_MODE_WRAP = 0,
      CU_TR_ADDRESS_MODE_CLAMP = 1,
      CU_TR_ADDRESS_MODE_MIRROR = 2,
      CU_TR_ADDRESS_MODE_BORDER = 3
   } CUaddress_mode;
 
```
Note that this call has no effect if \p hTexRef is bound to linear memory. Also, if the flag, ::CU_TRSF_NORMALIZED_COORDINATES, is not set, the only supported address mode is ::CU_TR_ADDRESS_MODE_CLAMP.
\brief Sets the addressing mode for a texture reference

Parameters:

hTexRef - - Texture reference

dim - - Dimension

am - - Addressing mode to set

Returns:

::CUDA_SUCCESS, ::CUDA_ERROR_DEINITIALIZED, ::CUDA_ERROR_NOT_INITIALIZED, ::CUDA_ERROR_INVALID_CONTEXT, ::CUDA_ERROR_INVALID_VALUE

cuTexRefSetFilterMode
```
@Cast("CUresult")
public static int cuTexRefSetFilterMode(CUtexref_st hTexRef,
                                        @Cast("CUfilter_mode")
                                        int fm)
```
Deprecated.
Specifies the filtering mode \p fm to be used when reading memory through the texture reference \p hTexRef. ::CUfilter_mode_enum is defined as:
```
   typedef enum CUfilter_mode_enum {
      CU_TR_FILTER_MODE_POINT = 0,
      CU_TR_FILTER_MODE_LINEAR = 1
   } CUfilter_mode;
 
```
Note that this call has no effect if \p hTexRef is bound to linear memory.
\brief Sets the filtering mode for a texture reference

Parameters:

hTexRef - - Texture reference

fm - - Filtering mode to set

Returns:

::CUDA_SUCCESS, ::CUDA_ERROR_DEINITIALIZED, ::CUDA_ERROR_NOT_INITIALIZED, ::CUDA_ERROR_INVALID_CONTEXT, ::CUDA_ERROR_INVALID_VALUE

cuTexRefSetMipmapFilterMode
```
@Cast("CUresult")
public static int cuTexRefSetMipmapFilterMode(CUtexref_st hTexRef,
                                              @Cast("CUfilter_mode")
                                              int fm)
```
Deprecated.
Specifies the mipmap filtering mode \p fm to be used when reading memory through the texture reference \p hTexRef. ::CUfilter_mode_enum is defined as:
```
   typedef enum CUfilter_mode_enum {
      CU_TR_FILTER_MODE_POINT = 0,
      CU_TR_FILTER_MODE_LINEAR = 1
   } CUfilter_mode;
 
```
Note that this call has no effect if \p hTexRef is not bound to a mipmapped array.
\brief Sets the mipmap filtering mode for a texture reference

Parameters:

hTexRef - - Texture reference

fm - - Filtering mode to set

Returns:

::CUDA_SUCCESS, ::CUDA_ERROR_DEINITIALIZED, ::CUDA_ERROR_NOT_INITIALIZED, ::CUDA_ERROR_INVALID_CONTEXT, ::CUDA_ERROR_INVALID_VALUE

cuTexRefSetMipmapLevelBias
```
@Cast("CUresult")
public static int cuTexRefSetMipmapLevelBias(CUtexref_st hTexRef,
                                             float bias)
```
Deprecated.
Specifies the mipmap level bias \p bias to be added to the specified mipmap level when reading memory through the texture reference \p hTexRef. Note that this call has no effect if \p hTexRef is not bound to a mipmapped array.

\brief Sets the mipmap level bias for a texture reference

Parameters:

hTexRef - - Texture reference

bias - - Mipmap level bias

Returns:

::CUDA_SUCCESS, ::CUDA_ERROR_DEINITIALIZED, ::CUDA_ERROR_NOT_INITIALIZED, ::CUDA_ERROR_INVALID_CONTEXT, ::CUDA_ERROR_INVALID_VALUE

cuTexRefSetMipmapLevelClamp
```
@Cast("CUresult")
public static int cuTexRefSetMipmapLevelClamp(CUtexref_st hTexRef,
                                              float minMipmapLevelClamp,
                                              float maxMipmapLevelClamp)
```
Deprecated.
Specifies the min/max mipmap level clamps, \p minMipmapLevelClamp and \p maxMipmapLevelClamp respectively, to be used when reading memory through the texture reference \p hTexRef. Note that this call has no effect if \p hTexRef is not bound to a mipmapped array.

\brief Sets the mipmap min/max mipmap level clamps for a texture reference

Parameters:

hTexRef - - Texture reference

minMipmapLevelClamp - - Mipmap min level clamp

maxMipmapLevelClamp - - Mipmap max level clamp

Returns:

::CUDA_SUCCESS, ::CUDA_ERROR_DEINITIALIZED, ::CUDA_ERROR_NOT_INITIALIZED, ::CUDA_ERROR_INVALID_CONTEXT, ::CUDA_ERROR_INVALID_VALUE

cuTexRefSetMaxAnisotropy
```
@Cast("CUresult")
public static int cuTexRefSetMaxAnisotropy(CUtexref_st hTexRef,
                                           @Cast("unsigned int")
                                           int maxAniso)
```
Deprecated.
Specifies the maximum anisotropy \p maxAniso to be used when reading memory through the texture reference \p hTexRef. Note that this call has no effect if \p hTexRef is bound to linear memory.

\brief Sets the maximum anisotropy for a texture reference

Parameters:

hTexRef - - Texture reference

maxAniso - - Maximum anisotropy

Returns:

::CUDA_SUCCESS, ::CUDA_ERROR_DEINITIALIZED, ::CUDA_ERROR_NOT_INITIALIZED, ::CUDA_ERROR_INVALID_CONTEXT, ::CUDA_ERROR_INVALID_VALUE

cuTexRefSetBorderColor
```
@Cast("CUresult")
public static int cuTexRefSetBorderColor(CUtexref_st hTexRef,
                                         FloatPointer pBorderColor)
```
Deprecated.
Specifies the value of the RGBA color via the \p pBorderColor to the texture reference \p hTexRef. The color value supports only float type and holds color components in the following sequence: pBorderColor[0] holds 'R' component pBorderColor[1] holds 'G' component pBorderColor[2] holds 'B' component pBorderColor[3] holds 'A' component Note that the color values can be set only when the Address mode is set to CU_TR_ADDRESS_MODE_BORDER using ::cuTexRefSetAddressMode. Applications using integer border color values have to "reinterpret_cast" their values to float.

\brief Sets the border color for a texture reference

Parameters:

hTexRef - - Texture reference

pBorderColor - - RGBA color

Returns:

::CUDA_SUCCESS, ::CUDA_ERROR_DEINITIALIZED, ::CUDA_ERROR_NOT_INITIALIZED, ::CUDA_ERROR_INVALID_CONTEXT, ::CUDA_ERROR_INVALID_VALUE

cuTexRefSetBorderColor

@Cast("CUresult")
public static int cuTexRefSetBorderColor(CUtexref_st hTexRef,
                                         FloatBuffer pBorderColor)

cuTexRefSetBorderColor

@Cast("CUresult")
public static int cuTexRefSetBorderColor(CUtexref_st hTexRef,
                                         float[] pBorderColor)

cuTexRefSetFlags
```
@Cast("CUresult")
public static int cuTexRefSetFlags(CUtexref_st hTexRef,
                                   @Cast("unsigned int")
                                   int Flags)
```
Deprecated.
Specifies optional flags via \p Flags to specify the behavior of data returned through the texture reference \p hTexRef. The valid flags are: - ::CU_TRSF_READ_AS_INTEGER, which suppresses the default behavior of having the texture promote integer data to floating point data in the range [0, 1]. Note that texture with 32-bit integer format would not be promoted, regardless of whether or not this flag is specified; - ::CU_TRSF_NORMALIZED_COORDINATES, which suppresses the default behavior of having the texture coordinates range from [0, Dim) where Dim is the width or height of the CUDA array. Instead, the texture coordinates [0, 1.0) reference the entire breadth of the array dimension;

\brief Sets the flags for a texture reference

Parameters:

hTexRef - - Texture reference

Flags - - Optional flags to set

Returns:

::CUDA_SUCCESS, ::CUDA_ERROR_DEINITIALIZED, ::CUDA_ERROR_NOT_INITIALIZED, ::CUDA_ERROR_INVALID_CONTEXT, ::CUDA_ERROR_INVALID_VALUE

cuTexRefGetAddress
```
@Cast("CUresult")
public static int cuTexRefGetAddress(@Cast("CUdeviceptr*")
                                     LongPointer pdptr,
                                     CUtexref_st hTexRef)
```
Deprecated.
Returns in \p *pdptr the base address bound to the texture reference \p hTexRef, or returns ::CUDA_ERROR_INVALID_VALUE if the texture reference is not bound to any device memory range.

\brief Gets the address associated with a texture reference

Parameters:

pdptr - - Returned device address

hTexRef - - Texture reference

Returns:

::CUDA_SUCCESS, ::CUDA_ERROR_DEINITIALIZED, ::CUDA_ERROR_NOT_INITIALIZED, ::CUDA_ERROR_INVALID_CONTEXT, ::CUDA_ERROR_INVALID_VALUE

cuTexRefGetAddress

@Cast("CUresult")
public static int cuTexRefGetAddress(@Cast("CUdeviceptr*")
                                     LongBuffer pdptr,
                                     CUtexref_st hTexRef)

cuTexRefGetAddress

@Cast("CUresult")
public static int cuTexRefGetAddress(@Cast("CUdeviceptr*")
                                     long[] pdptr,
                                     CUtexref_st hTexRef)

cuTexRefGetArray
```
@Cast("CUresult")
public static int cuTexRefGetArray(@ByPtrPtr
                                   CUarray_st phArray,
                                   CUtexref_st hTexRef)
```
Deprecated.
Returns in \p *phArray the CUDA array bound to the texture reference \p hTexRef, or returns ::CUDA_ERROR_INVALID_VALUE if the texture reference is not bound to any CUDA array.

\brief Gets the array bound to a texture reference

Parameters:

phArray - - Returned array

hTexRef - - Texture reference

Returns:

::CUDA_SUCCESS, ::CUDA_ERROR_DEINITIALIZED, ::CUDA_ERROR_NOT_INITIALIZED, ::CUDA_ERROR_INVALID_CONTEXT, ::CUDA_ERROR_INVALID_VALUE

cuTexRefGetMipmappedArray
```
@Cast("CUresult")
public static int cuTexRefGetMipmappedArray(@ByPtrPtr
                                            CUmipmappedArray_st phMipmappedArray,
                                            CUtexref_st hTexRef)
```
Deprecated.
Returns in \p *phMipmappedArray the CUDA mipmapped array bound to the texture reference \p hTexRef, or returns ::CUDA_ERROR_INVALID_VALUE if the texture reference is not bound to any CUDA mipmapped array.

\brief Gets the mipmapped array bound to a texture reference

Parameters:

phMipmappedArray - - Returned mipmapped array

hTexRef - - Texture reference

Returns:

::CUDA_SUCCESS, ::CUDA_ERROR_DEINITIALIZED, ::CUDA_ERROR_NOT_INITIALIZED, ::CUDA_ERROR_INVALID_CONTEXT, ::CUDA_ERROR_INVALID_VALUE

cuTexRefGetAddressMode
```
@Cast("CUresult")
public static int cuTexRefGetAddressMode(@Cast("CUaddress_mode*")
                                         IntPointer pam,
                                         CUtexref_st hTexRef,
                                         int dim)
```
Deprecated.
Returns in \p *pam the addressing mode corresponding to the dimension \p dim of the texture reference \p hTexRef. Currently, the only valid value for \p dim are 0 and 1.

\brief Gets the addressing mode used by a texture reference

Parameters:

pam - - Returned addressing mode

hTexRef - - Texture reference

dim - - Dimension

Returns:

::CUDA_SUCCESS, ::CUDA_ERROR_DEINITIALIZED, ::CUDA_ERROR_NOT_INITIALIZED, ::CUDA_ERROR_INVALID_CONTEXT, ::CUDA_ERROR_INVALID_VALUE

cuTexRefGetAddressMode

@Cast("CUresult")
public static int cuTexRefGetAddressMode(@Cast("CUaddress_mode*")
                                         IntBuffer pam,
                                         CUtexref_st hTexRef,
                                         int dim)

cuTexRefGetAddressMode

@Cast("CUresult")
public static int cuTexRefGetAddressMode(@Cast("CUaddress_mode*")
                                         int[] pam,
                                         CUtexref_st hTexRef,
                                         int dim)

cuTexRefGetFilterMode
```
@Cast("CUresult")
public static int cuTexRefGetFilterMode(@Cast("CUfilter_mode*")
                                        IntPointer pfm,
                                        CUtexref_st hTexRef)
```
Deprecated.
Returns in \p *pfm the filtering mode of the texture reference \p hTexRef.

\brief Gets the filter-mode used by a texture reference

Parameters:

pfm - - Returned filtering mode

hTexRef - - Texture reference

Returns:

::CUDA_SUCCESS, ::CUDA_ERROR_DEINITIALIZED, ::CUDA_ERROR_NOT_INITIALIZED, ::CUDA_ERROR_INVALID_CONTEXT, ::CUDA_ERROR_INVALID_VALUE

cuTexRefGetFilterMode

@Cast("CUresult")
public static int cuTexRefGetFilterMode(@Cast("CUfilter_mode*")
                                        IntBuffer pfm,
                                        CUtexref_st hTexRef)

cuTexRefGetFilterMode

@Cast("CUresult")
public static int cuTexRefGetFilterMode(@Cast("CUfilter_mode*")
                                        int[] pfm,
                                        CUtexref_st hTexRef)

cuTexRefGetFormat
```
@Cast("CUresult")
public static int cuTexRefGetFormat(@Cast("CUarray_format*")
                                    IntPointer pFormat,
                                    IntPointer pNumChannels,
                                    CUtexref_st hTexRef)
```
Deprecated.
Returns in \p *pFormat and \p *pNumChannels the format and number of components of the CUDA array bound to the texture reference \p hTexRef. If \p pFormat or \p pNumChannels is NULL, it will be ignored.

\brief Gets the format used by a texture reference

Parameters:

pFormat - - Returned format

pNumChannels - - Returned number of components

hTexRef - - Texture reference

Returns:

::CUDA_SUCCESS, ::CUDA_ERROR_DEINITIALIZED, ::CUDA_ERROR_NOT_INITIALIZED, ::CUDA_ERROR_INVALID_CONTEXT, ::CUDA_ERROR_INVALID_VALUE

cuTexRefGetFormat

@Cast("CUresult")
public static int cuTexRefGetFormat(@Cast("CUarray_format*")
                                    IntBuffer pFormat,
                                    IntBuffer pNumChannels,
                                    CUtexref_st hTexRef)

cuTexRefGetFormat

@Cast("CUresult")
public static int cuTexRefGetFormat(@Cast("CUarray_format*")
                                    int[] pFormat,
                                    int[] pNumChannels,
                                    CUtexref_st hTexRef)

cuTexRefGetMipmapFilterMode
```
@Cast("CUresult")
public static int cuTexRefGetMipmapFilterMode(@Cast("CUfilter_mode*")
                                              IntPointer pfm,
                                              CUtexref_st hTexRef)
```
Deprecated.
Returns the mipmap filtering mode in \p pfm that's used when reading memory through the texture reference \p hTexRef.

\brief Gets the mipmap filtering mode for a texture reference

Parameters:

pfm - - Returned mipmap filtering mode

hTexRef - - Texture reference

Returns:

::CUDA_SUCCESS, ::CUDA_ERROR_DEINITIALIZED, ::CUDA_ERROR_NOT_INITIALIZED, ::CUDA_ERROR_INVALID_CONTEXT, ::CUDA_ERROR_INVALID_VALUE

cuTexRefGetMipmapFilterMode

@Cast("CUresult")
public static int cuTexRefGetMipmapFilterMode(@Cast("CUfilter_mode*")
                                              IntBuffer pfm,
                                              CUtexref_st hTexRef)

cuTexRefGetMipmapFilterMode

@Cast("CUresult")
public static int cuTexRefGetMipmapFilterMode(@Cast("CUfilter_mode*")
                                              int[] pfm,
                                              CUtexref_st hTexRef)

cuTexRefGetMipmapLevelBias
```
@Cast("CUresult")
public static int cuTexRefGetMipmapLevelBias(FloatPointer pbias,
                                             CUtexref_st hTexRef)
```
Deprecated.
Returns the mipmap level bias in \p pBias that's added to the specified mipmap level when reading memory through the texture reference \p hTexRef.

\brief Gets the mipmap level bias for a texture reference

Parameters:

pbias - - Returned mipmap level bias

hTexRef - - Texture reference

Returns:

::CUDA_SUCCESS, ::CUDA_ERROR_DEINITIALIZED, ::CUDA_ERROR_NOT_INITIALIZED, ::CUDA_ERROR_INVALID_CONTEXT, ::CUDA_ERROR_INVALID_VALUE

cuTexRefGetMipmapLevelBias

@Cast("CUresult")
public static int cuTexRefGetMipmapLevelBias(FloatBuffer pbias,
                                             CUtexref_st hTexRef)

cuTexRefGetMipmapLevelBias

@Cast("CUresult")
public static int cuTexRefGetMipmapLevelBias(float[] pbias,
                                             CUtexref_st hTexRef)

cuTexRefGetMipmapLevelClamp
```
@Cast("CUresult")
public static int cuTexRefGetMipmapLevelClamp(FloatPointer pminMipmapLevelClamp,
                                              FloatPointer pmaxMipmapLevelClamp,
                                              CUtexref_st hTexRef)
```
Deprecated.
Returns the min/max mipmap level clamps in \p pminMipmapLevelClamp and \p pmaxMipmapLevelClamp that's used when reading memory through the texture reference \p hTexRef.

\brief Gets the min/max mipmap level clamps for a texture reference

Parameters:

pminMipmapLevelClamp - - Returned mipmap min level clamp

pmaxMipmapLevelClamp - - Returned mipmap max level clamp

hTexRef - - Texture reference

Returns:

::CUDA_SUCCESS, ::CUDA_ERROR_DEINITIALIZED, ::CUDA_ERROR_NOT_INITIALIZED, ::CUDA_ERROR_INVALID_CONTEXT, ::CUDA_ERROR_INVALID_VALUE

cuTexRefGetMipmapLevelClamp

@Cast("CUresult")
public static int cuTexRefGetMipmapLevelClamp(FloatBuffer pminMipmapLevelClamp,
                                              FloatBuffer pmaxMipmapLevelClamp,
                                              CUtexref_st hTexRef)

cuTexRefGetMipmapLevelClamp

@Cast("CUresult")
public static int cuTexRefGetMipmapLevelClamp(float[] pminMipmapLevelClamp,
                                              float[] pmaxMipmapLevelClamp,
                                              CUtexref_st hTexRef)

cuTexRefGetMaxAnisotropy
```
@Cast("CUresult")
public static int cuTexRefGetMaxAnisotropy(IntPointer pmaxAniso,
                                           CUtexref_st hTexRef)
```
Deprecated.
Returns the maximum anisotropy in \p pmaxAniso that's used when reading memory through the texture reference \p hTexRef.

\brief Gets the maximum anisotropy for a texture reference

Parameters:

pmaxAniso - - Returned maximum anisotropy

hTexRef - - Texture reference

Returns:

::CUDA_SUCCESS, ::CUDA_ERROR_DEINITIALIZED, ::CUDA_ERROR_NOT_INITIALIZED, ::CUDA_ERROR_INVALID_CONTEXT, ::CUDA_ERROR_INVALID_VALUE

cuTexRefGetMaxAnisotropy

@Cast("CUresult")
public static int cuTexRefGetMaxAnisotropy(IntBuffer pmaxAniso,
                                           CUtexref_st hTexRef)

cuTexRefGetMaxAnisotropy

@Cast("CUresult")
public static int cuTexRefGetMaxAnisotropy(int[] pmaxAniso,
                                           CUtexref_st hTexRef)

cuTexRefGetBorderColor
```
@Cast("CUresult")
public static int cuTexRefGetBorderColor(FloatPointer pBorderColor,
                                         CUtexref_st hTexRef)
```
Deprecated.
Returns in \p pBorderColor, values of the RGBA color used by the texture reference \p hTexRef. The color value is of type float and holds color components in the following sequence: pBorderColor[0] holds 'R' component pBorderColor[1] holds 'G' component pBorderColor[2] holds 'B' component pBorderColor[3] holds 'A' component

\brief Gets the border color used by a texture reference

Parameters:

hTexRef - - Texture reference

pBorderColor - - Returned Type and Value of RGBA color

Returns:

::CUDA_SUCCESS, ::CUDA_ERROR_DEINITIALIZED, ::CUDA_ERROR_NOT_INITIALIZED, ::CUDA_ERROR_INVALID_CONTEXT, ::CUDA_ERROR_INVALID_VALUE

cuTexRefGetBorderColor

@Cast("CUresult")
public static int cuTexRefGetBorderColor(FloatBuffer pBorderColor,
                                         CUtexref_st hTexRef)

cuTexRefGetBorderColor

@Cast("CUresult")
public static int cuTexRefGetBorderColor(float[] pBorderColor,
                                         CUtexref_st hTexRef)

cuTexRefGetFlags
```
@Cast("CUresult")
public static int cuTexRefGetFlags(@Cast("unsigned int*")
                                   IntPointer pFlags,
                                   CUtexref_st hTexRef)
```
Deprecated.
Returns in \p *pFlags the flags of the texture reference \p hTexRef.

\brief Gets the flags used by a texture reference

Parameters:

pFlags - - Returned flags

hTexRef - - Texture reference

Returns:

::CUDA_SUCCESS, ::CUDA_ERROR_DEINITIALIZED, ::CUDA_ERROR_NOT_INITIALIZED, ::CUDA_ERROR_INVALID_CONTEXT, ::CUDA_ERROR_INVALID_VALUE

cuTexRefGetFlags

@Cast("CUresult")
public static int cuTexRefGetFlags(@Cast("unsigned int*")
                                   IntBuffer pFlags,
                                   CUtexref_st hTexRef)

cuTexRefGetFlags

@Cast("CUresult")
public static int cuTexRefGetFlags(@Cast("unsigned int*")
                                   int[] pFlags,
                                   CUtexref_st hTexRef)

cuTexRefCreate
```
@Cast("CUresult")
public static int cuTexRefCreate(@ByPtrPtr
                                 CUtexref_st pTexRef)
```
Deprecated.
Creates a texture reference and returns its handle in \p *pTexRef. Once created, the application must call ::cuTexRefSetArray() or ::cuTexRefSetAddress() to associate the reference with allocated memory. Other texture reference functions are used to specify the format and interpretation (addressing, filtering, etc.) to be used when the memory is read through this texture reference.

\brief Creates a texture reference

Parameters:

pTexRef - - Returned texture reference

Returns:

::CUDA_SUCCESS, ::CUDA_ERROR_DEINITIALIZED, ::CUDA_ERROR_NOT_INITIALIZED, ::CUDA_ERROR_INVALID_CONTEXT, ::CUDA_ERROR_INVALID_VALUE

cuTexRefDestroy
```
@Cast("CUresult")
public static int cuTexRefDestroy(CUtexref_st hTexRef)
```
Deprecated.
Destroys the texture reference specified by \p hTexRef.

\brief Destroys a texture reference

Parameters:

hTexRef - - Texture reference to destroy

Returns:

::CUDA_SUCCESS, ::CUDA_ERROR_DEINITIALIZED, ::CUDA_ERROR_NOT_INITIALIZED, ::CUDA_ERROR_INVALID_CONTEXT, ::CUDA_ERROR_INVALID_VALUE

cuSurfRefSetArray
```
@Cast("CUresult")
public static int cuSurfRefSetArray(CUsurfref_st hSurfRef,
                                    CUarray_st hArray,
                                    @Cast("unsigned int")
                                    int Flags)
```
Deprecated.
Sets the CUDA array \p hArray to be read and written by the surface reference \p hSurfRef. Any previous CUDA array state associated with the surface reference is superseded by this function. \p Flags must be set to 0. The ::CUDA_ARRAY3D_SURFACE_LDST flag must have been set for the CUDA array. Any CUDA array previously bound to \p hSurfRef is unbound.

\brief Sets the CUDA array for a surface reference.

Parameters:

hSurfRef - - Surface reference handle

hArray - - CUDA array handle

Flags - - set to 0

Returns:

::CUDA_SUCCESS, ::CUDA_ERROR_DEINITIALIZED, ::CUDA_ERROR_NOT_INITIALIZED, ::CUDA_ERROR_INVALID_CONTEXT, ::CUDA_ERROR_INVALID_VALUE

cuSurfRefGetArray
```
@Cast("CUresult")
public static int cuSurfRefGetArray(@ByPtrPtr
                                    CUarray_st phArray,
                                    CUsurfref_st hSurfRef)
```
Deprecated.
Returns in \p *phArray the CUDA array bound to the surface reference \p hSurfRef, or returns ::CUDA_ERROR_INVALID_VALUE if the surface reference is not bound to any CUDA array.

\brief Passes back the CUDA array bound to a surface reference.

Parameters:

phArray - - Surface reference handle

hSurfRef - - Surface reference handle

Returns:

::CUDA_SUCCESS, ::CUDA_ERROR_DEINITIALIZED, ::CUDA_ERROR_NOT_INITIALIZED, ::CUDA_ERROR_INVALID_CONTEXT, ::CUDA_ERROR_INVALID_VALUE

cuTexObjectCreate
```
@Cast("CUresult")
public static int cuTexObjectCreate(@Cast("CUtexObject*")
                                    LongPointer pTexObject,
                                    @Const
                                    CUDA_RESOURCE_DESC pResDesc,
                                    @Const
                                    CUDA_TEXTURE_DESC pTexDesc,
                                    @Const
                                    CUDA_RESOURCE_VIEW_DESC pResViewDesc)
```
\brief Creates a texture object Creates a texture object and returns it in \p pTexObject. \p pResDesc describes the data to texture from. \p pTexDesc describes how the data should be sampled. \p pResViewDesc is an optional argument that specifies an alternate format for the data described by \p pResDesc, and also describes the subresource region to restrict access to when texturing. \p pResViewDesc can only be specified if the type of resource is a CUDA array or a CUDA mipmapped array. Texture objects are only supported on devices of compute capability 3.0 or higher. Additionally, a texture object is an opaque value, and, as such, should only be accessed through CUDA API calls. The ::CUDA_RESOURCE_DESC structure is defined as:
```
        typedef struct CUDA_RESOURCE_DESC_st
        {
            CUresourcetype resType;

            union {
                struct {
                    CUarray hArray;
                } array;
                struct {
                    CUmipmappedArray hMipmappedArray;
                } mipmap;
                struct {
                    CUdeviceptr devPtr;
                    CUarray_format format;
                    unsigned int numChannels;
                    size_t sizeInBytes;
                } linear;
                struct {
                    CUdeviceptr devPtr;
                    CUarray_format format;
                    unsigned int numChannels;
                    size_t width;
                    size_t height;
                    size_t pitchInBytes;
                } pitch2D;
            } res;

            unsigned int flags;
        } CUDA_RESOURCE_DESC;

 
```
where: - ::CUDA_RESOURCE_DESC::resType specifies the type of resource to texture from. CUresourceType is defined as:
```
        typedef enum CUresourcetype_enum {
            CU_RESOURCE_TYPE_ARRAY           = 0x00,
            CU_RESOURCE_TYPE_MIPMAPPED_ARRAY = 0x01,
            CU_RESOURCE_TYPE_LINEAR          = 0x02,
            CU_RESOURCE_TYPE_PITCH2D         = 0x03
        } CUresourcetype;
 
```
\par If ::CUDA_RESOURCE_DESC::resType is set to ::CU_RESOURCE_TYPE_ARRAY, ::CUDA_RESOURCE_DESC::res::array::hArray must be set to a valid CUDA array handle. \par If ::CUDA_RESOURCE_DESC::resType is set to ::CU_RESOURCE_TYPE_MIPMAPPED_ARRAY, ::CUDA_RESOURCE_DESC::res::mipmap::hMipmappedArray must be set to a valid CUDA mipmapped array handle. \par If ::CUDA_RESOURCE_DESC::resType is set to ::CU_RESOURCE_TYPE_LINEAR, ::CUDA_RESOURCE_DESC::res::linear::devPtr must be set to a valid device pointer, that is aligned to ::CU_DEVICE_ATTRIBUTE_TEXTURE_ALIGNMENT. ::CUDA_RESOURCE_DESC::res::linear::format and ::CUDA_RESOURCE_DESC::res::linear::numChannels describe the format of each component and the number of components per array element. ::CUDA_RESOURCE_DESC::res::linear::sizeInBytes specifies the size of the array in bytes. The total number of elements in the linear address range cannot exceed ::CU_DEVICE_ATTRIBUTE_MAXIMUM_TEXTURE1D_LINEAR_WIDTH. The number of elements is computed as (sizeInBytes / (sizeof(format) * numChannels)). \par If ::CUDA_RESOURCE_DESC::resType is set to ::CU_RESOURCE_TYPE_PITCH2D, ::CUDA_RESOURCE_DESC::res::pitch2D::devPtr must be set to a valid device pointer, that is aligned to ::CU_DEVICE_ATTRIBUTE_TEXTURE_ALIGNMENT. ::CUDA_RESOURCE_DESC::res::pitch2D::format and ::CUDA_RESOURCE_DESC::res::pitch2D::numChannels describe the format of each component and the number of components per array element. ::CUDA_RESOURCE_DESC::res::pitch2D::width and ::CUDA_RESOURCE_DESC::res::pitch2D::height specify the width and height of the array in elements, and cannot exceed ::CU_DEVICE_ATTRIBUTE_MAXIMUM_TEXTURE2D_LINEAR_WIDTH and ::CU_DEVICE_ATTRIBUTE_MAXIMUM_TEXTURE2D_LINEAR_HEIGHT respectively. ::CUDA_RESOURCE_DESC::res::pitch2D::pitchInBytes specifies the pitch between two rows in bytes and has to be aligned to ::CU_DEVICE_ATTRIBUTE_TEXTURE_PITCH_ALIGNMENT. Pitch cannot exceed ::CU_DEVICE_ATTRIBUTE_MAXIMUM_TEXTURE2D_LINEAR_PITCH. - ::flags must be set to zero. The ::CUDA_TEXTURE_DESC struct is defined as
```
        typedef struct CUDA_TEXTURE_DESC_st {
            CUaddress_mode addressMode[3];
            CUfilter_mode filterMode;
            unsigned int flags;
            unsigned int maxAnisotropy;
            CUfilter_mode mipmapFilterMode;
            float mipmapLevelBias;
            float minMipmapLevelClamp;
            float maxMipmapLevelClamp;
        } CUDA_TEXTURE_DESC;
 
```
where - ::CUDA_TEXTURE_DESC::addressMode specifies the addressing mode for each dimension of the texture data. ::CUaddress_mode is defined as:
```
        typedef enum CUaddress_mode_enum {
            CU_TR_ADDRESS_MODE_WRAP = 0,
            CU_TR_ADDRESS_MODE_CLAMP = 1,
            CU_TR_ADDRESS_MODE_MIRROR = 2,
            CU_TR_ADDRESS_MODE_BORDER = 3
        } CUaddress_mode;
   
```
This is ignored if ::CUDA_RESOURCE_DESC::resType is ::CU_RESOURCE_TYPE_LINEAR. Also, if the flag, ::CU_TRSF_NORMALIZED_COORDINATES is not set, the only supported address mode is ::CU_TR_ADDRESS_MODE_CLAMP. - ::CUDA_TEXTURE_DESC::filterMode specifies the filtering mode to be used when fetching from the texture. CUfilter_mode is defined as:
```
        typedef enum CUfilter_mode_enum {
            CU_TR_FILTER_MODE_POINT = 0,
            CU_TR_FILTER_MODE_LINEAR = 1
        } CUfilter_mode;
   
```
This is ignored if ::CUDA_RESOURCE_DESC::resType is ::CU_RESOURCE_TYPE_LINEAR. - ::CUDA_TEXTURE_DESC::flags can be any combination of the following: - ::CU_TRSF_READ_AS_INTEGER, which suppresses the default behavior of having the texture promote integer data to floating point data in the range [0, 1]. Note that texture with 32-bit integer format would not be promoted, regardless of whether or not this flag is specified. - ::CU_TRSF_NORMALIZED_COORDINATES, which suppresses the default behavior of having the texture coordinates range from [0, Dim) where Dim is the width or height of the CUDA array. Instead, the texture coordinates [0, 1.0) reference the entire breadth of the array dimension; Note that for CUDA mipmapped arrays, this flag has to be set. - ::CUDA_TEXTURE_DESC::maxAnisotropy specifies the maximum anisotropy ratio to be used when doing anisotropic filtering. This value will be clamped to the range [1,16]. - ::CUDA_TEXTURE_DESC::mipmapFilterMode specifies the filter mode when the calculated mipmap level lies between two defined mipmap levels. - ::CUDA_TEXTURE_DESC::mipmapLevelBias specifies the offset to be applied to the calculated mipmap level. - ::CUDA_TEXTURE_DESC::minMipmapLevelClamp specifies the lower end of the mipmap level range to clamp access to. - ::CUDA_TEXTURE_DESC::maxMipmapLevelClamp specifies the upper end of the mipmap level range to clamp access to. The ::CUDA_RESOURCE_VIEW_DESC struct is defined as
```
        typedef struct CUDA_RESOURCE_VIEW_DESC_st
        {
            CUresourceViewFormat format;
            size_t width;
            size_t height;
            size_t depth;
            unsigned int firstMipmapLevel;
            unsigned int lastMipmapLevel;
            unsigned int firstLayer;
            unsigned int lastLayer;
        } CUDA_RESOURCE_VIEW_DESC;
 
```
where: - ::CUDA_RESOURCE_VIEW_DESC::format specifies how the data contained in the CUDA array or CUDA mipmapped array should be interpreted. Note that this can incur a change in size of the texture data. If the resource view format is a block compressed format, then the underlying CUDA array or CUDA mipmapped array has to have a base of format ::CU_AD_FORMAT_UNSIGNED_INT32. with 2 or 4 channels, depending on the block compressed format. For ex., BC1 and BC4 require the underlying CUDA array to have a format of ::CU_AD_FORMAT_UNSIGNED_INT32 with 2 channels. The other BC formats require the underlying resource to have the same base format but with 4 channels. - ::CUDA_RESOURCE_VIEW_DESC::width specifies the new width of the texture data. If the resource view format is a block compressed format, this value has to be 4 times the original width of the resource. For non block compressed formats, this value has to be equal to that of the original resource. - ::CUDA_RESOURCE_VIEW_DESC::height specifies the new height of the texture data. If the resource view format is a block compressed format, this value has to be 4 times the original height of the resource. For non block compressed formats, this value has to be equal to that of the original resource. - ::CUDA_RESOURCE_VIEW_DESC::depth specifies the new depth of the texture data. This value has to be equal to that of the original resource. - ::CUDA_RESOURCE_VIEW_DESC::firstMipmapLevel specifies the most detailed mipmap level. This will be the new mipmap level zero. For non-mipmapped resources, this value has to be zero.::CUDA_TEXTURE_DESC::minMipmapLevelClamp and ::CUDA_TEXTURE_DESC::maxMipmapLevelClamp will be relative to this value. For ex., if the firstMipmapLevel is set to 2, and a minMipmapLevelClamp of 1.2 is specified, then the actual minimum mipmap level clamp will be 3.2. - ::CUDA_RESOURCE_VIEW_DESC::lastMipmapLevel specifies the least detailed mipmap level. For non-mipmapped resources, this value has to be zero. - ::CUDA_RESOURCE_VIEW_DESC::firstLayer specifies the first layer index for layered textures. This will be the new layer zero. For non-layered resources, this value has to be zero. - ::CUDA_RESOURCE_VIEW_DESC::lastLayer specifies the last layer index for layered textures. For non-layered resources, this value has to be zero.
Parameters:

pTexObject - - Texture object to create

pResDesc - - Resource descriptor

pTexDesc - - Texture descriptor

pResViewDesc - - Resource view descriptor

Returns:

::CUDA_SUCCESS, ::CUDA_ERROR_DEINITIALIZED, ::CUDA_ERROR_NOT_INITIALIZED, ::CUDA_ERROR_INVALID_CONTEXT, ::CUDA_ERROR_INVALID_VALUE

cuTexObjectCreate

@Cast("CUresult")
public static int cuTexObjectCreate(@Cast("CUtexObject*")
                                    LongBuffer pTexObject,
                                    @Const
                                    CUDA_RESOURCE_DESC pResDesc,
                                    @Const
                                    CUDA_TEXTURE_DESC pTexDesc,
                                    @Const
                                    CUDA_RESOURCE_VIEW_DESC pResViewDesc)

cuTexObjectCreate

@Cast("CUresult")
public static int cuTexObjectCreate(@Cast("CUtexObject*")
                                    long[] pTexObject,
                                    @Const
                                    CUDA_RESOURCE_DESC pResDesc,
                                    @Const
                                    CUDA_TEXTURE_DESC pTexDesc,
                                    @Const
                                    CUDA_RESOURCE_VIEW_DESC pResViewDesc)

cuTexObjectDestroy
```
@Cast("CUresult")
public static int cuTexObjectDestroy(@Cast("CUtexObject")
                                     long texObject)
```
\brief Destroys a texture object Destroys the texture object specified by \p texObject.

Parameters:

texObject - - Texture object to destroy

Returns:

::CUDA_SUCCESS, ::CUDA_ERROR_DEINITIALIZED, ::CUDA_ERROR_NOT_INITIALIZED, ::CUDA_ERROR_INVALID_CONTEXT, ::CUDA_ERROR_INVALID_VALUE

cuTexObjectGetResourceDesc
```
@Cast("CUresult")
public static int cuTexObjectGetResourceDesc(CUDA_RESOURCE_DESC pResDesc,
                                             @Cast("CUtexObject")
                                             long texObject)
```
\brief Returns a texture object's resource descriptor Returns the resource descriptor for the texture object specified by \p texObject.

Parameters:

pResDesc - - Resource descriptor

texObject - - Texture object

Returns:

::CUDA_SUCCESS, ::CUDA_ERROR_DEINITIALIZED, ::CUDA_ERROR_NOT_INITIALIZED, ::CUDA_ERROR_INVALID_CONTEXT, ::CUDA_ERROR_INVALID_VALUE

cuTexObjectGetTextureDesc
```
@Cast("CUresult")
public static int cuTexObjectGetTextureDesc(CUDA_TEXTURE_DESC pTexDesc,
                                            @Cast("CUtexObject")
                                            long texObject)
```
\brief Returns a texture object's texture descriptor Returns the texture descriptor for the texture object specified by \p texObject.

Parameters:

pTexDesc - - Texture descriptor

texObject - - Texture object

Returns:

::CUDA_SUCCESS, ::CUDA_ERROR_DEINITIALIZED, ::CUDA_ERROR_NOT_INITIALIZED, ::CUDA_ERROR_INVALID_CONTEXT, ::CUDA_ERROR_INVALID_VALUE

cuTexObjectGetResourceViewDesc
```
@Cast("CUresult")
public static int cuTexObjectGetResourceViewDesc(CUDA_RESOURCE_VIEW_DESC pResViewDesc,
                                                 @Cast("CUtexObject")
                                                 long texObject)
```
\brief Returns a texture object's resource view descriptor Returns the resource view descriptor for the texture object specified by \p texObject. If no resource view was set for \p texObject, the ::CUDA_ERROR_INVALID_VALUE is returned.

Parameters:

pResViewDesc - - Resource view descriptor

texObject - - Texture object

Returns:

::CUDA_SUCCESS, ::CUDA_ERROR_DEINITIALIZED, ::CUDA_ERROR_NOT_INITIALIZED, ::CUDA_ERROR_INVALID_CONTEXT, ::CUDA_ERROR_INVALID_VALUE

cuSurfObjectCreate
```
@Cast("CUresult")
public static int cuSurfObjectCreate(@Cast("CUsurfObject*")
                                     LongPointer pSurfObject,
                                     @Const
                                     CUDA_RESOURCE_DESC pResDesc)
```
\brief Creates a surface object Creates a surface object and returns it in \p pSurfObject. \p pResDesc describes the data to perform surface load/stores on. ::CUDA_RESOURCE_DESC::resType must be ::CU_RESOURCE_TYPE_ARRAY and ::CUDA_RESOURCE_DESC::res::array::hArray must be set to a valid CUDA array handle. ::CUDA_RESOURCE_DESC::flags must be set to zero. Surface objects are only supported on devices of compute capability 3.0 or higher. Additionally, a surface object is an opaque value, and, as such, should only be accessed through CUDA API calls.

Parameters:

pSurfObject - - Surface object to create

pResDesc - - Resource descriptor

Returns:

::CUDA_SUCCESS, ::CUDA_ERROR_DEINITIALIZED, ::CUDA_ERROR_NOT_INITIALIZED, ::CUDA_ERROR_INVALID_CONTEXT, ::CUDA_ERROR_INVALID_VALUE

cuSurfObjectCreate

@Cast("CUresult")
public static int cuSurfObjectCreate(@Cast("CUsurfObject*")
                                     LongBuffer pSurfObject,
                                     @Const
                                     CUDA_RESOURCE_DESC pResDesc)

cuSurfObjectCreate

@Cast("CUresult")
public static int cuSurfObjectCreate(@Cast("CUsurfObject*")
                                     long[] pSurfObject,
                                     @Const
                                     CUDA_RESOURCE_DESC pResDesc)

cuSurfObjectDestroy
```
@Cast("CUresult")
public static int cuSurfObjectDestroy(@Cast("CUsurfObject")
                                      long surfObject)
```
\brief Destroys a surface object Destroys the surface object specified by \p surfObject.

Parameters:

surfObject - - Surface object to destroy

Returns:

::CUDA_SUCCESS, ::CUDA_ERROR_DEINITIALIZED, ::CUDA_ERROR_NOT_INITIALIZED, ::CUDA_ERROR_INVALID_CONTEXT, ::CUDA_ERROR_INVALID_VALUE

cuSurfObjectGetResourceDesc
```
@Cast("CUresult")
public static int cuSurfObjectGetResourceDesc(CUDA_RESOURCE_DESC pResDesc,
                                              @Cast("CUsurfObject")
                                              long surfObject)
```
\brief Returns a surface object's resource descriptor Returns the resource descriptor for the surface object specified by \p surfObject.

Parameters:

pResDesc - - Resource descriptor

surfObject - - Surface object

Returns:

::CUDA_SUCCESS, ::CUDA_ERROR_DEINITIALIZED, ::CUDA_ERROR_NOT_INITIALIZED, ::CUDA_ERROR_INVALID_CONTEXT, ::CUDA_ERROR_INVALID_VALUE

cuDeviceCanAccessPeer
```
@Cast("CUresult")
public static int cuDeviceCanAccessPeer(IntPointer canAccessPeer,
                                        @Cast("CUdevice")
                                        int dev,
                                        @Cast("CUdevice")
                                        int peerDev)
```
\brief Queries if a device may directly access a peer device's memory. Returns in \p *canAccessPeer a value of 1 if contexts on \p dev are capable of directly accessing memory from contexts on \p peerDev and 0 otherwise. If direct access of \p peerDev from \p dev is possible, then access may be enabled on two specific contexts by calling ::cuCtxEnablePeerAccess().

Parameters:

canAccessPeer - - Returned access capability

dev - - Device from which allocations on \p peerDev are to be directly accessed.

peerDev - - Device on which the allocations to be directly accessed by \p dev reside.

Returns:

::CUDA_SUCCESS, ::CUDA_ERROR_DEINITIALIZED, ::CUDA_ERROR_NOT_INITIALIZED, ::CUDA_ERROR_INVALID_DEVICE \notefnerr

cuDeviceCanAccessPeer

@Cast("CUresult")
public static int cuDeviceCanAccessPeer(IntBuffer canAccessPeer,
                                        @Cast("CUdevice")
                                        int dev,
                                        @Cast("CUdevice")
                                        int peerDev)

cuDeviceCanAccessPeer

@Cast("CUresult")
public static int cuDeviceCanAccessPeer(int[] canAccessPeer,
                                        @Cast("CUdevice")
                                        int dev,
                                        @Cast("CUdevice")
                                        int peerDev)

cuCtxEnablePeerAccess
```
@Cast("CUresult")
public static int cuCtxEnablePeerAccess(CUctx_st peerContext,
                                        @Cast("unsigned int")
                                        int Flags)
```
\brief Enables direct access to memory allocations in a peer context. If both the current context and \p peerContext are on devices which support unified addressing (as may be queried using ::CU_DEVICE_ATTRIBUTE_UNIFIED_ADDRESSING) and same major compute capability, then on success all allocations from \p peerContext will immediately be accessible by the current context. See \ref CUDA_UNIFIED for additional details. Note that access granted by this call is unidirectional and that in order to access memory from the current context in \p peerContext, a separate symmetric call to ::cuCtxEnablePeerAccess() is required. Note that there are both device-wide and system-wide limitations per system configuration, as noted in the CUDA Programming Guide under the section "Peer-to-Peer Memory Access". Returns ::CUDA_ERROR_PEER_ACCESS_UNSUPPORTED if ::cuDeviceCanAccessPeer() indicates that the ::CUdevice of the current context cannot directly access memory from the ::CUdevice of \p peerContext. Returns ::CUDA_ERROR_PEER_ACCESS_ALREADY_ENABLED if direct access of \p peerContext from the current context has already been enabled. Returns ::CUDA_ERROR_TOO_MANY_PEERS if direct peer access is not possible because hardware resources required for peer access have been exhausted. Returns ::CUDA_ERROR_INVALID_CONTEXT if there is no current context, \p peerContext is not a valid context, or if the current context is \p peerContext. Returns ::CUDA_ERROR_INVALID_VALUE if \p Flags is not 0.

Parameters:

peerContext - - Peer context to enable direct access to from the current context

Flags - - Reserved for future use and must be set to 0

Returns:

::CUDA_SUCCESS, ::CUDA_ERROR_DEINITIALIZED, ::CUDA_ERROR_NOT_INITIALIZED, ::CUDA_ERROR_PEER_ACCESS_ALREADY_ENABLED, ::CUDA_ERROR_TOO_MANY_PEERS, ::CUDA_ERROR_INVALID_CONTEXT, ::CUDA_ERROR_PEER_ACCESS_UNSUPPORTED, ::CUDA_ERROR_INVALID_VALUE \notefnerr

cuCtxDisablePeerAccess
```
@Cast("CUresult")
public static int cuCtxDisablePeerAccess(CUctx_st peerContext)
```
\brief Disables direct access to memory allocations in a peer context and unregisters any registered allocations. Returns ::CUDA_ERROR_PEER_ACCESS_NOT_ENABLED if direct peer access has not yet been enabled from \p peerContext to the current context. Returns ::CUDA_ERROR_INVALID_CONTEXT if there is no current context, or if \p peerContext is not a valid context.

Parameters:

peerContext - - Peer context to disable direct access to

Returns:

::CUDA_SUCCESS, ::CUDA_ERROR_DEINITIALIZED, ::CUDA_ERROR_NOT_INITIALIZED, ::CUDA_ERROR_PEER_ACCESS_NOT_ENABLED, ::CUDA_ERROR_INVALID_CONTEXT, \notefnerr

cuGraphicsUnregisterResource
```
@Cast("CUresult")
public static int cuGraphicsUnregisterResource(CUgraphicsResource_st resource)
```
\brief Unregisters a graphics resource for access by CUDA Unregisters the graphics resource \p resource so it is not accessible by CUDA unless registered again. If \p resource is invalid then ::CUDA_ERROR_INVALID_HANDLE is returned.

Parameters:

resource - - Resource to unregister

Returns:

::CUDA_SUCCESS, ::CUDA_ERROR_DEINITIALIZED, ::CUDA_ERROR_NOT_INITIALIZED, ::CUDA_ERROR_INVALID_CONTEXT, ::CUDA_ERROR_INVALID_HANDLE, ::CUDA_ERROR_UNKNOWN \notefnerr

cuGraphicsSubResourceGetMappedArray
```
@Cast("CUresult")
public static int cuGraphicsSubResourceGetMappedArray(@ByPtrPtr
                                                      CUarray_st pArray,
                                                      CUgraphicsResource_st resource,
                                                      @Cast("unsigned int")
                                                      int arrayIndex,
                                                      @Cast("unsigned int")
                                                      int mipLevel)
```
\brief Get an array through which to access a subresource of a mapped graphics resource. Returns in \p *pArray an array through which the subresource of the mapped graphics resource \p resource which corresponds to array index \p arrayIndex and mipmap level \p mipLevel may be accessed. The value set in \p *pArray may change every time that \p resource is mapped. If \p resource is not a texture then it cannot be accessed via an array and ::CUDA_ERROR_NOT_MAPPED_AS_ARRAY is returned. If \p arrayIndex is not a valid array index for \p resource then ::CUDA_ERROR_INVALID_VALUE is returned. If \p mipLevel is not a valid mipmap level for \p resource then ::CUDA_ERROR_INVALID_VALUE is returned. If \p resource is not mapped then ::CUDA_ERROR_NOT_MAPPED is returned.

Parameters:

pArray - - Returned array through which a subresource of \p resource may be accessed

resource - - Mapped resource to access

arrayIndex - - Array index for array textures or cubemap face index as defined by ::CUarray_cubemap_face for cubemap textures for the subresource to access

mipLevel - - Mipmap level for the subresource to access

Returns:

::CUDA_SUCCESS, ::CUDA_ERROR_DEINITIALIZED, ::CUDA_ERROR_NOT_INITIALIZED, ::CUDA_ERROR_INVALID_CONTEXT, ::CUDA_ERROR_INVALID_VALUE, ::CUDA_ERROR_INVALID_HANDLE, ::CUDA_ERROR_NOT_MAPPED, ::CUDA_ERROR_NOT_MAPPED_AS_ARRAY \notefnerr

cuGraphicsResourceGetMappedMipmappedArray
```
@Cast("CUresult")
public static int cuGraphicsResourceGetMappedMipmappedArray(@ByPtrPtr
                                                            CUmipmappedArray_st pMipmappedArray,
                                                            CUgraphicsResource_st resource)
```
\brief Get a mipmapped array through which to access a mapped graphics resource. Returns in \p *pMipmappedArray a mipmapped array through which the mapped graphics resource \p resource. The value set in \p *pMipmappedArray may change every time that \p resource is mapped. If \p resource is not a texture then it cannot be accessed via a mipmapped array and ::CUDA_ERROR_NOT_MAPPED_AS_ARRAY is returned. If \p resource is not mapped then ::CUDA_ERROR_NOT_MAPPED is returned.

Parameters:

pMipmappedArray - - Returned mipmapped array through which \p resource may be accessed

resource - - Mapped resource to access

Returns:

::CUDA_SUCCESS, ::CUDA_ERROR_DEINITIALIZED, ::CUDA_ERROR_NOT_INITIALIZED, ::CUDA_ERROR_INVALID_CONTEXT, ::CUDA_ERROR_INVALID_VALUE, ::CUDA_ERROR_INVALID_HANDLE, ::CUDA_ERROR_NOT_MAPPED, ::CUDA_ERROR_NOT_MAPPED_AS_ARRAY \notefnerr

cuGraphicsResourceGetMappedPointer
```
@Cast("CUresult")
public static int cuGraphicsResourceGetMappedPointer(@Cast("CUdeviceptr*")
                                                     LongPointer pDevPtr,
                                                     @Cast("size_t*")
                                                     SizeTPointer pSize,
                                                     CUgraphicsResource_st resource)
```
\brief Get a device pointer through which to access a mapped graphics resource. Returns in \p *pDevPtr a pointer through which the mapped graphics resource \p resource may be accessed. Returns in \p pSize the size of the memory in bytes which may be accessed from that pointer. The value set in \p pPointer may change every time that \p resource is mapped. If \p resource is not a buffer then it cannot be accessed via a pointer and ::CUDA_ERROR_NOT_MAPPED_AS_POINTER is returned. If \p resource is not mapped then ::CUDA_ERROR_NOT_MAPPED is returned. *

Parameters:

pDevPtr - - Returned pointer through which \p resource may be accessed

pSize - - Returned size of the buffer accessible starting at \p *pPointer

resource - - Mapped resource to access

Returns:

::CUDA_SUCCESS, ::CUDA_ERROR_DEINITIALIZED, ::CUDA_ERROR_NOT_INITIALIZED, ::CUDA_ERROR_INVALID_CONTEXT, ::CUDA_ERROR_INVALID_VALUE, ::CUDA_ERROR_INVALID_HANDLE, ::CUDA_ERROR_NOT_MAPPED, ::CUDA_ERROR_NOT_MAPPED_AS_POINTER \notefnerr

cuGraphicsResourceGetMappedPointer

@Cast("CUresult")
public static int cuGraphicsResourceGetMappedPointer(@Cast("CUdeviceptr*")
                                                     LongBuffer pDevPtr,
                                                     @Cast("size_t*")
                                                     SizeTPointer pSize,
                                                     CUgraphicsResource_st resource)

cuGraphicsResourceGetMappedPointer

@Cast("CUresult")
public static int cuGraphicsResourceGetMappedPointer(@Cast("CUdeviceptr*")
                                                     long[] pDevPtr,
                                                     @Cast("size_t*")
                                                     SizeTPointer pSize,
                                                     CUgraphicsResource_st resource)

cuGraphicsResourceSetMapFlags
```
@Cast("CUresult")
public static int cuGraphicsResourceSetMapFlags(CUgraphicsResource_st resource,
                                                @Cast("unsigned int")
                                                int flags)
```
\brief Set usage flags for mapping a graphics resource Set \p flags for mapping the graphics resource \p resource. Changes to \p flags will take effect the next time \p resource is mapped. The \p flags argument may be any of the following:
- ::CU_GRAPHICS_MAP_RESOURCE_FLAGS_NONE: Specifies no hints about how this resource will be used. It is therefore assumed that this resource will be read from and written to by CUDA kernels. This is the default value. - ::CU_GRAPHICS_MAP_RESOURCE_FLAGS_READONLY: Specifies that CUDA kernels which access this resource will not write to this resource. - ::CU_GRAPHICS_MAP_RESOURCE_FLAGS_WRITEDISCARD: Specifies that CUDA kernels which access this resource will not read from this resource and will write over the entire contents of the resource, so none of the data previously stored in the resource will be preserved. If \p resource is presently mapped for access by CUDA then ::CUDA_ERROR_ALREADY_MAPPED is returned. If \p flags is not one of the above values then ::CUDA_ERROR_INVALID_VALUE is returned.

Parameters:

resource - - Registered resource to set flags for

flags - - Parameters for resource mapping

Returns:

::CUDA_SUCCESS, ::CUDA_ERROR_DEINITIALIZED, ::CUDA_ERROR_NOT_INITIALIZED, ::CUDA_ERROR_INVALID_CONTEXT, ::CUDA_ERROR_INVALID_VALUE, ::CUDA_ERROR_INVALID_HANDLE, ::CUDA_ERROR_ALREADY_MAPPED \notefnerr

cuGraphicsMapResources
```
@Cast("CUresult")
public static int cuGraphicsMapResources(@Cast("unsigned int")
                                         int count,
                                         @ByPtrPtr
                                         CUgraphicsResource_st resources,
                                         CUstream_st hStream)
```
\brief Map graphics resources for access by CUDA Maps the \p count graphics resources in \p resources for access by CUDA. The resources in \p resources may be accessed by CUDA until they are unmapped. The graphics API from which \p resources were registered should not access any resources while they are mapped by CUDA. If an application does so, the results are undefined. This function provides the synchronization guarantee that any graphics calls issued before ::cuGraphicsMapResources() will complete before any subsequent CUDA work issued in \p stream begins. If \p resources includes any duplicate entries then ::CUDA_ERROR_INVALID_HANDLE is returned. If any of \p resources are presently mapped for access by CUDA then ::CUDA_ERROR_ALREADY_MAPPED is returned.

Parameters:

count - - Number of resources to map

resources - - Resources to map for CUDA usage

hStream - - Stream with which to synchronize

Returns:

::CUDA_SUCCESS, ::CUDA_ERROR_DEINITIALIZED, ::CUDA_ERROR_NOT_INITIALIZED, ::CUDA_ERROR_INVALID_CONTEXT, ::CUDA_ERROR_INVALID_HANDLE, ::CUDA_ERROR_ALREADY_MAPPED, ::CUDA_ERROR_UNKNOWN \note_null_stream \notefnerr

cuGraphicsUnmapResources
```
@Cast("CUresult")
public static int cuGraphicsUnmapResources(@Cast("unsigned int")
                                           int count,
                                           @ByPtrPtr
                                           CUgraphicsResource_st resources,
                                           CUstream_st hStream)
```
\brief Unmap graphics resources. Unmaps the \p count graphics resources in \p resources. Once unmapped, the resources in \p resources may not be accessed by CUDA until they are mapped again. This function provides the synchronization guarantee that any CUDA work issued in \p stream before ::cuGraphicsUnmapResources() will complete before any subsequently issued graphics work begins. If \p resources includes any duplicate entries then ::CUDA_ERROR_INVALID_HANDLE is returned. If any of \p resources are not presently mapped for access by CUDA then ::CUDA_ERROR_NOT_MAPPED is returned.

Parameters:

count - - Number of resources to unmap

resources - - Resources to unmap

hStream - - Stream with which to synchronize

Returns:

::CUDA_SUCCESS, ::CUDA_ERROR_DEINITIALIZED, ::CUDA_ERROR_NOT_INITIALIZED, ::CUDA_ERROR_INVALID_CONTEXT, ::CUDA_ERROR_INVALID_HANDLE, ::CUDA_ERROR_NOT_MAPPED, ::CUDA_ERROR_UNKNOWN \note_null_stream \notefnerr

cuGetExportTable

@Cast("CUresult")
public static int cuGetExportTable(@Cast("const void**")
                                   PointerPointer ppExportTable,
                                   @Const
                                   CUuuid pExportTableId)

\}

cuGetExportTable

@Cast("CUresult")
public static int cuGetExportTable(@Cast("const void**") @ByPtrPtr
                                   Pointer ppExportTable,
                                   @Const
                                   CUuuid pExportTableId)

cudaStreamLegacy
```
@MemberGetter
public static CUstream_st cudaStreamLegacy()
```
Legacy stream handle Stream handle that can be passed as a cudaStream_t to use an implicit stream with legacy synchronization behavior. See details of the \link_sync_behavior

cudaStreamPerThread
```
@MemberGetter
public static CUstream_st cudaStreamPerThread()
```
Per-thread stream handle Stream handle that can be passed as a cudaStream_t to use an implicit stream with per-thread synchronization behavior. See details of the \link_sync_behavior

cudaDeviceReset
```
@Cast("cudaError_t")
public static int cudaDeviceReset()
```
\brief Destroy all allocations and reset all state on the current device in the current process. Explicitly destroys and cleans up all resources associated with the current device in the current process. Any subsequent API call to this device will reinitialize the device. Note that this function will reset the device immediately. It is the caller's responsibility to ensure that the device is not being accessed by any other host threads from the process when this function is called.

Returns:

::cudaSuccess \notefnerr \note_init_rt \note_callback

cudaDeviceSynchronize
```
@Cast("cudaError_t")
public static int cudaDeviceSynchronize()
```
\brief Wait for compute device to finish Blocks until the device has completed all preceding requested tasks. ::cudaDeviceSynchronize() returns an error if one of the preceding tasks has failed. If the ::cudaDeviceScheduleBlockingSync flag was set for this device, the host thread will block until the device has finished its work.

Returns:

::cudaSuccess \notefnerr \note_init_rt \note_callback

cudaDeviceSetLimit
```
@Cast("cudaError_t")
public static int cudaDeviceSetLimit(@Cast("cudaLimit")
                                     int _limit,
                                     @Cast("size_t")
                                     long value)
```
\brief Set resource limits Setting \p limit to \p value is a request by the application to update the current limit maintained by the device. The driver is free to modify the requested value to meet h/w requirements (this could be clamping to minimum or maximum values, rounding up to nearest element size, etc). The application can use ::cudaDeviceGetLimit() to find out exactly what the limit has been set to. Setting each ::cudaLimit has its own specific restrictions, so each is discussed here. - ::cudaLimitStackSize controls the stack size in bytes of each GPU thread. Note that the CUDA driver will set the \p limit to the maximum of \p value and what the kernel function requires. - ::cudaLimitPrintfFifoSize controls the size in bytes of the shared FIFO used by the ::printf() device system call. Setting ::cudaLimitPrintfFifoSize must not be performed after launching any kernel that uses the ::printf() device system call - in such case ::cudaErrorInvalidValue will be returned. - ::cudaLimitMallocHeapSize controls the size in bytes of the heap used by the ::malloc() and ::free() device system calls. Setting ::cudaLimitMallocHeapSize must not be performed after launching any kernel that uses the ::malloc() or ::free() device system calls - in such case ::cudaErrorInvalidValue will be returned. - ::cudaLimitDevRuntimeSyncDepth controls the maximum nesting depth of a grid at which a thread can safely call ::cudaDeviceSynchronize(). Setting this limit must be performed before any launch of a kernel that uses the device runtime and calls ::cudaDeviceSynchronize() above the default sync depth, two levels of grids. Calls to ::cudaDeviceSynchronize() will fail with error code ::cudaErrorSyncDepthExceeded if the limitation is violated. This limit can be set smaller than the default or up the maximum launch depth of 24. When setting this limit, keep in mind that additional levels of sync depth require the runtime to reserve large amounts of device memory which can no longer be used for user allocations. If these reservations of device memory fail, ::cudaDeviceSetLimit will return ::cudaErrorMemoryAllocation, and the limit can be reset to a lower value. This limit is only applicable to devices of compute capability 3.5 and higher. Attempting to set this limit on devices of compute capability less than 3.5 will result in the error ::cudaErrorUnsupportedLimit being returned. - ::cudaLimitDevRuntimePendingLaunchCount controls the maximum number of outstanding device runtime launches that can be made from the current device. A grid is outstanding from the point of launch up until the grid is known to have been completed. Device runtime launches which violate this limitation fail and return ::cudaErrorLaunchPendingCountExceeded when ::cudaGetLastError() is called after launch. If more pending launches than the default (2048 launches) are needed for a module using the device runtime, this limit can be increased. Keep in mind that being able to sustain additional pending launches will require the runtime to reserve larger amounts of device memory upfront which can no longer be used for allocations. If these reservations fail, ::cudaDeviceSetLimit will return ::cudaErrorMemoryAllocation, and the limit can be reset to a lower value. This limit is only applicable to devices of compute capability 3.5 and higher. Attempting to set this limit on devices of compute capability less than 3.5 will result in the error ::cudaErrorUnsupportedLimit being returned. - ::cudaLimitMaxL2FetchGranularity controls the L2 cache fetch granularity. Values can range from 0B to 128B. This is purely a performance hint and it can be ignored or clamped depending on the platform.

Parameters:

limit - - Limit to set

value - - Size of limit

Returns:

::cudaSuccess, ::cudaErrorUnsupportedLimit, ::cudaErrorInvalidValue, ::cudaErrorMemoryAllocation \notefnerr \note_init_rt \note_callback

cudaDeviceGetLimit
```
@Cast("cudaError_t")
public static int cudaDeviceGetLimit(@Cast("size_t*")
                                     SizeTPointer pValue,
                                     @Cast("cudaLimit")
                                     int _limit)
```
\brief Returns resource limits Returns in \p *pValue the current size of \p limit. The supported ::cudaLimit values are: - ::cudaLimitStackSize: stack size in bytes of each GPU thread; - ::cudaLimitPrintfFifoSize: size in bytes of the shared FIFO used by the ::printf() device system call. - ::cudaLimitMallocHeapSize: size in bytes of the heap used by the ::malloc() and ::free() device system calls; - ::cudaLimitDevRuntimeSyncDepth: maximum grid depth at which a thread can isssue the device runtime call ::cudaDeviceSynchronize() to wait on child grid launches to complete. - ::cudaLimitDevRuntimePendingLaunchCount: maximum number of outstanding device runtime launches. - ::cudaLimitMaxL2FetchGranularity: L2 cache fetch granularity.

Parameters:

limit - - Limit to query

pValue - - Returned size of the limit

Returns:

::cudaSuccess, ::cudaErrorUnsupportedLimit, ::cudaErrorInvalidValue \notefnerr \note_init_rt \note_callback

cudaDeviceGetCacheConfig
```
@Cast("cudaError_t")
public static int cudaDeviceGetCacheConfig(@Cast("cudaFuncCache*")
                                           IntPointer pCacheConfig)
```
\brief Returns the preferred cache configuration for the current device. On devices where the L1 cache and shared memory use the same hardware resources, this returns through \p pCacheConfig the preferred cache configuration for the current device. This is only a preference. The runtime will use the requested configuration if possible, but it is free to choose a different configuration if required to execute functions. This will return a \p pCacheConfig of ::cudaFuncCachePreferNone on devices where the size of the L1 cache and shared memory are fixed. The supported cache configurations are: - ::cudaFuncCachePreferNone: no preference for shared memory or L1 (default) - ::cudaFuncCachePreferShared: prefer larger shared memory and smaller L1 cache - ::cudaFuncCachePreferL1: prefer larger L1 cache and smaller shared memory - ::cudaFuncCachePreferEqual: prefer equal size L1 cache and shared memory

Parameters:

pCacheConfig - - Returned cache configuration

Returns:

::cudaSuccess \notefnerr \note_init_rt \note_callback

cudaDeviceGetCacheConfig

@Cast("cudaError_t")
public static int cudaDeviceGetCacheConfig(@Cast("cudaFuncCache*")
                                           IntBuffer pCacheConfig)

cudaDeviceGetCacheConfig

@Cast("cudaError_t")
public static int cudaDeviceGetCacheConfig(@Cast("cudaFuncCache*")
                                           int[] pCacheConfig)

cudaDeviceGetStreamPriorityRange
```
@Cast("cudaError_t")
public static int cudaDeviceGetStreamPriorityRange(IntPointer leastPriority,
                                                   IntPointer greatestPriority)
```
\brief Returns numerical values that correspond to the least and greatest stream priorities. Returns in \p *leastPriority and \p *greatestPriority the numerical values that correspond to the least and greatest stream priorities respectively. Stream priorities follow a convention where lower numbers imply greater priorities. The range of meaningful stream priorities is given by [\p *greatestPriority, \p *leastPriority]. If the user attempts to create a stream with a priority value that is outside the the meaningful range as specified by this API, the priority is automatically clamped down or up to either \p *leastPriority or \p *greatestPriority respectively. See ::cudaStreamCreateWithPriority for details on creating a priority stream. A NULL may be passed in for \p *leastPriority or \p *greatestPriority if the value is not desired. This function will return '0' in both \p *leastPriority and \p *greatestPriority if the current context's device does not support stream priorities (see ::cudaDeviceGetAttribute).

Parameters:

leastPriority - - Pointer to an int in which the numerical value for least stream priority is returned

greatestPriority - - Pointer to an int in which the numerical value for greatest stream priority is returned

Returns:

::cudaSuccess \notefnerr \note_init_rt \note_callback

cudaDeviceGetStreamPriorityRange

@Cast("cudaError_t")
public static int cudaDeviceGetStreamPriorityRange(IntBuffer leastPriority,
                                                   IntBuffer greatestPriority)

cudaDeviceGetStreamPriorityRange

@Cast("cudaError_t")
public static int cudaDeviceGetStreamPriorityRange(int[] leastPriority,
                                                   int[] greatestPriority)

cudaDeviceSetCacheConfig
```
@Cast("cudaError_t")
public static int cudaDeviceSetCacheConfig(@Cast("cudaFuncCache")
                                           int cacheConfig)
```
\brief Sets the preferred cache configuration for the current device. On devices where the L1 cache and shared memory use the same hardware resources, this sets through \p cacheConfig the preferred cache configuration for the current device. This is only a preference. The runtime will use the requested configuration if possible, but it is free to choose a different configuration if required to execute the function. Any function preference set via \ref ::cudaFuncSetCacheConfig(const void*, enum cudaFuncCache) "cudaFuncSetCacheConfig (C API)" or \ref ::cudaFuncSetCacheConfig(T*, enum cudaFuncCache) "cudaFuncSetCacheConfig (C++ API)" will be preferred over this device-wide setting. Setting the device-wide cache configuration to ::cudaFuncCachePreferNone will cause subsequent kernel launches to prefer to not change the cache configuration unless required to launch the kernel. This setting does nothing on devices where the size of the L1 cache and shared memory are fixed. Launching a kernel with a different preference than the most recent preference setting may insert a device-side synchronization point. The supported cache configurations are: - ::cudaFuncCachePreferNone: no preference for shared memory or L1 (default) - ::cudaFuncCachePreferShared: prefer larger shared memory and smaller L1 cache - ::cudaFuncCachePreferL1: prefer larger L1 cache and smaller shared memory - ::cudaFuncCachePreferEqual: prefer equal size L1 cache and shared memory

Parameters:

cacheConfig - - Requested cache configuration

Returns:

::cudaSuccess \notefnerr \note_init_rt \note_callback

cudaDeviceGetSharedMemConfig
```
@Cast("cudaError_t")
public static int cudaDeviceGetSharedMemConfig(@Cast("cudaSharedMemConfig*")
                                               IntPointer pConfig)
```
\brief Returns the shared memory configuration for the current device. This function will return in \p pConfig the current size of shared memory banks on the current device. On devices with configurable shared memory banks, ::cudaDeviceSetSharedMemConfig can be used to change this setting, so that all subsequent kernel launches will by default use the new bank size. When ::cudaDeviceGetSharedMemConfig is called on devices without configurable shared memory, it will return the fixed bank size of the hardware. The returned bank configurations can be either: - ::cudaSharedMemBankSizeFourByte - shared memory bank width is four bytes. - ::cudaSharedMemBankSizeEightByte - shared memory bank width is eight bytes.

Parameters:

pConfig - - Returned cache configuration

Returns:

::cudaSuccess, ::cudaErrorInvalidValue \notefnerr \note_init_rt \note_callback

cudaDeviceGetSharedMemConfig

@Cast("cudaError_t")
public static int cudaDeviceGetSharedMemConfig(@Cast("cudaSharedMemConfig*")
                                               IntBuffer pConfig)

cudaDeviceGetSharedMemConfig

@Cast("cudaError_t")
public static int cudaDeviceGetSharedMemConfig(@Cast("cudaSharedMemConfig*")
                                               int[] pConfig)

cudaDeviceSetSharedMemConfig
```
@Cast("cudaError_t")
public static int cudaDeviceSetSharedMemConfig(@Cast("cudaSharedMemConfig")
                                               int config)
```
\brief Sets the shared memory configuration for the current device. On devices with configurable shared memory banks, this function will set the shared memory bank size which is used for all subsequent kernel launches. Any per-function setting of shared memory set via ::cudaFuncSetSharedMemConfig will override the device wide setting. Changing the shared memory configuration between launches may introduce a device side synchronization point. Changing the shared memory bank size will not increase shared memory usage or affect occupancy of kernels, but may have major effects on performance. Larger bank sizes will allow for greater potential bandwidth to shared memory, but will change what kinds of accesses to shared memory will result in bank conflicts. This function will do nothing on devices with fixed shared memory bank size. The supported bank configurations are: - ::cudaSharedMemBankSizeDefault: set bank width the device default (currently, four bytes) - ::cudaSharedMemBankSizeFourByte: set shared memory bank width to be four bytes natively. - ::cudaSharedMemBankSizeEightByte: set shared memory bank width to be eight bytes natively.

Parameters:

config - - Requested cache configuration

Returns:

::cudaSuccess, ::cudaErrorInvalidValue \notefnerr \note_init_rt \note_callback

cudaDeviceGetByPCIBusId
```
@Cast("cudaError_t")
public static int cudaDeviceGetByPCIBusId(IntPointer device,
                                          @Cast("const char*")
                                          BytePointer pciBusId)
```
\brief Returns a handle to a compute device Returns in \p *device a device ordinal given a PCI bus ID string.

Parameters:

device - - Returned device ordinal

pciBusId - - String in one of the following forms: [domain]:[bus]:[device].[function] [domain]:[bus]:[device] [bus]:[device].[function] where \p domain, \p bus, \p device, and \p function are all hexadecimal values

Returns:

::cudaSuccess, ::cudaErrorInvalidValue, ::cudaErrorInvalidDevice \notefnerr \note_init_rt \note_callback

cudaDeviceGetByPCIBusId

@Cast("cudaError_t")
public static int cudaDeviceGetByPCIBusId(IntBuffer device,
                                          String pciBusId)

cudaDeviceGetByPCIBusId

@Cast("cudaError_t")
public static int cudaDeviceGetByPCIBusId(int[] device,
                                          @Cast("const char*")
                                          BytePointer pciBusId)

cudaDeviceGetByPCIBusId

@Cast("cudaError_t")
public static int cudaDeviceGetByPCIBusId(IntPointer device,
                                          String pciBusId)

cudaDeviceGetByPCIBusId

@Cast("cudaError_t")
public static int cudaDeviceGetByPCIBusId(IntBuffer device,
                                          @Cast("const char*")
                                          BytePointer pciBusId)

cudaDeviceGetByPCIBusId

@Cast("cudaError_t")
public static int cudaDeviceGetByPCIBusId(int[] device,
                                          String pciBusId)

cudaDeviceGetPCIBusId
```
@Cast("cudaError_t")
public static int cudaDeviceGetPCIBusId(@Cast("char*")
                                        BytePointer pciBusId,
                                        int len,
                                        int device)
```
\brief Returns a PCI Bus Id string for the device Returns an ASCII string identifying the device \p dev in the NULL-terminated string pointed to by \p pciBusId. \p len specifies the maximum length of the string that may be returned.

Parameters:

pciBusId - - Returned identifier string for the device in the following format [domain]:[bus]:[device].[function] where \p domain, \p bus, \p device, and \p function are all hexadecimal values. pciBusId should be large enough to store 13 characters including the NULL-terminator.

len - - Maximum length of string to store in \p name

device - - Device to get identifier string for

Returns:

::cudaSuccess, ::cudaErrorInvalidValue, ::cudaErrorInvalidDevice \notefnerr \note_init_rt \note_callback

cudaDeviceGetPCIBusId

@Cast("cudaError_t")
public static int cudaDeviceGetPCIBusId(@Cast("char*")
                                        ByteBuffer pciBusId,
                                        int len,
                                        int device)

cudaDeviceGetPCIBusId

@Cast("cudaError_t")
public static int cudaDeviceGetPCIBusId(@Cast("char*")
                                        byte[] pciBusId,
                                        int len,
                                        int device)

cudaIpcGetEventHandle
```
@Cast("cudaError_t")
public static int cudaIpcGetEventHandle(cudaIpcEventHandle_t handle,
                                        CUevent_st event)
```
\brief Gets an interprocess handle for a previously allocated event Takes as input a previously allocated event. This event must have been created with the ::cudaEventInterprocess and ::cudaEventDisableTiming flags set. This opaque handle may be copied into other processes and opened with ::cudaIpcOpenEventHandle to allow efficient hardware synchronization between GPU work in different processes. After the event has been been opened in the importing process, ::cudaEventRecord, ::cudaEventSynchronize, ::cudaStreamWaitEvent and ::cudaEventQuery may be used in either process. Performing operations on the imported event after the exported event has been freed with ::cudaEventDestroy will result in undefined behavior. IPC functionality is restricted to devices with support for unified addressing on Linux operating systems. IPC functionality is not supported on Tegra platforms.

Parameters:

handle - - Pointer to a user allocated cudaIpcEventHandle in which to return the opaque event handle

event - - Event allocated with ::cudaEventInterprocess and ::cudaEventDisableTiming flags.

Returns:

::cudaSuccess, ::cudaErrorInvalidResourceHandle, ::cudaErrorMemoryAllocation, ::cudaErrorMapBufferObjectFailed, ::cudaErrorNotSupported \note_init_rt \note_callback

cudaIpcOpenEventHandle
```
@Cast("cudaError_t")
public static int cudaIpcOpenEventHandle(@ByPtrPtr
                                         CUevent_st event,
                                         @ByVal
                                         cudaIpcEventHandle_t handle)
```
\brief Opens an interprocess event handle for use in the current process Opens an interprocess event handle exported from another process with ::cudaIpcGetEventHandle. This function returns a ::cudaEvent_t that behaves like a locally created event with the ::cudaEventDisableTiming flag specified. This event must be freed with ::cudaEventDestroy. Performing operations on the imported event after the exported event has been freed with ::cudaEventDestroy will result in undefined behavior. IPC functionality is restricted to devices with support for unified addressing on Linux operating systems. IPC functionality is not supported on Tegra platforms.

Parameters:

event - - Returns the imported event

handle - - Interprocess handle to open

Returns:

::cudaSuccess, ::cudaErrorMapBufferObjectFailed, ::cudaErrorInvalidResourceHandle, ::cudaErrorNotSupported \note_init_rt \note_callback

cudaIpcGetMemHandle
```
@Cast("cudaError_t")
public static int cudaIpcGetMemHandle(cudaIpcMemHandle_t handle,
                                      Pointer devPtr)
```
\brief Gets an interprocess memory handle for an existing device memory allocation Takes a pointer to the base of an existing device memory allocation created with ::cudaMalloc and exports it for use in another process. This is a lightweight operation and may be called multiple times on an allocation without adverse effects. If a region of memory is freed with ::cudaFree and a subsequent call to ::cudaMalloc returns memory with the same device address, ::cudaIpcGetMemHandle will return a unique handle for the new memory. IPC functionality is restricted to devices with support for unified addressing on Linux operating systems. IPC functionality is not supported on Tegra platforms.

Parameters:

handle - - Pointer to user allocated ::cudaIpcMemHandle to return the handle in.

devPtr - - Base pointer to previously allocated device memory

Returns:

::cudaSuccess, ::cudaErrorInvalidResourceHandle, ::cudaErrorMemoryAllocation, ::cudaErrorMapBufferObjectFailed, ::cudaErrorNotSupported \note_init_rt \note_callback

cudaIpcOpenMemHandle
```
@Cast("cudaError_t")
public static int cudaIpcOpenMemHandle(@Cast("void**")
                                       PointerPointer devPtr,
                                       @ByVal
                                       cudaIpcMemHandle_t handle,
                                       @Cast("unsigned int")
                                       int flags)
```
\brief Opens an interprocess memory handle exported from another process and returns a device pointer usable in the local process. Maps memory exported from another process with ::cudaIpcGetMemHandle into the current device address space. For contexts on different devices ::cudaIpcOpenMemHandle can attempt to enable peer access between the devices as if the user called ::cudaDeviceEnablePeerAccess. This behavior is controlled by the ::cudaIpcMemLazyEnablePeerAccess flag. ::cudaDeviceCanAccessPeer can determine if a mapping is possible. ::cudaIpcOpenMemHandle can open handles to devices that may not be visible in the process calling the API. Contexts that may open ::cudaIpcMemHandles are restricted in the following way. ::cudaIpcMemHandles from each device in a given process may only be opened by one context per device per other process. Memory returned from ::cudaIpcOpenMemHandle must be freed with ::cudaIpcCloseMemHandle. Calling ::cudaFree on an exported memory region before calling ::cudaIpcCloseMemHandle in the importing context will result in undefined behavior. IPC functionality is restricted to devices with support for unified addressing on Linux operating systems. IPC functionality is not supported on Tegra platforms.

Parameters:

devPtr - - Returned device pointer

handle - - ::cudaIpcMemHandle to open

flags - - Flags for this operation. Must be specified as ::cudaIpcMemLazyEnablePeerAccess

Returns:

::cudaSuccess, ::cudaErrorMapBufferObjectFailed, ::cudaErrorInvalidResourceHandle, ::cudaErrorTooManyPeers, ::cudaErrorNotSupported \note_init_rt \note_callback \note No guarantees are made about the address returned in \p *devPtr. In particular, multiple processes may not receive the same address for the same \p handle.

cudaIpcOpenMemHandle

@Cast("cudaError_t")
public static int cudaIpcOpenMemHandle(@Cast("void**") @ByPtrPtr
                                       Pointer devPtr,
                                       @ByVal
                                       cudaIpcMemHandle_t handle,
                                       @Cast("unsigned int")
                                       int flags)

cudaIpcCloseMemHandle
```
@Cast("cudaError_t")
public static int cudaIpcCloseMemHandle(Pointer devPtr)
```
\brief Close memory mapped with cudaIpcOpenMemHandle Unmaps memory returnd by ::cudaIpcOpenMemHandle. The original allocation in the exporting process as well as imported mappings in other processes will be unaffected. Any resources used to enable peer access will be freed if this is the last mapping using them. IPC functionality is restricted to devices with support for unified addressing on Linux operating systems. IPC functionality is not supported on Tegra platforms.

Parameters:

devPtr - - Device pointer returned by ::cudaIpcOpenMemHandle

Returns:

::cudaSuccess, ::cudaErrorMapBufferObjectFailed, ::cudaErrorInvalidResourceHandle, ::cudaErrorNotSupported \note_init_rt \note_callback

cudaThreadExit
```
@Cast("cudaError_t")
@Deprecated
public static int cudaThreadExit()
```
Deprecated.
Note that this function is deprecated because its name does not reflect its behavior. Its functionality is identical to the non-deprecated function ::cudaDeviceReset(), which should be used instead. Explicitly destroys all cleans up all resources associated with the current device in the current process. Any subsequent API call to this device will reinitialize the device. Note that this function will reset the device immediately. It is the caller's responsibility to ensure that the device is not being accessed by any other host threads from the process when this function is called.

\brief Exit and clean up from CUDA launches

Returns:

::cudaSuccess \notefnerr \note_init_rt \note_callback

cudaThreadSynchronize
```
@Cast("cudaError_t")
@Deprecated
public static int cudaThreadSynchronize()
```
Deprecated.
Note that this function is deprecated because its name does not reflect its behavior. Its functionality is similar to the non-deprecated function ::cudaDeviceSynchronize(), which should be used instead. Blocks until the device has completed all preceding requested tasks. ::cudaThreadSynchronize() returns an error if one of the preceding tasks has failed. If the ::cudaDeviceScheduleBlockingSync flag was set for this device, the host thread will block until the device has finished its work.

\brief Wait for compute device to finish

Returns:

::cudaSuccess \notefnerr \note_init_rt \note_callback

cudaThreadSetLimit
```
@Cast("cudaError_t")
@Deprecated
public static int cudaThreadSetLimit(@Cast("cudaLimit")
                                     int _limit,
                                     @Cast("size_t")
                                     long value)
```
Deprecated.
Note that this function is deprecated because its name does not reflect its behavior. Its functionality is identical to the non-deprecated function ::cudaDeviceSetLimit(), which should be used instead. Setting \p limit to \p value is a request by the application to update the current limit maintained by the device. The driver is free to modify the requested value to meet h/w requirements (this could be clamping to minimum or maximum values, rounding up to nearest element size, etc). The application can use ::cudaThreadGetLimit() to find out exactly what the limit has been set to. Setting each ::cudaLimit has its own specific restrictions, so each is discussed here. - ::cudaLimitStackSize controls the stack size of each GPU thread. - ::cudaLimitPrintfFifoSize controls the size of the shared FIFO used by the ::printf() device system call. Setting ::cudaLimitPrintfFifoSize must be performed before launching any kernel that uses the ::printf() device system call, otherwise ::cudaErrorInvalidValue will be returned. - ::cudaLimitMallocHeapSize controls the size of the heap used by the ::malloc() and ::free() device system calls. Setting ::cudaLimitMallocHeapSize must be performed before launching any kernel that uses the ::malloc() or ::free() device system calls, otherwise ::cudaErrorInvalidValue will be returned.

\brief Set resource limits

Parameters:

limit - - Limit to set

value - - Size in bytes of limit

Returns:

::cudaSuccess, ::cudaErrorUnsupportedLimit, ::cudaErrorInvalidValue \notefnerr \note_init_rt \note_callback

cudaThreadGetLimit
```
@Cast("cudaError_t")
@Deprecated
public static int cudaThreadGetLimit(@Cast("size_t*")
                                     SizeTPointer pValue,
                                     @Cast("cudaLimit")
                                     int _limit)
```
Deprecated.
Note that this function is deprecated because its name does not reflect its behavior. Its functionality is identical to the non-deprecated function ::cudaDeviceGetLimit(), which should be used instead. Returns in \p *pValue the current size of \p limit. The supported ::cudaLimit values are: - ::cudaLimitStackSize: stack size of each GPU thread; - ::cudaLimitPrintfFifoSize: size of the shared FIFO used by the ::printf() device system call. - ::cudaLimitMallocHeapSize: size of the heap used by the ::malloc() and ::free() device system calls;

\brief Returns resource limits

Parameters:

limit - - Limit to query

pValue - - Returned size in bytes of limit

Returns:

::cudaSuccess, ::cudaErrorUnsupportedLimit, ::cudaErrorInvalidValue \notefnerr \note_init_rt \note_callback

cudaThreadGetCacheConfig
```
@Cast("cudaError_t")
@Deprecated
public static int cudaThreadGetCacheConfig(@Cast("cudaFuncCache*")
                                           IntPointer pCacheConfig)
```
Deprecated.
Note that this function is deprecated because its name does not reflect its behavior. Its functionality is identical to the non-deprecated function ::cudaDeviceGetCacheConfig(), which should be used instead. On devices where the L1 cache and shared memory use the same hardware resources, this returns through \p pCacheConfig the preferred cache configuration for the current device. This is only a preference. The runtime will use the requested configuration if possible, but it is free to choose a different configuration if required to execute functions. This will return a \p pCacheConfig of ::cudaFuncCachePreferNone on devices where the size of the L1 cache and shared memory are fixed. The supported cache configurations are: - ::cudaFuncCachePreferNone: no preference for shared memory or L1 (default) - ::cudaFuncCachePreferShared: prefer larger shared memory and smaller L1 cache - ::cudaFuncCachePreferL1: prefer larger L1 cache and smaller shared memory

\brief Returns the preferred cache configuration for the current device.

Parameters:

pCacheConfig - - Returned cache configuration

Returns:

::cudaSuccess \notefnerr \note_init_rt \note_callback

cudaThreadGetCacheConfig

@Cast("cudaError_t")
@Deprecated
public static int cudaThreadGetCacheConfig(@Cast("cudaFuncCache*")
                                           IntBuffer pCacheConfig)

Deprecated.

cudaThreadGetCacheConfig

@Cast("cudaError_t")
@Deprecated
public static int cudaThreadGetCacheConfig(@Cast("cudaFuncCache*")
                                           int[] pCacheConfig)

Deprecated.

cudaThreadSetCacheConfig
```
@Cast("cudaError_t")
@Deprecated
public static int cudaThreadSetCacheConfig(@Cast("cudaFuncCache")
                                           int cacheConfig)
```
Deprecated.
Note that this function is deprecated because its name does not reflect its behavior. Its functionality is identical to the non-deprecated function ::cudaDeviceSetCacheConfig(), which should be used instead. On devices where the L1 cache and shared memory use the same hardware resources, this sets through \p cacheConfig the preferred cache configuration for the current device. This is only a preference. The runtime will use the requested configuration if possible, but it is free to choose a different configuration if required to execute the function. Any function preference set via \ref ::cudaFuncSetCacheConfig(const void*, enum cudaFuncCache) "cudaFuncSetCacheConfig (C API)" or \ref ::cudaFuncSetCacheConfig(T*, enum cudaFuncCache) "cudaFuncSetCacheConfig (C++ API)" will be preferred over this device-wide setting. Setting the device-wide cache configuration to ::cudaFuncCachePreferNone will cause subsequent kernel launches to prefer to not change the cache configuration unless required to launch the kernel. This setting does nothing on devices where the size of the L1 cache and shared memory are fixed. Launching a kernel with a different preference than the most recent preference setting may insert a device-side synchronization point. The supported cache configurations are: - ::cudaFuncCachePreferNone: no preference for shared memory or L1 (default) - ::cudaFuncCachePreferShared: prefer larger shared memory and smaller L1 cache - ::cudaFuncCachePreferL1: prefer larger L1 cache and smaller shared memory

\brief Sets the preferred cache configuration for the current device.

Parameters:

cacheConfig - - Requested cache configuration

Returns:

::cudaSuccess \notefnerr \note_init_rt \note_callback

cudaGetLastError
```
@Cast("cudaError_t")
public static int cudaGetLastError()
```
\brief Returns the last error from a runtime call Returns the last error that has been produced by any of the runtime calls in the same host thread and resets it to ::cudaSuccess.

Returns:

::cudaSuccess, ::cudaErrorMissingConfiguration, ::cudaErrorMemoryAllocation, ::cudaErrorInitializationError, ::cudaErrorLaunchFailure, ::cudaErrorLaunchTimeout, ::cudaErrorLaunchOutOfResources, ::cudaErrorInvalidDeviceFunction, ::cudaErrorInvalidConfiguration, ::cudaErrorInvalidDevice, ::cudaErrorInvalidValue, ::cudaErrorInvalidPitchValue, ::cudaErrorInvalidSymbol, ::cudaErrorUnmapBufferObjectFailed, ::cudaErrorInvalidDevicePointer, ::cudaErrorInvalidTexture, ::cudaErrorInvalidTextureBinding, ::cudaErrorInvalidChannelDescriptor, ::cudaErrorInvalidMemcpyDirection, ::cudaErrorInvalidFilterSetting, ::cudaErrorInvalidNormSetting, ::cudaErrorUnknown, ::cudaErrorInvalidResourceHandle, ::cudaErrorInsufficientDriver, ::cudaErrorNoDevice, ::cudaErrorSetOnActiveProcess, ::cudaErrorStartupFailure, ::cudaErrorInvalidPtx, ::cudaErrorNoKernelImageForDevice, ::cudaErrorJitCompilerNotFound \notefnerr \note_init_rt \note_callback

cudaPeekAtLastError
```
@Cast("cudaError_t")
public static int cudaPeekAtLastError()
```
\brief Returns the last error from a runtime call Returns the last error that has been produced by any of the runtime calls in the same host thread. Note that this call does not reset the error to ::cudaSuccess like ::cudaGetLastError().

Returns:

::cudaSuccess, ::cudaErrorMissingConfiguration, ::cudaErrorMemoryAllocation, ::cudaErrorInitializationError, ::cudaErrorLaunchFailure, ::cudaErrorLaunchTimeout, ::cudaErrorLaunchOutOfResources, ::cudaErrorInvalidDeviceFunction, ::cudaErrorInvalidConfiguration, ::cudaErrorInvalidDevice, ::cudaErrorInvalidValue, ::cudaErrorInvalidPitchValue, ::cudaErrorInvalidSymbol, ::cudaErrorUnmapBufferObjectFailed, ::cudaErrorInvalidDevicePointer, ::cudaErrorInvalidTexture, ::cudaErrorInvalidTextureBinding, ::cudaErrorInvalidChannelDescriptor, ::cudaErrorInvalidMemcpyDirection, ::cudaErrorInvalidFilterSetting, ::cudaErrorInvalidNormSetting, ::cudaErrorUnknown, ::cudaErrorInvalidResourceHandle, ::cudaErrorInsufficientDriver, ::cudaErrorNoDevice, ::cudaErrorSetOnActiveProcess, ::cudaErrorStartupFailure, ::cudaErrorInvalidPtx, ::cudaErrorNoKernelImageForDevice, ::cudaErrorJitCompilerNotFound \notefnerr \note_init_rt \note_callback

cudaGetErrorName
```
@Cast("const char*")
public static BytePointer cudaGetErrorName(@Cast("cudaError_t")
                                           int error)
```
\brief Returns the string representation of an error code enum name Returns a string containing the name of an error code in the enum. If the error code is not recognized, "unrecognized error code" is returned.

Parameters:

error - - Error code to convert to string

Returns:

\p char* pointer to a NULL-terminated string

cudaGetErrorString
```
@Cast("const char*")
public static BytePointer cudaGetErrorString(@Cast("cudaError_t")
                                             int error)
```
\brief Returns the description string for an error code Returns the description string for an error code. If the error code is not recognized, "unrecognized error code" is returned.

Parameters:

error - - Error code to convert to string

Returns:

\p char* pointer to a NULL-terminated string

cudaGetDeviceCount
```
@Cast("cudaError_t")
public static int cudaGetDeviceCount(IntPointer count)
```
\brief Returns the number of compute-capable devices Returns in \p *count the number of devices with compute capability greater or equal to 2.0 that are available for execution.

Parameters:

count - - Returns the number of devices with compute capability greater or equal to 2.0

Returns:

::cudaErrorInvalidValue (if a NULL device pointer is assigned), ::cudaSuccess
\notefnerr \note_init_rt \note_callback

cudaGetDeviceCount

@Cast("cudaError_t")
public static int cudaGetDeviceCount(IntBuffer count)

cudaGetDeviceCount

@Cast("cudaError_t")
public static int cudaGetDeviceCount(int[] count)

cudaGetDeviceProperties
```
@Cast("cudaError_t")
public static int cudaGetDeviceProperties(cudaDeviceProp prop,
                                          int device)
```
\brief Returns information about the compute-device Returns in \p *prop the properties of device \p dev. The ::cudaDeviceProp structure is defined as:
```
    struct cudaDeviceProp {
        char name[256];
        cudaUUID_t uuid;
        size_t totalGlobalMem;
        size_t sharedMemPerBlock;
        int regsPerBlock;
        int warpSize;
        size_t memPitch;
        int maxThreadsPerBlock;
        int maxThreadsDim[3];
        int maxGridSize[3];
        int clockRate;
        size_t totalConstMem;
        int major;
        int minor;
        size_t textureAlignment;
        size_t texturePitchAlignment;
        int deviceOverlap;
        int multiProcessorCount;
        int kernelExecTimeoutEnabled;
        int integrated;
        int canMapHostMemory;
        int computeMode;
        int maxTexture1D;
        int maxTexture1DMipmap;
        int maxTexture1DLinear;
        int maxTexture2D[2];
        int maxTexture2DMipmap[2];
        int maxTexture2DLinear[3];
        int maxTexture2DGather[2];
        int maxTexture3D[3];
        int maxTexture3DAlt[3];
        int maxTextureCubemap;
        int maxTexture1DLayered[2];
        int maxTexture2DLayered[3];
        int maxTextureCubemapLayered[2];
        int maxSurface1D;
        int maxSurface2D[2];
        int maxSurface3D[3];
        int maxSurface1DLayered[2];
        int maxSurface2DLayered[3];
        int maxSurfaceCubemap;
        int maxSurfaceCubemapLayered[2];
        size_t surfaceAlignment;
        int concurrentKernels;
        int ECCEnabled;
        int pciBusID;
        int pciDeviceID;
        int pciDomainID;
        int tccDriver;
        int asyncEngineCount;
        int unifiedAddressing;
        int memoryClockRate;
        int memoryBusWidth;
        int l2CacheSize;
        int maxThreadsPerMultiProcessor;
        int streamPrioritiesSupported;
        int globalL1CacheSupported;
        int localL1CacheSupported;
        size_t sharedMemPerMultiprocessor;
        int regsPerMultiprocessor;
        int managedMemory;
        int isMultiGpuBoard;
        int multiGpuBoardGroupID;
        int singleToDoublePrecisionPerfRatio;
        int pageableMemoryAccess;
        int concurrentManagedAccess;
        int computePreemptionSupported;
        int canUseHostPointerForRegisteredMem;
        int cooperativeLaunch;
        int cooperativeMultiDeviceLaunch;
        int pageableMemoryAccessUsesHostPageTables;
        int directManagedMemAccessFromHost;
    }
 
```
where: - \ref ::cudaDeviceProp::name "name[256]" is an ASCII string identifying the device; - \ref ::cudaDeviceProp::uuid "uuid" is a 16-byte unique identifier. - \ref ::cudaDeviceProp::totalGlobalMem "totalGlobalMem" is the total amount of global memory available on the device in bytes; - \ref ::cudaDeviceProp::sharedMemPerBlock "sharedMemPerBlock" is the maximum amount of shared memory available to a thread block in bytes; - \ref ::cudaDeviceProp::regsPerBlock "regsPerBlock" is the maximum number of 32-bit registers available to a thread block; - \ref ::cudaDeviceProp::warpSize "warpSize" is the warp size in threads; - \ref ::cudaDeviceProp::memPitch "memPitch" is the maximum pitch in bytes allowed by the memory copy functions that involve memory regions allocated through ::cudaMallocPitch(); - \ref ::cudaDeviceProp::maxThreadsPerBlock "maxThreadsPerBlock" is the maximum number of threads per block; - \ref ::cudaDeviceProp::maxThreadsDim "maxThreadsDim[3]" contains the maximum size of each dimension of a block; - \ref ::cudaDeviceProp::maxGridSize "maxGridSize[3]" contains the maximum size of each dimension of a grid; - \ref ::cudaDeviceProp::clockRate "clockRate" is the clock frequency in kilohertz; - \ref ::cudaDeviceProp::totalConstMem "totalConstMem" is the total amount of constant memory available on the device in bytes; - \ref ::cudaDeviceProp::major "major", \ref ::cudaDeviceProp::minor "minor" are the major and minor revision numbers defining the device's compute capability; - \ref ::cudaDeviceProp::textureAlignment "textureAlignment" is the alignment requirement; texture base addresses that are aligned to \ref ::cudaDeviceProp::textureAlignment "textureAlignment" bytes do not need an offset applied to texture fetches; - \ref ::cudaDeviceProp::texturePitchAlignment "texturePitchAlignment" is the pitch alignment requirement for 2D texture references that are bound to pitched memory; - \ref ::cudaDeviceProp::deviceOverlap "deviceOverlap" is 1 if the device can concurrently copy memory between host and device while executing a kernel, or 0 if not. Deprecated, use instead asyncEngineCount. - \ref ::cudaDeviceProp::multiProcessorCount "multiProcessorCount" is the number of multiprocessors on the device; - \ref ::cudaDeviceProp::kernelExecTimeoutEnabled "kernelExecTimeoutEnabled" is 1 if there is a run time limit for kernels executed on the device, or 0 if not. - \ref ::cudaDeviceProp::integrated "integrated" is 1 if the device is an integrated (motherboard) GPU and 0 if it is a discrete (card) component. - \ref ::cudaDeviceProp::canMapHostMemory "canMapHostMemory" is 1 if the device can map host memory into the CUDA address space for use with ::cudaHostAlloc()/::cudaHostGetDevicePointer(), or 0 if not; - \ref ::cudaDeviceProp::computeMode "computeMode" is the compute mode that the device is currently in. Available modes are as follows: - cudaComputeModeDefault: Default mode - Device is not restricted and multiple threads can use ::cudaSetDevice() with this device. - cudaComputeModeExclusive: Compute-exclusive mode - Only one thread will be able to use ::cudaSetDevice() with this device. - cudaComputeModeProhibited: Compute-prohibited mode - No threads can use ::cudaSetDevice() with this device. - cudaComputeModeExclusiveProcess: Compute-exclusive-process mode - Many threads in one process will be able to use ::cudaSetDevice() with this device.
If ::cudaSetDevice() is called on an already occupied \p device with computeMode ::cudaComputeModeExclusive, ::cudaErrorDeviceAlreadyInUse will be immediately returned indicating the device cannot be used. When an occupied exclusive mode device is chosen with ::cudaSetDevice, all subsequent non-device management runtime functions will return ::cudaErrorDevicesUnavailable. - \ref ::cudaDeviceProp::maxTexture1D "maxTexture1D" is the maximum 1D texture size. - \ref ::cudaDeviceProp::maxTexture1DMipmap "maxTexture1DMipmap" is the maximum 1D mipmapped texture texture size. - \ref ::cudaDeviceProp::maxTexture1DLinear "maxTexture1DLinear" is the maximum 1D texture size for textures bound to linear memory. - \ref ::cudaDeviceProp::maxTexture2D "maxTexture2D[2]" contains the maximum 2D texture dimensions. - \ref ::cudaDeviceProp::maxTexture2DMipmap "maxTexture2DMipmap[2]" contains the maximum 2D mipmapped texture dimensions. - \ref ::cudaDeviceProp::maxTexture2DLinear "maxTexture2DLinear[3]" contains the maximum 2D texture dimensions for 2D textures bound to pitch linear memory. - \ref ::cudaDeviceProp::maxTexture2DGather "maxTexture2DGather[2]" contains the maximum 2D texture dimensions if texture gather operations have to be performed. - \ref ::cudaDeviceProp::maxTexture3D "maxTexture3D[3]" contains the maximum 3D texture dimensions. - \ref ::cudaDeviceProp::maxTexture3DAlt "maxTexture3DAlt[3]" contains the maximum alternate 3D texture dimensions. - \ref ::cudaDeviceProp::maxTextureCubemap "maxTextureCubemap" is the maximum cubemap texture width or height. - \ref ::cudaDeviceProp::maxTexture1DLayered "maxTexture1DLayered[2]" contains the maximum 1D layered texture dimensions. - \ref ::cudaDeviceProp::maxTexture2DLayered "maxTexture2DLayered[3]" contains the maximum 2D layered texture dimensions. - \ref ::cudaDeviceProp::maxTextureCubemapLayered "maxTextureCubemapLayered[2]" contains the maximum cubemap layered texture dimensions. - \ref ::cudaDeviceProp::maxSurface1D "maxSurface1D" is the maximum 1D surface size. - \ref ::cudaDeviceProp::maxSurface2D "maxSurface2D[2]" contains the maximum 2D surface dimensions. - \ref ::cudaDeviceProp::maxSurface3D "maxSurface3D[3]" contains the maximum 3D surface dimensions. - \ref ::cudaDeviceProp::maxSurface1DLayered "maxSurface1DLayered[2]" contains the maximum 1D layered surface dimensions. - \ref ::cudaDeviceProp::maxSurface2DLayered "maxSurface2DLayered[3]" contains the maximum 2D layered surface dimensions. - \ref ::cudaDeviceProp::maxSurfaceCubemap "maxSurfaceCubemap" is the maximum cubemap surface width or height. - \ref ::cudaDeviceProp::maxSurfaceCubemapLayered "maxSurfaceCubemapLayered[2]" contains the maximum cubemap layered surface dimensions. - \ref ::cudaDeviceProp::surfaceAlignment "surfaceAlignment" specifies the alignment requirements for surfaces. - \ref ::cudaDeviceProp::concurrentKernels "concurrentKernels" is 1 if the device supports executing multiple kernels within the same context simultaneously, or 0 if not. It is not guaranteed that multiple kernels will be resident on the device concurrently so this feature should not be relied upon for correctness; - \ref ::cudaDeviceProp::ECCEnabled "ECCEnabled" is 1 if the device has ECC support turned on, or 0 if not. - \ref ::cudaDeviceProp::pciBusID "pciBusID" is the PCI bus identifier of the device. - \ref ::cudaDeviceProp::pciDeviceID "pciDeviceID" is the PCI device (sometimes called slot) identifier of the device. - \ref ::cudaDeviceProp::pciDomainID "pciDomainID" is the PCI domain identifier of the device. - \ref ::cudaDeviceProp::tccDriver "tccDriver" is 1 if the device is using a TCC driver or 0 if not. - \ref ::cudaDeviceProp::asyncEngineCount "asyncEngineCount" is 1 when the device can concurrently copy memory between host and device while executing a kernel. It is 2 when the device can concurrently copy memory between host and device in both directions and execute a kernel at the same time. It is 0 if neither of these is supported. - \ref ::cudaDeviceProp::unifiedAddressing "unifiedAddressing" is 1 if the device shares a unified address space with the host and 0 otherwise. - \ref ::cudaDeviceProp::memoryClockRate "memoryClockRate" is the peak memory clock frequency in kilohertz. - \ref ::cudaDeviceProp::memoryBusWidth "memoryBusWidth" is the memory bus width in bits. - \ref ::cudaDeviceProp::l2CacheSize "l2CacheSize" is L2 cache size in bytes. - \ref ::cudaDeviceProp::maxThreadsPerMultiProcessor "maxThreadsPerMultiProcessor" is the number of maximum resident threads per multiprocessor. - \ref ::cudaDeviceProp::streamPrioritiesSupported "streamPrioritiesSupported" is 1 if the device supports stream priorities, or 0 if it is not supported. - \ref ::cudaDeviceProp::globalL1CacheSupported "globalL1CacheSupported" is 1 if the device supports caching of globals in L1 cache, or 0 if it is not supported. - \ref ::cudaDeviceProp::localL1CacheSupported "localL1CacheSupported" is 1 if the device supports caching of locals in L1 cache, or 0 if it is not supported. - \ref ::cudaDeviceProp::sharedMemPerMultiprocessor "sharedMemPerMultiprocessor" is the maximum amount of shared memory available to a multiprocessor in bytes; this amount is shared by all thread blocks simultaneously resident on a multiprocessor; - \ref ::cudaDeviceProp::regsPerMultiprocessor "regsPerMultiprocessor" is the maximum number of 32-bit registers available to a multiprocessor; this number is shared by all thread blocks simultaneously resident on a multiprocessor; - \ref ::cudaDeviceProp::managedMemory "managedMemory" is 1 if the device supports allocating managed memory on this system, or 0 if it is not supported. - \ref ::cudaDeviceProp::isMultiGpuBoard "isMultiGpuBoard" is 1 if the device is on a multi-GPU board (e.g. Gemini cards), and 0 if not; - \ref ::cudaDeviceProp::multiGpuBoardGroupID "multiGpuBoardGroupID" is a unique identifier for a group of devices associated with the same board. Devices on the same multi-GPU board will share the same identifier; - \ref ::cudaDeviceProp::singleToDoublePrecisionPerfRatio "singleToDoublePrecisionPerfRatio" is the ratio of single precision performance (in floating-point operations per second) to double precision performance. - \ref ::cudaDeviceProp::pageableMemoryAccess "pageableMemoryAccess" is 1 if the device supports coherently accessing pageable memory without calling cudaHostRegister on it, and 0 otherwise. - \ref ::cudaDeviceProp::concurrentManagedAccess "concurrentManagedAccess" is 1 if the device can coherently access managed memory concurrently with the CPU, and 0 otherwise. - \ref ::cudaDeviceProp::computePreemptionSupported "computePreemptionSupported" is 1 if the device supports Compute Preemption, and 0 otherwise. - \ref ::cudaDeviceProp::canUseHostPointerForRegisteredMem "canUseHostPointerForRegisteredMem" is 1 if the device can access host registered memory at the same virtual address as the CPU, and 0 otherwise. - \ref ::cudaDeviceProp::cooperativeLaunch "cooperativeLaunch" is 1 if the device supports launching cooperative kernels via ::cudaLaunchCooperativeKernel, and 0 otherwise. - \ref ::cudaDeviceProp::cooperativeMultiDeviceLaunch "cooperativeMultiDeviceLaunch" is 1 if the device supports launching cooperative kernels via ::cudaLaunchCooperativeKernelMultiDevice, and 0 otherwise. - \ref ::cudaDeviceProp::pageableMemoryAccessUsesHostPageTables "pageableMemoryAccessUsesHostPageTables" is 1 if the device accesses pageable memory via the host's page tables, and 0 otherwise. - \ref ::cudaDeviceProp::directManagedMemAccessFromHost "directManagedMemAccessFromHost" is 1 if the host can directly access managed memory on the device without migration, and 0 otherwise.
Parameters:

prop - - Properties for the specified device

device - - Device number to get properties for

Returns:

::cudaSuccess, ::cudaErrorInvalidDevice \notefnerr \note_init_rt \note_callback

cudaDeviceGetAttribute
```
@Cast("cudaError_t")
public static int cudaDeviceGetAttribute(IntPointer value,
                                         @Cast("cudaDeviceAttr")
                                         int attr,
                                         int device)
```
\brief Returns information about the device Returns in \p *value the integer value of the attribute \p attr on device \p device. The supported attributes are: - ::cudaDevAttrMaxThreadsPerBlock: Maximum number of threads per block; - ::cudaDevAttrMaxBlockDimX: Maximum x-dimension of a block; - ::cudaDevAttrMaxBlockDimY: Maximum y-dimension of a block; - ::cudaDevAttrMaxBlockDimZ: Maximum z-dimension of a block; - ::cudaDevAttrMaxGridDimX: Maximum x-dimension of a grid; - ::cudaDevAttrMaxGridDimY: Maximum y-dimension of a grid; - ::cudaDevAttrMaxGridDimZ: Maximum z-dimension of a grid; - ::cudaDevAttrMaxSharedMemoryPerBlock: Maximum amount of shared memory available to a thread block in bytes; - ::cudaDevAttrTotalConstantMemory: Memory available on device for __constant__ variables in a CUDA C kernel in bytes; - ::cudaDevAttrWarpSize: Warp size in threads; - ::cudaDevAttrMaxPitch: Maximum pitch in bytes allowed by the memory copy functions that involve memory regions allocated through ::cudaMallocPitch(); - ::cudaDevAttrMaxTexture1DWidth: Maximum 1D texture width; - ::cudaDevAttrMaxTexture1DLinearWidth: Maximum width for a 1D texture bound to linear memory; - ::cudaDevAttrMaxTexture1DMipmappedWidth: Maximum mipmapped 1D texture width; - ::cudaDevAttrMaxTexture2DWidth: Maximum 2D texture width; - ::cudaDevAttrMaxTexture2DHeight: Maximum 2D texture height; - ::cudaDevAttrMaxTexture2DLinearWidth: Maximum width for a 2D texture bound to linear memory; - ::cudaDevAttrMaxTexture2DLinearHeight: Maximum height for a 2D texture bound to linear memory; - ::cudaDevAttrMaxTexture2DLinearPitch: Maximum pitch in bytes for a 2D texture bound to linear memory; - ::cudaDevAttrMaxTexture2DMipmappedWidth: Maximum mipmapped 2D texture width; - ::cudaDevAttrMaxTexture2DMipmappedHeight: Maximum mipmapped 2D texture height; - ::cudaDevAttrMaxTexture3DWidth: Maximum 3D texture width; - ::cudaDevAttrMaxTexture3DHeight: Maximum 3D texture height; - ::cudaDevAttrMaxTexture3DDepth: Maximum 3D texture depth; - ::cudaDevAttrMaxTexture3DWidthAlt: Alternate maximum 3D texture width, 0 if no alternate maximum 3D texture size is supported; - ::cudaDevAttrMaxTexture3DHeightAlt: Alternate maximum 3D texture height, 0 if no alternate maximum 3D texture size is supported; - ::cudaDevAttrMaxTexture3DDepthAlt: Alternate maximum 3D texture depth, 0 if no alternate maximum 3D texture size is supported; - ::cudaDevAttrMaxTextureCubemapWidth: Maximum cubemap texture width or height; - ::cudaDevAttrMaxTexture1DLayeredWidth: Maximum 1D layered texture width; - ::cudaDevAttrMaxTexture1DLayeredLayers: Maximum layers in a 1D layered texture; - ::cudaDevAttrMaxTexture2DLayeredWidth: Maximum 2D layered texture width; - ::cudaDevAttrMaxTexture2DLayeredHeight: Maximum 2D layered texture height; - ::cudaDevAttrMaxTexture2DLayeredLayers: Maximum layers in a 2D layered texture; - ::cudaDevAttrMaxTextureCubemapLayeredWidth: Maximum cubemap layered texture width or height; - ::cudaDevAttrMaxTextureCubemapLayeredLayers: Maximum layers in a cubemap layered texture; - ::cudaDevAttrMaxSurface1DWidth: Maximum 1D surface width; - ::cudaDevAttrMaxSurface2DWidth: Maximum 2D surface width; - ::cudaDevAttrMaxSurface2DHeight: Maximum 2D surface height; - ::cudaDevAttrMaxSurface3DWidth: Maximum 3D surface width; - ::cudaDevAttrMaxSurface3DHeight: Maximum 3D surface height; - ::cudaDevAttrMaxSurface3DDepth: Maximum 3D surface depth; - ::cudaDevAttrMaxSurface1DLayeredWidth: Maximum 1D layered surface width; - ::cudaDevAttrMaxSurface1DLayeredLayers: Maximum layers in a 1D layered surface; - ::cudaDevAttrMaxSurface2DLayeredWidth: Maximum 2D layered surface width; - ::cudaDevAttrMaxSurface2DLayeredHeight: Maximum 2D layered surface height; - ::cudaDevAttrMaxSurface2DLayeredLayers: Maximum layers in a 2D layered surface; - ::cudaDevAttrMaxSurfaceCubemapWidth: Maximum cubemap surface width; - ::cudaDevAttrMaxSurfaceCubemapLayeredWidth: Maximum cubemap layered surface width; - ::cudaDevAttrMaxSurfaceCubemapLayeredLayers: Maximum layers in a cubemap layered surface; - ::cudaDevAttrMaxRegistersPerBlock: Maximum number of 32-bit registers available to a thread block; - ::cudaDevAttrClockRate: Peak clock frequency in kilohertz; - ::cudaDevAttrTextureAlignment: Alignment requirement; texture base addresses aligned to ::textureAlign bytes do not need an offset applied to texture fetches; - ::cudaDevAttrTexturePitchAlignment: Pitch alignment requirement for 2D texture references bound to pitched memory; - ::cudaDevAttrGpuOverlap: 1 if the device can concurrently copy memory between host and device while executing a kernel, or 0 if not; - ::cudaDevAttrMultiProcessorCount: Number of multiprocessors on the device; - ::cudaDevAttrKernelExecTimeout: 1 if there is a run time limit for kernels executed on the device, or 0 if not; - ::cudaDevAttrIntegrated: 1 if the device is integrated with the memory subsystem, or 0 if not; - ::cudaDevAttrCanMapHostMemory: 1 if the device can map host memory into the CUDA address space, or 0 if not; - ::cudaDevAttrComputeMode: Compute mode is the compute mode that the device is currently in. Available modes are as follows: - ::cudaComputeModeDefault: Default mode - Device is not restricted and multiple threads can use ::cudaSetDevice() with this device. - ::cudaComputeModeExclusive: Compute-exclusive mode - Only one thread will be able to use ::cudaSetDevice() with this device. - ::cudaComputeModeProhibited: Compute-prohibited mode - No threads can use ::cudaSetDevice() with this device. - ::cudaComputeModeExclusiveProcess: Compute-exclusive-process mode - Many threads in one process will be able to use ::cudaSetDevice() with this device. - ::cudaDevAttrConcurrentKernels: 1 if the device supports executing multiple kernels within the same context simultaneously, or 0 if not. It is not guaranteed that multiple kernels will be resident on the device concurrently so this feature should not be relied upon for correctness; - ::cudaDevAttrEccEnabled: 1 if error correction is enabled on the device, 0 if error correction is disabled or not supported by the device; - ::cudaDevAttrPciBusId: PCI bus identifier of the device; - ::cudaDevAttrPciDeviceId: PCI device (also known as slot) identifier of the device; - ::cudaDevAttrTccDriver: 1 if the device is using a TCC driver. TCC is only available on Tesla hardware running Windows Vista or later; - ::cudaDevAttrMemoryClockRate: Peak memory clock frequency in kilohertz; - ::cudaDevAttrGlobalMemoryBusWidth: Global memory bus width in bits; - ::cudaDevAttrL2CacheSize: Size of L2 cache in bytes. 0 if the device doesn't have L2 cache; - ::cudaDevAttrMaxThreadsPerMultiProcessor: Maximum resident threads per multiprocessor; - ::cudaDevAttrUnifiedAddressing: 1 if the device shares a unified address space with the host, or 0 if not; - ::cudaDevAttrComputeCapabilityMajor: Major compute capability version number; - ::cudaDevAttrComputeCapabilityMinor: Minor compute capability version number; - ::cudaDevAttrStreamPrioritiesSupported: 1 if the device supports stream priorities, or 0 if not; - ::cudaDevAttrGlobalL1CacheSupported: 1 if device supports caching globals in L1 cache, 0 if not; - ::cudaDevAttrLocalL1CacheSupported: 1 if device supports caching locals in L1 cache, 0 if not; - ::cudaDevAttrMaxSharedMemoryPerMultiprocessor: Maximum amount of shared memory available to a multiprocessor in bytes; this amount is shared by all thread blocks simultaneously resident on a multiprocessor; - ::cudaDevAttrMaxRegistersPerMultiprocessor: Maximum number of 32-bit registers available to a multiprocessor; this number is shared by all thread blocks simultaneously resident on a multiprocessor; - ::cudaDevAttrManagedMemory: 1 if device supports allocating managed memory, 0 if not; - ::cudaDevAttrIsMultiGpuBoard: 1 if device is on a multi-GPU board, 0 if not; - ::cudaDevAttrMultiGpuBoardGroupID: Unique identifier for a group of devices on the same multi-GPU board; - ::cudaDevAttrHostNativeAtomicSupported: 1 if the link between the device and the host supports native atomic operations; - ::cudaDevAttrSingleToDoublePrecisionPerfRatio: Ratio of single precision performance (in floating-point operations per second) to double precision performance; - ::cudaDevAttrPageableMemoryAccess: 1 if the device supports coherently accessing pageable memory without calling cudaHostRegister on it, and 0 otherwise. - ::cudaDevAttrConcurrentManagedAccess: 1 if the device can coherently access managed memory concurrently with the CPU, and 0 otherwise. - ::cudaDevAttrComputePreemptionSupported: 1 if the device supports Compute Preemption, 0 if not. - ::cudaDevAttrCanUseHostPointerForRegisteredMem: 1 if the device can access host registered memory at the same virtual address as the CPU, and 0 otherwise. - ::cudaDevAttrCooperativeLaunch: 1 if the device supports launching cooperative kernels via ::cudaLaunchCooperativeKernel, and 0 otherwise. - ::cudaDevAttrCooperativeMultiDeviceLaunch: 1 if the device supports launching cooperative kernels via ::cudaLaunchCooperativeKernelMultiDevice, and 0 otherwise. - ::cudaDevAttrCanFlushRemoteWrites: 1 if the device supports flushing of outstanding remote writes, and 0 otherwise. - ::cudaDevAttrHostRegisterSupported: 1 if the device supports host memory registration via ::cudaHostRegister, and 0 otherwise. - ::cudaDevAttrPageableMemoryAccessUsesHostPageTables: 1 if the device accesses pageable memory via the host's page tables, and 0 otherwise. - ::cudaDevAttrDirectManagedMemAccessFromHost: 1 if the host can directly access managed memory on the device without migration, and 0 otherwise. - ::cudaDevAttrMaxSharedMemoryPerBlockOptin: Maximum per block shared memory size on the device. This value can be opted into when using ::cudaFuncSetAttribute

Parameters:

value - - Returned device attribute value

attr - - Device attribute to query

device - - Device number to query

Returns:

::cudaSuccess, ::cudaErrorInvalidDevice, ::cudaErrorInvalidValue \notefnerr \note_init_rt \note_callback

cudaDeviceGetAttribute

@Cast("cudaError_t")
public static int cudaDeviceGetAttribute(IntBuffer value,
                                         @Cast("cudaDeviceAttr")
                                         int attr,
                                         int device)

cudaDeviceGetAttribute

@Cast("cudaError_t")
public static int cudaDeviceGetAttribute(int[] value,
                                         @Cast("cudaDeviceAttr")
                                         int attr,
                                         int device)

cudaDeviceGetP2PAttribute
```
@Cast("cudaError_t")
public static int cudaDeviceGetP2PAttribute(IntPointer value,
                                            @Cast("cudaDeviceP2PAttr")
                                            int attr,
                                            int srcDevice,
                                            int dstDevice)
```
\brief Queries attributes of the link between two devices. Returns in \p *value the value of the requested attribute \p attrib of the link between \p srcDevice and \p dstDevice. The supported attributes are: - ::cudaDevP2PAttrPerformanceRank: A relative value indicating the performance of the link between two devices. Lower value means better performance (0 being the value used for most performant link). - ::cudaDevP2PAttrAccessSupported: 1 if peer access is enabled. - ::cudaDevP2PAttrNativeAtomicSupported: 1 if native atomic operations over the link are supported. - ::cudaDevP2PAttrCudaArrayAccessSupported: 1 if accessing CUDA arrays over the link is supported. Returns ::cudaErrorInvalidDevice if \p srcDevice or \p dstDevice are not valid or if they represent the same device. Returns ::cudaErrorInvalidValue if \p attrib is not valid or if \p value is a null pointer.

Parameters:

value - - Returned value of the requested attribute

attrib - - The requested attribute of the link between \p srcDevice and \p dstDevice.

srcDevice - - The source device of the target link.

dstDevice - - The destination device of the target link.

Returns:

::cudaSuccess, ::cudaErrorInvalidDevice, ::cudaErrorInvalidValue \notefnerr \note_init_rt \note_callback

cudaDeviceGetP2PAttribute

@Cast("cudaError_t")
public static int cudaDeviceGetP2PAttribute(IntBuffer value,
                                            @Cast("cudaDeviceP2PAttr")
                                            int attr,
                                            int srcDevice,
                                            int dstDevice)

cudaDeviceGetP2PAttribute

@Cast("cudaError_t")
public static int cudaDeviceGetP2PAttribute(int[] value,
                                            @Cast("cudaDeviceP2PAttr")
                                            int attr,
                                            int srcDevice,
                                            int dstDevice)

cudaChooseDevice
```
@Cast("cudaError_t")
public static int cudaChooseDevice(IntPointer device,
                                   @Const
                                   cudaDeviceProp prop)
```
\brief Select compute-device which best matches criteria Returns in \p *device the device which has properties that best match \p *prop.

Parameters:

device - - Device with best match

prop - - Desired device properties

Returns:

::cudaSuccess, ::cudaErrorInvalidValue \notefnerr \note_init_rt \note_callback

cudaChooseDevice

@Cast("cudaError_t")
public static int cudaChooseDevice(IntBuffer device,
                                   @Const
                                   cudaDeviceProp prop)

cudaChooseDevice

@Cast("cudaError_t")
public static int cudaChooseDevice(int[] device,
                                   @Const
                                   cudaDeviceProp prop)

cudaSetDevice
```
@Cast("cudaError_t")
public static int cudaSetDevice(int device)
```
\brief Set device to be used for GPU executions Sets \p device as the current device for the calling host thread. Valid device id's are 0 to (::cudaGetDeviceCount() - 1). Any device memory subsequently allocated from this host thread using ::cudaMalloc(), ::cudaMallocPitch() or ::cudaMallocArray() will be physically resident on \p device. Any host memory allocated from this host thread using ::cudaMallocHost() or ::cudaHostAlloc() or ::cudaHostRegister() will have its lifetime associated with \p device. Any streams or events created from this host thread will be associated with \p device. Any kernels launched from this host thread using the <<<>>> operator or ::cudaLaunchKernel() will be executed on \p device. This call may be made from any host thread, to any device, and at any time. This function will do no synchronization with the previous or new device, and should be considered a very low overhead call.

Parameters:

device - - Device on which the active host thread should execute the device code.

Returns:

::cudaSuccess, ::cudaErrorInvalidDevice, ::cudaErrorDeviceAlreadyInUse \notefnerr \note_init_rt \note_callback

cudaGetDevice
```
@Cast("cudaError_t")
public static int cudaGetDevice(IntPointer device)
```
\brief Returns which device is currently being used Returns in \p *device the current device for the calling host thread.

Parameters:

device - - Returns the device on which the active host thread executes the device code.

Returns:

::cudaSuccess, ::cudaErrorInvalidValue \notefnerr \note_init_rt \note_callback

cudaGetDevice

@Cast("cudaError_t")
public static int cudaGetDevice(IntBuffer device)

cudaGetDevice

@Cast("cudaError_t")
public static int cudaGetDevice(int[] device)

cudaSetValidDevices
```
@Cast("cudaError_t")
public static int cudaSetValidDevices(IntPointer device_arr,
                                      int len)
```
\brief Set a list of devices that can be used for CUDA Sets a list of devices for CUDA execution in priority order using \p device_arr. The parameter \p len specifies the number of elements in the list. CUDA will try devices from the list sequentially until it finds one that works. If this function is not called, or if it is called with a \p len of 0, then CUDA will go back to its default behavior of trying devices sequentially from a default list containing all of the available CUDA devices in the system. If a specified device ID in the list does not exist, this function will return ::cudaErrorInvalidDevice. If \p len is not 0 and \p device_arr is NULL or if \p len exceeds the number of devices in the system, then ::cudaErrorInvalidValue is returned.

Parameters:

device_arr - - List of devices to try

len - - Number of devices in specified list

Returns:

::cudaSuccess, ::cudaErrorInvalidValue, ::cudaErrorInvalidDevice \notefnerr \note_init_rt \note_callback

cudaSetValidDevices

@Cast("cudaError_t")
public static int cudaSetValidDevices(IntBuffer device_arr,
                                      int len)

cudaSetValidDevices

@Cast("cudaError_t")
public static int cudaSetValidDevices(int[] device_arr,
                                      int len)

cudaSetDeviceFlags
```
@Cast("cudaError_t")
public static int cudaSetDeviceFlags(@Cast("unsigned int")
                                     int flags)
```
\brief Sets flags to be used for device executions Records \p flags as the flags to use when initializing the current device. If no device has been made current to the calling thread, then \p flags will be applied to the initialization of any device initialized by the calling host thread, unless that device has had its initialization flags set explicitly by this or any host thread. If the current device has been set and that device has already been initialized then this call will fail with the error ::cudaErrorSetOnActiveProcess. In this case it is necessary to reset \p device using ::cudaDeviceReset() before the device's initialization flags may be set. The two LSBs of the \p flags parameter can be used to control how the CPU thread interacts with the OS scheduler when waiting for results from the device. - ::cudaDeviceScheduleAuto: The default value if the \p flags parameter is zero, uses a heuristic based on the number of active CUDA contexts in the process \p C and the number of logical processors in the system \p P. If \p C \> \p P, then CUDA will yield to other OS threads when waiting for the device, otherwise CUDA will not yield while waiting for results and actively spin on the processor. Additionally, on Tegra devices, ::cudaDeviceScheduleAuto uses a heuristic based on the power profile of the platform and may choose ::cudaDeviceScheduleBlockingSync for low-powered devices. - ::cudaDeviceScheduleSpin: Instruct CUDA to actively spin when waiting for results from the device. This can decrease latency when waiting for the device, but may lower the performance of CPU threads if they are performing work in parallel with the CUDA thread. - ::cudaDeviceScheduleYield: Instruct CUDA to yield its thread when waiting for results from the device. This can increase latency when waiting for the device, but can increase the performance of CPU threads performing work in parallel with the device. - ::cudaDeviceScheduleBlockingSync: Instruct CUDA to block the CPU thread on a synchronization primitive when waiting for the device to finish work. - ::cudaDeviceBlockingSync: Instruct CUDA to block the CPU thread on a synchronization primitive when waiting for the device to finish work.
\ref deprecated "Deprecated:" This flag was deprecated as of CUDA 4.0 and replaced with ::cudaDeviceScheduleBlockingSync. - ::cudaDeviceMapHost: This flag enables allocating pinned host memory that is accessible to the device. It is implicit for the runtime but may be absent if a context is created using the driver API. If this flag is not set, ::cudaHostGetDevicePointer() will always return a failure code. - ::cudaDeviceLmemResizeToMax: Instruct CUDA to not reduce local memory after resizing local memory for a kernel. This can prevent thrashing by local memory allocations when launching many kernels with high local memory usage at the cost of potentially increased memory usage.

Parameters:

flags - - Parameters for device operation

Returns:

::cudaSuccess, ::cudaErrorInvalidValue, ::cudaErrorSetOnActiveProcess \notefnerr \note_init_rt \note_callback

cudaGetDeviceFlags
```
@Cast("cudaError_t")
public static int cudaGetDeviceFlags(@Cast("unsigned int*")
                                     IntPointer flags)
```
\brief Gets the flags for the current device Returns in \p flags the flags for the current device. If there is a current device for the calling thread, and the device has been initialized or flags have been set on that device specifically, the flags for the device are returned. If there is no current device, but flags have been set for the thread with ::cudaSetDeviceFlags, the thread flags are returned. Finally, if there is no current device and no thread flags, the flags for the first device are returned, which may be the default flags. Compare to the behavior of ::cudaSetDeviceFlags. Typically, the flags returned should match the behavior that will be seen if the calling thread uses a device after this call, without any change to the flags or current device inbetween by this or another thread. Note that if the device is not initialized, it is possible for another thread to change the flags for the current device before it is initialized. Additionally, when using exclusive mode, if this thread has not requested a specific device, it may use a device other than the first device, contrary to the assumption made by this function. If a context has been created via the driver API and is current to the calling thread, the flags for that context are always returned. Flags returned by this function may specifically include ::cudaDeviceMapHost even though it is not accepted by ::cudaSetDeviceFlags because it is implicit in runtime API flags. The reason for this is that the current context may have been created via the driver API in which case the flag is not implicit and may be unset.

Parameters:

flags - - Pointer to store the device flags

Returns:

::cudaSuccess, ::cudaErrorInvalidDevice, ::cudaErrorInvalidValue
\notefnerr \note_init_rt \note_callback

cudaGetDeviceFlags

@Cast("cudaError_t")
public static int cudaGetDeviceFlags(@Cast("unsigned int*")
                                     IntBuffer flags)

cudaGetDeviceFlags

@Cast("cudaError_t")
public static int cudaGetDeviceFlags(@Cast("unsigned int*")
                                     int[] flags)

cudaStreamCreate
```
@Cast("cudaError_t")
public static int cudaStreamCreate(@ByPtrPtr
                                   CUstream_st pStream)
```
\brief Create an asynchronous stream Creates a new asynchronous stream.

Parameters:

pStream - - Pointer to new stream identifier

Returns:

::cudaSuccess, ::cudaErrorInvalidValue \notefnerr \note_init_rt \note_callback

cudaStreamCreateWithFlags
```
@Cast("cudaError_t")
public static int cudaStreamCreateWithFlags(@ByPtrPtr
                                            CUstream_st pStream,
                                            @Cast("unsigned int")
                                            int flags)
```
\brief Create an asynchronous stream Creates a new asynchronous stream. The \p flags argument determines the behaviors of the stream. Valid values for \p flags are - ::cudaStreamDefault: Default stream creation flag. - ::cudaStreamNonBlocking: Specifies that work running in the created stream may run concurrently with work in stream 0 (the NULL stream), and that the created stream should perform no implicit synchronization with stream 0.

Parameters:

pStream - - Pointer to new stream identifier

flags - - Parameters for stream creation

Returns:

::cudaSuccess, ::cudaErrorInvalidValue \notefnerr \note_init_rt \note_callback

cudaStreamCreateWithPriority
```
@Cast("cudaError_t")
public static int cudaStreamCreateWithPriority(@ByPtrPtr
                                               CUstream_st pStream,
                                               @Cast("unsigned int")
                                               int flags,
                                               int priority)
```
\brief Create an asynchronous stream with the specified priority Creates a stream with the specified priority and returns a handle in \p pStream. This API alters the scheduler priority of work in the stream. Work in a higher priority stream may preempt work already executing in a low priority stream. \p priority follows a convention where lower numbers represent higher priorities. '0' represents default priority. The range of meaningful numerical priorities can be queried using ::cudaDeviceGetStreamPriorityRange. If the specified priority is outside the numerical range returned by ::cudaDeviceGetStreamPriorityRange, it will automatically be clamped to the lowest or the highest number in the range.

Parameters:

pStream - - Pointer to new stream identifier

flags - - Flags for stream creation. See ::cudaStreamCreateWithFlags for a list of valid flags that can be passed

priority - - Priority of the stream. Lower numbers represent higher priorities. See ::cudaDeviceGetStreamPriorityRange for more information about the meaningful stream priorities that can be passed.

Returns:

::cudaSuccess, ::cudaErrorInvalidValue \notefnerr \note_init_rt \note_callback \note Stream priorities are supported only on GPUs with compute capability 3.5 or higher. \note In the current implementation, only compute kernels launched in priority streams are affected by the stream's priority. Stream priorities have no effect on host-to-device and device-to-host memory operations.

cudaStreamGetPriority
```
@Cast("cudaError_t")
public static int cudaStreamGetPriority(CUstream_st hStream,
                                        IntPointer priority)
```
\brief Query the priority of a stream Query the priority of a stream. The priority is returned in in \p priority. Note that if the stream was created with a priority outside the meaningful numerical range returned by ::cudaDeviceGetStreamPriorityRange, this function returns the clamped priority. See ::cudaStreamCreateWithPriority for details about priority clamping.

Parameters:

hStream - - Handle to the stream to be queried

priority - - Pointer to a signed integer in which the stream's priority is returned

Returns:

::cudaSuccess, ::cudaErrorInvalidValue, ::cudaErrorInvalidResourceHandle \notefnerr \note_init_rt \note_callback

cudaStreamGetPriority

@Cast("cudaError_t")
public static int cudaStreamGetPriority(CUstream_st hStream,
                                        IntBuffer priority)

cudaStreamGetPriority

@Cast("cudaError_t")
public static int cudaStreamGetPriority(CUstream_st hStream,
                                        int[] priority)

cudaStreamGetFlags
```
@Cast("cudaError_t")
public static int cudaStreamGetFlags(CUstream_st hStream,
                                     @Cast("unsigned int*")
                                     IntPointer flags)
```
\brief Query the flags of a stream Query the flags of a stream. The flags are returned in \p flags. See ::cudaStreamCreateWithFlags for a list of valid flags.

Parameters:

hStream - - Handle to the stream to be queried

flags - - Pointer to an unsigned integer in which the stream's flags are returned

Returns:

::cudaSuccess, ::cudaErrorInvalidValue, ::cudaErrorInvalidResourceHandle \note_null_stream \notefnerr \note_init_rt \note_callback

cudaStreamGetFlags

@Cast("cudaError_t")
public static int cudaStreamGetFlags(CUstream_st hStream,
                                     @Cast("unsigned int*")
                                     IntBuffer flags)

cudaStreamGetFlags

@Cast("cudaError_t")
public static int cudaStreamGetFlags(CUstream_st hStream,
                                     @Cast("unsigned int*")
                                     int[] flags)

cudaStreamDestroy
```
@Cast("cudaError_t")
public static int cudaStreamDestroy(CUstream_st stream)
```
\brief Destroys and cleans up an asynchronous stream Destroys and cleans up the asynchronous stream specified by \p stream. In case the device is still doing work in the stream \p stream when ::cudaStreamDestroy() is called, the function will return immediately and the resources associated with \p stream will be released automatically once the device has completed all work in \p stream.

Parameters:

stream - - Stream identifier

Returns:

::cudaSuccess, ::cudaErrorInvalidValue, ::cudaErrorInvalidResourceHandle \note_null_stream \notefnerr \note_init_rt \note_callback

cudaStreamWaitEvent
```
@Cast("cudaError_t")
public static int cudaStreamWaitEvent(CUstream_st stream,
                                      CUevent_st event,
                                      @Cast("unsigned int")
                                      int flags)
```
\brief Make a compute stream wait on an event Makes all future work submitted to \p stream wait for all work captured in \p event. See ::cudaEventRecord() for details on what is captured by an event. The synchronization will be performed efficiently on the device when applicable. \p event may be from a different device than \p stream.

Parameters:

stream - - Stream to wait

event - - Event to wait on

flags - - Parameters for the operation (must be 0)

Returns:

::cudaSuccess, ::cudaErrorInvalidValue, ::cudaErrorInvalidResourceHandle \note_null_stream \notefnerr \note_init_rt \note_callback

cudaStreamAddCallback
```
@Cast("cudaError_t")
public static int cudaStreamAddCallback(CUstream_st stream,
                                        cudaStreamCallback_t callback,
                                        Pointer userData,
                                        @Cast("unsigned int")
                                        int flags)
```
\brief Add a callback to a compute stream \note This function is slated for eventual deprecation and removal. If you do not require the callback to execute in case of a device error, consider using ::cudaLaunchHostFunc. Additionally, this function is not supported with ::cudaStreamBeginCapture and ::cudaStreamEndCapture, unlike ::cudaLaunchHostFunc. Adds a callback to be called on the host after all currently enqueued items in the stream have completed. For each cudaStreamAddCallback call, a callback will be executed exactly once. The callback will block later work in the stream until it is finished. The callback may be passed ::cudaSuccess or an error code. In the event of a device error, all subsequently executed callbacks will receive an appropriate ::cudaError_t. Callbacks must not make any CUDA API calls. Attempting to use CUDA APIs may result in ::cudaErrorNotPermitted. Callbacks must not perform any synchronization that may depend on outstanding device work or other callbacks that are not mandated to run earlier. Callbacks without a mandated order (in independent streams) execute in undefined order and may be serialized. For the purposes of Unified Memory, callback execution makes a number of guarantees:
- The callback stream is considered idle for the duration of the callback. Thus, for example, a callback may always use memory attached to the callback stream.
- The start of execution of a callback has the same effect as synchronizing an event recorded in the same stream immediately prior to the callback. It thus synchronizes streams which have been "joined" prior to the callback.
- Adding device work to any stream does not have the effect of making the stream active until all preceding callbacks have executed. Thus, for example, a callback might use global attached memory even if work has been added to another stream, if it has been properly ordered with an event.
- Completion of a callback does not cause a stream to become active except as described above. The callback stream will remain idle if no device work follows the callback, and will remain idle across consecutive callbacks without device work in between. Thus, for example, stream synchronization can be done by signaling from a callback at the end of the stream.
Parameters:

stream - - Stream to add callback to

callback - - The function to call once preceding stream operations are complete

userData - - User specified data to be passed to the callback function

flags - - Reserved for future use, must be 0

Returns:

::cudaSuccess, ::cudaErrorInvalidResourceHandle, ::cudaErrorInvalidValue, ::cudaErrorNotSupported \note_null_stream \notefnerr \note_init_rt \note_callback

cudaStreamSynchronize
```
@Cast("cudaError_t")
public static int cudaStreamSynchronize(CUstream_st stream)
```
\brief Waits for stream tasks to complete Blocks until \p stream has completed all operations. If the ::cudaDeviceScheduleBlockingSync flag was set for this device, the host thread will block until the stream is finished with all of its tasks.

Parameters:

stream - - Stream identifier

Returns:

::cudaSuccess, ::cudaErrorInvalidResourceHandle \note_null_stream \notefnerr \note_init_rt \note_callback

cudaStreamQuery
```
@Cast("cudaError_t")
public static int cudaStreamQuery(CUstream_st stream)
```
\brief Queries an asynchronous stream for completion status Returns ::cudaSuccess if all operations in \p stream have completed, or ::cudaErrorNotReady if not. For the purposes of Unified Memory, a return value of ::cudaSuccess is equivalent to having called ::cudaStreamSynchronize().

Parameters:

stream - - Stream identifier

Returns:

::cudaSuccess, ::cudaErrorNotReady, ::cudaErrorInvalidResourceHandle \note_null_stream \notefnerr \note_init_rt \note_callback

cudaStreamAttachMemAsync
```
@Cast("cudaError_t")
public static int cudaStreamAttachMemAsync(CUstream_st stream,
                                           Pointer devPtr,
                                           @Cast("size_t")
                                           long length,
                                           @Cast("unsigned int")
                                           int flags)
```
\brief Attach memory to a stream asynchronously Enqueues an operation in \p stream to specify stream association of \p length bytes of memory starting from \p devPtr. This function is a stream-ordered operation, meaning that it is dependent on, and will only take effect when, previous work in stream has completed. Any previous association is automatically replaced. \p devPtr must point to an one of the following types of memories: - managed memory declared using the __managed__ keyword or allocated with ::cudaMallocManaged. - a valid host-accessible region of system-allocated pageable memory. This type of memory may only be specified if the device associated with the stream reports a non-zero value for the device attribute ::cudaDevAttrPageableMemoryAccess. For managed allocations, \p length must be either zero or the entire allocation's size. Both indicate that the entire allocation's stream association is being changed. Currently, it is not possible to change stream association for a portion of a managed allocation. For pageable allocations, \p length must be non-zero. The stream association is specified using \p flags which must be one of ::cudaMemAttachGlobal, ::cudaMemAttachHost or ::cudaMemAttachSingle. The default value for \p flags is ::cudaMemAttachSingle If the ::cudaMemAttachGlobal flag is specified, the memory can be accessed by any stream on any device. If the ::cudaMemAttachHost flag is specified, the program makes a guarantee that it won't access the memory on the device from any stream on a device that has a zero value for the device attribute ::cudaDevAttrConcurrentManagedAccess. If the ::cudaMemAttachSingle flag is specified and \p stream is associated with a device that has a zero value for the device attribute ::cudaDevAttrConcurrentManagedAccess, the program makes a guarantee that it will only access the memory on the device from \p stream. It is illegal to attach singly to the NULL stream, because the NULL stream is a virtual global stream and not a specific stream. An error will be returned in this case. When memory is associated with a single stream, the Unified Memory system will allow CPU access to this memory region so long as all operations in \p stream have completed, regardless of whether other streams are active. In effect, this constrains exclusive ownership of the managed memory region by an active GPU to per-stream activity instead of whole-GPU activity. Accessing memory on the device from streams that are not associated with it will produce undefined results. No error checking is performed by the Unified Memory system to ensure that kernels launched into other streams do not access this region. It is a program's responsibility to order calls to ::cudaStreamAttachMemAsync via events, synchronization or other means to ensure legal access to memory at all times. Data visibility and coherency will be changed appropriately for all kernels which follow a stream-association change. If \p stream is destroyed while data is associated with it, the association is removed and the association reverts to the default visibility of the allocation as specified at ::cudaMallocManaged. For __managed__ variables, the default association is always ::cudaMemAttachGlobal. Note that destroying a stream is an asynchronous operation, and as a result, the change to default association won't happen until all work in the stream has completed.

Parameters:

stream - - Stream in which to enqueue the attach operation

devPtr - - Pointer to memory (must be a pointer to managed memory or to a valid host-accessible region of system-allocated memory)

length - - Length of memory (defaults to zero)

flags - - Must be one of ::cudaMemAttachGlobal, ::cudaMemAttachHost or ::cudaMemAttachSingle (defaults to ::cudaMemAttachSingle)

Returns:

::cudaSuccess, ::cudaErrorNotReady, ::cudaErrorInvalidValue, ::cudaErrorInvalidResourceHandle \notefnerr \note_init_rt \note_callback

cudaStreamAttachMemAsync

@Cast("cudaError_t")
public static int cudaStreamAttachMemAsync(CUstream_st stream,
                                           Pointer devPtr)

cudaStreamBeginCapture
```
@Cast("cudaError_t")
public static int cudaStreamBeginCapture(CUstream_st stream,
                                         @Cast("cudaStreamCaptureMode")
                                         int mode)
```
\brief Begins graph capture on a stream Begin graph capture on \p stream. When a stream is in capture mode, all operations pushed into the stream will not be executed, but will instead be captured into a graph, which will be returned via ::cudaStreamEndCapture. Capture may not be initiated if \p stream is ::cudaStreamLegacy. Capture must be ended on the same stream in which it was initiated, and it may only be initiated if the stream is not already in capture mode. The capture mode may be queried via ::cudaStreamIsCapturing. A unique id representing the capture sequence may be queried via ::cudaStreamGetCaptureInfo. If \p mode is not ::cudaStreamCaptureModeRelaxed, ::cudaStreamEndCapture must be called on this stream from the same thread. \note Kernels captured using this API must not use texture and surface references. Reading or writing through any texture or surface reference is undefined behavior. This restriction does not apply to texture and surface objects.

Parameters:

stream - - Stream in which to initiate capture

mode - - Controls the interaction of this capture sequence with other API calls that are potentially unsafe. For more details see ::cudaThreadExchangeStreamCaptureMode.

Returns:

::cudaSuccess, ::cudaErrorInvalidValue \notefnerr

cudaThreadExchangeStreamCaptureMode
```
@Cast("cudaError_t")
public static int cudaThreadExchangeStreamCaptureMode(@Cast("cudaStreamCaptureMode*")
                                                      IntPointer mode)
```
\brief Swaps the stream capture interaction mode for a thread Sets the calling thread's stream capture interaction mode to the value contained in \p *mode, and overwrites \p *mode with the previous mode for the thread. To facilitate deterministic behavior across function or module boundaries, callers are encouraged to use this API in a push-pop fashion:
```
     cudaStreamCaptureMode mode = desiredMode;
     cudaThreadExchangeStreamCaptureMode(&mode);
     ...
     cudaThreadExchangeStreamCaptureMode(&mode); // restore previous mode
 
```
During stream capture (see ::cudaStreamBeginCapture), some actions, such as a call to ::cudaMalloc, may be unsafe. In the case of ::cudaMalloc, the operation is not enqueued asynchronously to a stream, and is not observed by stream capture. Therefore, if the sequence of operations captured via ::cudaStreamBeginCapture depended on the allocation being replayed whenever the graph is launched, the captured graph would be invalid. Therefore, stream capture places restrictions on API calls that can be made within or concurrently to a ::cudaStreamBeginCapture-::cudaStreamEndCapture sequence. This behavior can be controlled via this API and flags to ::cudaStreamBeginCapture. A thread's mode is one of the following: - \p cudaStreamCaptureModeGlobal: This is the default mode. If the local thread has an ongoing capture sequence that was not initiated with \p cudaStreamCaptureModeRelaxed at \p cuStreamBeginCapture, or if any other thread has a concurrent capture sequence initiated with \p cudaStreamCaptureModeGlobal, this thread is prohibited from potentially unsafe API calls. - \p cudaStreamCaptureModeThreadLocal: If the local thread has an ongoing capture sequence not initiated with \p cudaStreamCaptureModeRelaxed, it is prohibited from potentially unsafe API calls. Concurrent capture sequences in other threads are ignored. - \p cudaStreamCaptureModeRelaxed: The local thread is not prohibited from potentially unsafe API calls. Note that the thread is still prohibited from API calls which necessarily conflict with stream capture, for example, attempting ::cudaEventQuery on an event that was last recorded inside a capture sequence.
Parameters:

mode - - Pointer to mode value to swap with the current mode

Returns:

::cudaSuccess, ::cudaErrorInvalidValue \notefnerr

cudaThreadExchangeStreamCaptureMode

@Cast("cudaError_t")
public static int cudaThreadExchangeStreamCaptureMode(@Cast("cudaStreamCaptureMode*")
                                                      IntBuffer mode)

cudaThreadExchangeStreamCaptureMode

@Cast("cudaError_t")
public static int cudaThreadExchangeStreamCaptureMode(@Cast("cudaStreamCaptureMode*")
                                                      int[] mode)

cudaStreamEndCapture
```
@Cast("cudaError_t")
public static int cudaStreamEndCapture(CUstream_st stream,
                                       @ByPtrPtr
                                       CUgraph_st pGraph)
```
\brief Ends capture on a stream, returning the captured graph End capture on \p stream, returning the captured graph via \p pGraph. Capture must have been initiated on \p stream via a call to ::cudaStreamBeginCapture. If capture was invalidated, due to a violation of the rules of stream capture, then a NULL graph will be returned. If the \p mode argument to ::cudaStreamBeginCapture was not ::cudaStreamCaptureModeRelaxed, this call must be from the same thread as ::cudaStreamBeginCapture.

Parameters:

stream - - Stream to query

pGraph - - The captured graph

Returns:

::cudaSuccess, ::cudaErrorInvalidValue, ::cudaErrorStreamCaptureWrongThread \notefnerr

cudaStreamIsCapturing
```
@Cast("cudaError_t")
public static int cudaStreamIsCapturing(CUstream_st stream,
                                        @Cast("cudaStreamCaptureStatus*")
                                        IntPointer pCaptureStatus)
```
\brief Returns a stream's capture status Return the capture status of \p stream via \p pCaptureStatus. After a successful call, \p *pCaptureStatus will contain one of the following: - ::cudaStreamCaptureStatusNone: The stream is not capturing. - ::cudaStreamCaptureStatusActive: The stream is capturing. - ::cudaStreamCaptureStatusInvalidated: The stream was capturing but an error has invalidated the capture sequence. The capture sequence must be terminated with ::cudaStreamEndCapture on the stream where it was initiated in order to continue using \p stream. Note that, if this is called on ::cudaStreamLegacy (the "null stream") while a blocking stream on the same device is capturing, it will return ::cudaErrorStreamCaptureImplicit and \p *pCaptureStatus is unspecified after the call. The blocking stream capture is not invalidated. When a blocking stream is capturing, the legacy stream is in an unusable state until the blocking stream capture is terminated. The legacy stream is not supported for stream capture, but attempted use would have an implicit dependency on the capturing stream(s).

Parameters:

stream - - Stream to query

pCaptureStatus - - Returns the stream's capture status

Returns:

::cudaSuccess, ::cudaErrorInvalidValue, ::cudaErrorStreamCaptureImplicit \notefnerr

cudaStreamIsCapturing

@Cast("cudaError_t")
public static int cudaStreamIsCapturing(CUstream_st stream,
                                        @Cast("cudaStreamCaptureStatus*")
                                        IntBuffer pCaptureStatus)

cudaStreamIsCapturing

@Cast("cudaError_t")
public static int cudaStreamIsCapturing(CUstream_st stream,
                                        @Cast("cudaStreamCaptureStatus*")
                                        int[] pCaptureStatus)

cudaStreamGetCaptureInfo
```
@Cast("cudaError_t")
public static int cudaStreamGetCaptureInfo(CUstream_st stream,
                                           @Cast("cudaStreamCaptureStatus*")
                                           IntPointer pCaptureStatus,
                                           @Cast("unsigned long long*")
                                           LongPointer pId)
```
\brief Query capture status of a stream Query the capture status of a stream and get a unique id representing the capture sequence over the lifetime of the process. If called on ::cudaStreamLegacy (the "null stream") while a stream not created with ::cudaStreamNonBlocking is capturing, returns ::cudaErrorStreamCaptureImplicit. A valid id is returned only if both of the following are true: - the call returns ::cudaSuccess - captureStatus is set to ::cudaStreamCaptureStatusActive

Parameters:

stream - - Stream to query

pCaptureStatus - - Returns the stream's capture status

pId - - Returns the unique id of the capture sequence

Returns:

::cudaSuccess, ::cudaErrorStreamCaptureImplicit \notefnerr

cudaStreamGetCaptureInfo

@Cast("cudaError_t")
public static int cudaStreamGetCaptureInfo(CUstream_st stream,
                                           @Cast("cudaStreamCaptureStatus*")
                                           IntBuffer pCaptureStatus,
                                           @Cast("unsigned long long*")
                                           LongBuffer pId)

cudaStreamGetCaptureInfo

@Cast("cudaError_t")
public static int cudaStreamGetCaptureInfo(CUstream_st stream,
                                           @Cast("cudaStreamCaptureStatus*")
                                           int[] pCaptureStatus,
                                           @Cast("unsigned long long*")
                                           long[] pId)

cudaEventCreate
```
@Cast("cudaError_t")
public static int cudaEventCreate(@ByPtrPtr
                                  CUevent_st event)
```
\brief Creates an event object Creates an event object for the current device using ::cudaEventDefault.

Parameters:

event - - Newly created event

Returns:

::cudaSuccess, ::cudaErrorInvalidValue, ::cudaErrorLaunchFailure, ::cudaErrorMemoryAllocation \notefnerr \note_init_rt \note_callback

cudaEventCreateWithFlags
```
@Cast("cudaError_t")
public static int cudaEventCreateWithFlags(@ByPtrPtr
                                           CUevent_st event,
                                           @Cast("unsigned int")
                                           int flags)
```
\brief Creates an event object with the specified flags Creates an event object for the current device with the specified flags. Valid flags include: - ::cudaEventDefault: Default event creation flag. - ::cudaEventBlockingSync: Specifies that event should use blocking synchronization. A host thread that uses ::cudaEventSynchronize() to wait on an event created with this flag will block until the event actually completes. - ::cudaEventDisableTiming: Specifies that the created event does not need to record timing data. Events created with this flag specified and the ::cudaEventBlockingSync flag not specified will provide the best performance when used with ::cudaStreamWaitEvent() and ::cudaEventQuery(). - ::cudaEventInterprocess: Specifies that the created event may be used as an interprocess event by ::cudaIpcGetEventHandle(). ::cudaEventInterprocess must be specified along with ::cudaEventDisableTiming.

Parameters:

event - - Newly created event

flags - - Flags for new event

Returns:

::cudaSuccess, ::cudaErrorInvalidValue, ::cudaErrorLaunchFailure, ::cudaErrorMemoryAllocation \notefnerr \note_init_rt \note_callback

cudaEventRecord
```
@Cast("cudaError_t")
public static int cudaEventRecord(CUevent_st event,
                                  CUstream_st stream)
```
\brief Records an event Captures in \p event the contents of \p stream at the time of this call. \p event and \p stream must be on the same device. Calls such as ::cudaEventQuery() or ::cudaStreamWaitEvent() will then examine or wait for completion of the work that was captured. Uses of \p stream after this call do not modify \p event. See note on default stream behavior for what is captured in the default case. ::cudaEventRecord() can be called multiple times on the same event and will overwrite the previously captured state. Other APIs such as ::cudaStreamWaitEvent() use the most recently captured state at the time of the API call, and are not affected by later calls to ::cudaEventRecord(). Before the first call to ::cudaEventRecord(), an event represents an empty set of work, so for example ::cudaEventQuery() would return ::cudaSuccess.

Parameters:

event - - Event to record

stream - - Stream in which to record event

Returns:

::cudaSuccess, ::cudaErrorInvalidValue, ::cudaErrorInvalidResourceHandle, ::cudaErrorLaunchFailure \note_null_stream \notefnerr \note_init_rt \note_callback

cudaEventRecord

@Cast("cudaError_t")
public static int cudaEventRecord(CUevent_st event)

cudaEventQuery
```
@Cast("cudaError_t")
public static int cudaEventQuery(CUevent_st event)
```
\brief Queries an event's status Queries the status of all work currently captured by \p event. See ::cudaEventRecord() for details on what is captured by an event. Returns ::cudaSuccess if all captured work has been completed, or ::cudaErrorNotReady if any captured work is incomplete. For the purposes of Unified Memory, a return value of ::cudaSuccess is equivalent to having called ::cudaEventSynchronize().

Parameters:

event - - Event to query

Returns:

::cudaSuccess, ::cudaErrorNotReady, ::cudaErrorInvalidValue, ::cudaErrorInvalidResourceHandle, ::cudaErrorLaunchFailure \notefnerr \note_init_rt \note_callback

cudaEventSynchronize
```
@Cast("cudaError_t")
public static int cudaEventSynchronize(CUevent_st event)
```
\brief Waits for an event to complete Waits until the completion of all work currently captured in \p event. See ::cudaEventRecord() for details on what is captured by an event. Waiting for an event that was created with the ::cudaEventBlockingSync flag will cause the calling CPU thread to block until the event has been completed by the device. If the ::cudaEventBlockingSync flag has not been set, then the CPU thread will busy-wait until the event has been completed by the device.

Parameters:

event - - Event to wait for

Returns:

::cudaSuccess, ::cudaErrorInvalidValue, ::cudaErrorInvalidResourceHandle, ::cudaErrorLaunchFailure \notefnerr \note_init_rt \note_callback

cudaEventDestroy
```
@Cast("cudaError_t")
public static int cudaEventDestroy(CUevent_st event)
```
\brief Destroys an event object Destroys the event specified by \p event. An event may be destroyed before it is complete (i.e., while ::cudaEventQuery() would return ::cudaErrorNotReady). In this case, the call does not block on completion of the event, and any associated resources will automatically be released asynchronously at completion.

Parameters:

event - - Event to destroy

Returns:

::cudaSuccess, ::cudaErrorInvalidValue, ::cudaErrorLaunchFailure \notefnerr \note_init_rt \note_callback

cudaEventElapsedTime
```
@Cast("cudaError_t")
public static int cudaEventElapsedTime(FloatPointer ms,
                                       CUevent_st start,
                                       CUevent_st end)
```
\brief Computes the elapsed time between events Computes the elapsed time between two events (in milliseconds with a resolution of around 0.5 microseconds). If either event was last recorded in a non-NULL stream, the resulting time may be greater than expected (even if both used the same stream handle). This happens because the ::cudaEventRecord() operation takes place asynchronously and there is no guarantee that the measured latency is actually just between the two events. Any number of other different stream operations could execute in between the two measured events, thus altering the timing in a significant way. If ::cudaEventRecord() has not been called on either event, then ::cudaErrorInvalidResourceHandle is returned. If ::cudaEventRecord() has been called on both events but one or both of them has not yet been completed (that is, ::cudaEventQuery() would return ::cudaErrorNotReady on at least one of the events), ::cudaErrorNotReady is returned. If either event was created with the ::cudaEventDisableTiming flag, then this function will return ::cudaErrorInvalidResourceHandle.

Parameters:

ms - - Time between \p start and \p end in ms

start - - Starting event

end - - Ending event

Returns:

::cudaSuccess, ::cudaErrorNotReady, ::cudaErrorInvalidValue, ::cudaErrorInvalidResourceHandle, ::cudaErrorLaunchFailure \notefnerr \note_init_rt \note_callback

cudaEventElapsedTime

@Cast("cudaError_t")
public static int cudaEventElapsedTime(FloatBuffer ms,
                                       CUevent_st start,
                                       CUevent_st end)

cudaEventElapsedTime

@Cast("cudaError_t")
public static int cudaEventElapsedTime(float[] ms,
                                       CUevent_st start,
                                       CUevent_st end)

cudaImportExternalMemory
```
@Cast("cudaError_t")
public static int cudaImportExternalMemory(@ByPtrPtr
                                           CUexternalMemory_st extMem_out,
                                           @Const
                                           cudaExternalMemoryHandleDesc memHandleDesc)
```
\brief Imports an external memory object Imports an externally allocated memory object and returns a handle to that in \p extMem_out. The properties of the handle being imported must be described in \p memHandleDesc. The ::cudaExternalMemoryHandleDesc structure is defined as follows:
```
        typedef struct cudaExternalMemoryHandleDesc_st {
            cudaExternalMemoryHandleType type;
            union {
                int fd;
                struct {
                    void *handle;
                    const void *name;
                } win32;
                const void *nvSciBufObject;
            } handle;
            unsigned long long size;
            unsigned int flags;
        } cudaExternalMemoryHandleDesc;
 
```
where ::cudaExternalMemoryHandleDesc::type specifies the type of handle being imported. ::cudaExternalMemoryHandleType is defined as:
```
        typedef enum cudaExternalMemoryHandleType_enum {
            cudaExternalMemoryHandleTypeOpaqueFd         = 1,
            cudaExternalMemoryHandleTypeOpaqueWin32      = 2,
            cudaExternalMemoryHandleTypeOpaqueWin32Kmt   = 3,
            cudaExternalMemoryHandleTypeD3D12Heap        = 4,
            cudaExternalMemoryHandleTypeD3D12Resource    = 5,
	        cudaExternalMemoryHandleTypeD3D11Resource    = 6,
		    cudaExternalMemoryHandleTypeD3D11ResourceKmt = 7,
            cudaExternalMemoryHandleTypeNvSciBuf         = 8
        } cudaExternalMemoryHandleType;
 
```
If ::cudaExternalMemoryHandleDesc::type is ::cudaExternalMemoryHandleTypeOpaqueFd, then ::cudaExternalMemoryHandleDesc::handle::fd must be a valid file descriptor referencing a memory object. Ownership of the file descriptor is transferred to the CUDA driver when the handle is imported successfully. Performing any operations on the file descriptor after it is imported results in undefined behavior. If ::cudaExternalMemoryHandleDesc::type is ::cudaExternalMemoryHandleTypeOpaqueWin32, then exactly one of ::cudaExternalMemoryHandleDesc::handle::win32::handle and ::cudaExternalMemoryHandleDesc::handle::win32::name must not be NULL. If ::cudaExternalMemoryHandleDesc::handle::win32::handle is not NULL, then it must represent a valid shared NT handle that references a memory object. Ownership of this handle is not transferred to CUDA after the import operation, so the application must release the handle using the appropriate system call. If ::cudaExternalMemoryHandleDesc::handle::win32::name is not NULL, then it must point to a NULL-terminated array of UTF-16 characters that refers to a memory object. If ::cudaExternalMemoryHandleDesc::type is ::cudaExternalMemoryHandleTypeOpaqueWin32Kmt, then ::cudaExternalMemoryHandleDesc::handle::win32::handle must be non-NULL and ::cudaExternalMemoryHandleDesc::handle::win32::name must be NULL. The handle specified must be a globally shared KMT handle. This handle does not hold a reference to the underlying object, and thus will be invalid when all references to the memory object are destroyed. If ::cudaExternalMemoryHandleDesc::type is ::cudaExternalMemoryHandleTypeD3D12Heap, then exactly one of ::cudaExternalMemoryHandleDesc::handle::win32::handle and ::cudaExternalMemoryHandleDesc::handle::win32::name must not be NULL. If ::cudaExternalMemoryHandleDesc::handle::win32::handle is not NULL, then it must represent a valid shared NT handle that is returned by ID3D12Device::CreateSharedHandle when referring to a ID3D12Heap object. This handle holds a reference to the underlying object. If ::cudaExternalMemoryHandleDesc::handle::win32::name is not NULL, then it must point to a NULL-terminated array of UTF-16 characters that refers to a ID3D12Heap object. If ::cudaExternalMemoryHandleDesc::type is ::cudaExternalMemoryHandleTypeD3D12Resource, then exactly one of ::cudaExternalMemoryHandleDesc::handle::win32::handle and ::cudaExternalMemoryHandleDesc::handle::win32::name must not be NULL. If ::cudaExternalMemoryHandleDesc::handle::win32::handle is not NULL, then it must represent a valid shared NT handle that is returned by ID3D12Device::CreateSharedHandle when referring to a ID3D12Resource object. This handle holds a reference to the underlying object. If ::cudaExternalMemoryHandleDesc::handle::win32::name is not NULL, then it must point to a NULL-terminated array of UTF-16 characters that refers to a ID3D12Resource object. If ::cudaExternalMemoryHandleDesc::type is ::cudaExternalMemoryHandleTypeD3D11Resource,then exactly one of ::cudaExternalMemoryHandleDesc::handle::win32::handle and ::cudaExternalMemoryHandleDesc::handle::win32::name must not be NULL. If ::cudaExternalMemoryHandleDesc::handle::win32::handle is not NULL, then it must represent a valid shared NT handle that is returned by IDXGIResource1::CreateSharedHandle when referring to a ID3D11Resource object. If ::cudaExternalMemoryHandleDesc::handle::win32::name is not NULL, then it must point to a NULL-terminated array of UTF-16 characters that refers to a ID3D11Resource object. If ::cudaExternalMemoryHandleDesc::type is ::cudaExternalMemoryHandleTypeD3D11ResourceKmt, then ::cudaExternalMemoryHandleDesc::handle::win32::handle must be non-NULL and ::cudaExternalMemoryHandleDesc::handle::win32::name must be NULL. The handle specified must be a valid shared KMT handle that is returned by IDXGIResource::GetSharedHandle when referring to a ID3D11Resource object. If ::cudaExternalMemoryHandleDesc::type is ::cudaExternalMemoryHandleTypeNvSciBuf, then ::cudaExternalMemoryHandleDesc::handle::nvSciBufObject must be NON-NULL and reference a valid NvSciBuf object. If the NvSciBuf object imported into CUDA is also mapped by other drivers, then the application must use ::cudaWaitExternalSemaphoresAsync or ::cudaSignalExternalSemaphoresAsync as approprriate barriers to maintain coherence between CUDA and the other drivers. The size of the memory object must be specified in ::cudaExternalMemoryHandleDesc::size. Specifying the flag ::cudaExternalMemoryDedicated in ::cudaExternalMemoryHandleDesc::flags indicates that the resource is a dedicated resource. The definition of what a dedicated resource is outside the scope of this extension. This flag must be set if ::cudaExternalMemoryHandleDesc::type is one of the following: ::cudaExternalMemoryHandleTypeD3D12Resource ::cudaExternalMemoryHandleTypeD3D11Resource ::cudaExternalMemoryHandleTypeD3D11ResourceKmt
Parameters:

extMem_out - - Returned handle to an external memory object

memHandleDesc - - Memory import handle descriptor

Returns:

::cudaSuccess, ::cudaErrorInvalidResourceHandle \notefnerr \note_init_rt \note_callback \note If the Vulkan memory imported into CUDA is mapped on the CPU then the application must use vkInvalidateMappedMemoryRanges/vkFlushMappedMemoryRanges as well as appropriate Vulkan pipeline barriers to maintain coherence between CPU and GPU. For more information on these APIs, please refer to "Synchronization and Cache Control" chapter from Vulkan specification.

cudaExternalMemoryGetMappedBuffer
```
@Cast("cudaError_t")
public static int cudaExternalMemoryGetMappedBuffer(@Cast("void**")
                                                    PointerPointer devPtr,
                                                    CUexternalMemory_st extMem,
                                                    @Const
                                                    cudaExternalMemoryBufferDesc bufferDesc)
```
\brief Maps a buffer onto an imported memory object Maps a buffer onto an imported memory object and returns a device pointer in \p devPtr. The properties of the buffer being mapped must be described in \p bufferDesc. The ::cudaExternalMemoryBufferDesc structure is defined as follows:
```
        typedef struct cudaExternalMemoryBufferDesc_st {
            unsigned long long offset;
            unsigned long long size;
            unsigned int flags;
        } cudaExternalMemoryBufferDesc;
 
```
where ::cudaExternalMemoryBufferDesc::offset is the offset in the memory object where the buffer's base address is. ::cudaExternalMemoryBufferDesc::size is the size of the buffer. ::cudaExternalMemoryBufferDesc::flags must be zero. The offset and size have to be suitably aligned to match the requirements of the external API. Mapping two buffers whose ranges overlap may or may not result in the same virtual address being returned for the overlapped portion. In such cases, the application must ensure that all accesses to that region from the GPU are volatile. Otherwise writes made via one address are not guaranteed to be visible via the other address, even if they're issued by the same thread. It is recommended that applications map the combined range instead of mapping separate buffers and then apply the appropriate offsets to the returned pointer to derive the individual buffers. The returned pointer \p devPtr must be freed using ::cudaFree.
Parameters:

devPtr - - Returned device pointer to buffer

extMem - - Handle to external memory object

bufferDesc - - Buffer descriptor

Returns:

::cudaSuccess, ::cudaErrorInvalidResourceHandle \notefnerr \note_init_rt \note_callback

cudaExternalMemoryGetMappedBuffer

@Cast("cudaError_t")
public static int cudaExternalMemoryGetMappedBuffer(@Cast("void**") @ByPtrPtr
                                                    Pointer devPtr,
                                                    CUexternalMemory_st extMem,
                                                    @Const
                                                    cudaExternalMemoryBufferDesc bufferDesc)

cudaExternalMemoryGetMappedMipmappedArray
```
@Cast("cudaError_t")
public static int cudaExternalMemoryGetMappedMipmappedArray(@ByPtrPtr
                                                            cudaMipmappedArray mipmap,
                                                            CUexternalMemory_st extMem,
                                                            @Const
                                                            cudaExternalMemoryMipmappedArrayDesc mipmapDesc)
```
\brief Maps a CUDA mipmapped array onto an external memory object Maps a CUDA mipmapped array onto an external object and returns a handle to it in \p mipmap. The properties of the CUDA mipmapped array being mapped must be described in \p mipmapDesc. The structure ::cudaExternalMemoryMipmappedArrayDesc is defined as follows:
```
        typedef struct cudaExternalMemoryMipmappedArrayDesc_st {
            unsigned long long offset;
            cudaChannelFormatDesc formatDesc;
            cudaExtent extent;
            unsigned int flags;
            unsigned int numLevels;
        } cudaExternalMemoryMipmappedArrayDesc;
 
```
where ::cudaExternalMemoryMipmappedArrayDesc::offset is the offset in the memory object where the base level of the mipmap chain is. ::cudaExternalMemoryMipmappedArrayDesc::formatDesc describes the format of the data. ::cudaExternalMemoryMipmappedArrayDesc::extent specifies the dimensions of the base level of the mipmap chain. ::cudaExternalMemoryMipmappedArrayDesc::flags are flags associated with CUDA mipmapped arrays. For further details, please refer to the documentation for ::cudaMalloc3DArray. Note that if the mipmapped array is bound as a color target in the graphics API, then the flag ::cudaArrayColorAttachment must be specified in ::cudaExternalMemoryMipmappedArrayDesc::flags. ::cudaExternalMemoryMipmappedArrayDesc::numLevels specifies the total number of levels in the mipmap chain. The returned CUDA mipmapped array must be freed using ::cudaFreeMipmappedArray.
Parameters:

mipmap - - Returned CUDA mipmapped array

extMem - - Handle to external memory object

mipmapDesc - - CUDA array descriptor

Returns:

::cudaSuccess, ::cudaErrorInvalidResourceHandle \notefnerr \note_init_rt \note_callback

cudaDestroyExternalMemory
```
@Cast("cudaError_t")
public static int cudaDestroyExternalMemory(CUexternalMemory_st extMem)
```
\brief Destroys an external memory object. Destroys the specified external memory object. Any existing buffers and CUDA mipmapped arrays mapped onto this object must no longer be used and must be explicitly freed using ::cudaFree and ::cudaFreeMipmappedArray respectively.

Parameters:

extMem - - External memory object to be destroyed

Returns:

::cudaSuccess, ::cudaErrorInvalidResourceHandle \notefnerr \note_init_rt \note_callback

cudaImportExternalSemaphore
```
@Cast("cudaError_t")
public static int cudaImportExternalSemaphore(@ByPtrPtr
                                              CUexternalSemaphore_st extSem_out,
                                              @Const
                                              cudaExternalSemaphoreHandleDesc semHandleDesc)
```
\brief Imports an external semaphore Imports an externally allocated synchronization object and returns a handle to that in \p extSem_out. The properties of the handle being imported must be described in \p semHandleDesc. The ::cudaExternalSemaphoreHandleDesc is defined as follows:
```
        typedef struct cudaExternalSemaphoreHandleDesc_st {
            cudaExternalSemaphoreHandleType type;
            union {
                int fd;
                struct {
                    void *handle;
                    const void *name;
                } win32;
                const void* NvSciSyncObj;
            } handle;
            unsigned int flags;
        } cudaExternalSemaphoreHandleDesc;
 
```
where ::cudaExternalSemaphoreHandleDesc::type specifies the type of handle being imported. ::cudaExternalSemaphoreHandleType is defined as:
```
        typedef enum cudaExternalSemaphoreHandleType_enum {
            cudaExternalSemaphoreHandleTypeOpaqueFd       = 1,
            cudaExternalSemaphoreHandleTypeOpaqueWin32    = 2,
            cudaExternalSemaphoreHandleTypeOpaqueWin32Kmt = 3,
            cudaExternalSemaphoreHandleTypeD3D12Fence     = 4,
		    cudaExternalSemaphoreHandleTypeD3D11Fence     = 5,
            cudaExternalSemaphoreHandleTypeNvSciSync      = 6,
            cudaExternalSemaphoreHandleTypeKeyedMutex     = 7,
            cudaExternalSemaphoreHandleTypeKeyedMutexKmt  = 8
        } cudaExternalSemaphoreHandleType;
 
```
If ::cudaExternalSemaphoreHandleDesc::type is ::cudaExternalSemaphoreHandleTypeOpaqueFd, then ::cudaExternalSemaphoreHandleDesc::handle::fd must be a valid file descriptor referencing a synchronization object. Ownership of the file descriptor is transferred to the CUDA driver when the handle is imported successfully. Performing any operations on the file descriptor after it is imported results in undefined behavior. If ::cudaExternalSemaphoreHandleDesc::type is ::cudaExternalSemaphoreHandleTypeOpaqueWin32, then exactly one of ::cudaExternalSemaphoreHandleDesc::handle::win32::handle and ::cudaExternalSemaphoreHandleDesc::handle::win32::name must not be NULL. If ::cudaExternalSemaphoreHandleDesc::handle::win32::handle is not NULL, then it must represent a valid shared NT handle that references a synchronization object. Ownership of this handle is not transferred to CUDA after the import operation, so the application must release the handle using the appropriate system call. If ::cudaExternalSemaphoreHandleDesc::handle::win32::name is not NULL, then it must name a valid synchronization object. If ::cudaExternalSemaphoreHandleDesc::type is ::cudaExternalSemaphoreHandleTypeOpaqueWin32Kmt, then ::cudaExternalSemaphoreHandleDesc::handle::win32::handle must be non-NULL and ::cudaExternalSemaphoreHandleDesc::handle::win32::name must be NULL. The handle specified must be a globally shared KMT handle. This handle does not hold a reference to the underlying object, and thus will be invalid when all references to the synchronization object are destroyed. If ::cudaExternalSemaphoreHandleDesc::type is ::cudaExternalSemaphoreHandleTypeD3D12Fence, then exactly one of ::cudaExternalSemaphoreHandleDesc::handle::win32::handle and ::cudaExternalSemaphoreHandleDesc::handle::win32::name must not be NULL. If ::cudaExternalSemaphoreHandleDesc::handle::win32::handle is not NULL, then it must represent a valid shared NT handle that is returned by ID3D12Device::CreateSharedHandle when referring to a ID3D12Fence object. This handle holds a reference to the underlying object. If ::cudaExternalSemaphoreHandleDesc::handle::win32::name is not NULL, then it must name a valid synchronization object that refers to a valid ID3D12Fence object. If ::cudaExternalSemaphoreHandleDesc::type is ::cudaExternalSemaphoreHandleTypeD3D11Fence, then exactly one of ::cudaExternalSemaphoreHandleDesc::handle::win32::handle and ::cudaExternalSemaphoreHandleDesc::handle::win32::name must not be NULL. If ::cudaExternalSemaphoreHandleDesc::handle::win32::handle is not NULL, then it must represent a valid shared NT handle that is returned by ID3D11Fence::CreateSharedHandle. If ::cudaExternalSemaphoreHandleDesc::handle::win32::name is not NULL, then it must name a valid synchronization object that refers to a valid ID3D11Fence object. If ::cudaExternalSemaphoreHandleDesc::type is ::cudaExternalSemaphoreHandleTypeNvSciSync, then ::cudaExternalSemaphoreHandleDesc::handle::nvSciSyncObj represents a valid NvSciSyncObj. ::cudaExternalSemaphoreHandleTypeKeyedMutex, then exactly one of ::cudaExternalSemaphoreHandleDesc::handle::win32::handle and ::cudaExternalSemaphoreHandleDesc::handle::win32::name must not be NULL. If ::cudaExternalSemaphoreHandleDesc::handle::win32::handle is not NULL, then it represent a valid shared NT handle that is returned by IDXGIResource1::CreateSharedHandle when referring to a IDXGIKeyedMutex object. If ::cudaExternalSemaphoreHandleDesc::type is ::cudaExternalSemaphoreHandleTypeKeyedMutexKmt, then ::cudaExternalSemaphoreHandleDesc::handle::win32::handle must be non-NULL and ::cudaExternalSemaphoreHandleDesc::handle::win32::name must be NULL. The handle specified must represent a valid KMT handle that is returned by IDXGIResource::GetSharedHandle when referring to a IDXGIKeyedMutex object.
Parameters:

extSem_out - - Returned handle to an external semaphore

semHandleDesc - - Semaphore import handle descriptor

Returns:

::cudaSuccess, ::cudaErrorInvalidResourceHandle \notefnerr \note_init_rt \note_callback

cudaSignalExternalSemaphoresAsync
```
@Cast("cudaError_t")
public static int cudaSignalExternalSemaphoresAsync(@Cast("const cudaExternalSemaphore_t*") @ByPtrPtr
                                                    CUexternalSemaphore_st extSemArray,
                                                    @Const
                                                    cudaExternalSemaphoreSignalParams paramsArray,
                                                    @Cast("unsigned int")
                                                    int numExtSems,
                                                    CUstream_st stream)
```
\brief Signals a set of external semaphore objects Enqueues a signal operation on a set of externally allocated semaphore object in the specified stream. The operations will be executed when all prior operations in the stream complete. The exact semantics of signaling a semaphore depends on the type of the object. If the semaphore object is any one of the following types: ::cudaExternalSemaphoreHandleTypeOpaqueFd, ::cudaExternalSemaphoreHandleTypeOpaqueWin32, ::cudaExternalSemaphoreHandleTypeOpaqueWin32Kmt then signaling the semaphore will set it to the signaled state. If the semaphore object is any one of the following types: ::cudaExternalSemaphoreHandleTypeD3D12Fence, ::cudaExternalSemaphoreHandleTypeD3D11Fence then the semaphore will be set to the value specified in ::cudaExternalSemaphoreSignalParams::params::fence::value. If the semaphore object is of the type ::cudaExternalSemaphoreHandleTypeNvSciSync this API sets ::cudaExternalSemaphoreSignalParams::params::nvSciSync::fence to a value that can be used by subsequent waiters of the same NvSciSync object to order operations with those currently submitted in \p stream. Such an update will overwrite previous contents of ::cudaExternalSemaphoreSignalParams::params::nvSciSync::fence. By deefault, signaling such an external semaphore object causes appropriate memory synchronization operations to be performed over all the external memory objects that are imported as ::cudaExternalMemoryHandleTypeNvSciBuf. This ensures that any subsequent accesses made by other importers of the same set of NvSciBuf memory object(s) are coherent. These operations can be skipped by specifying the flag ::cudaExternalSemaphoreSignalSkipNvSciBufMemSync, which can be used as a performance optimization when data coherency is not required. But specifying this flag in scenarios where data coherency is required results in undefined behavior. Also, for semaphore object of the type ::cudaExternalSemaphoreHandleTypeNvSciSync, if the NvSciSyncAttrList used to create the NvSciSyncObj had not set the flags in ::cudaDeviceGetNvSciSyncAttributes to cudaNvSciSyncAttrSignal, this API will return cudaErrorNotSupported. If the semaphore object is any one of the following types: ::cudaExternalSemaphoreHandleTypeKeyedMutex, ::cudaExternalSemaphoreHandleTypeKeyedMutexKmt, then the keyed mutex will be released with the key specified in ::cudaExternalSemaphoreSignalParams::params::keyedmutex::key.

Parameters:

extSemArray - - Set of external semaphores to be signaled

paramsArray - - Array of semaphore parameters

numExtSems - - Number of semaphores to signal

stream - - Stream to enqueue the signal operations in

Returns:

::cudaSuccess, ::cudaErrorInvalidResourceHandle \notefnerr \note_init_rt \note_callback

cudaSignalExternalSemaphoresAsync

@Cast("cudaError_t")
public static int cudaSignalExternalSemaphoresAsync(@Cast("const cudaExternalSemaphore_t*") @ByPtrPtr
                                                    CUexternalSemaphore_st extSemArray,
                                                    @Const
                                                    cudaExternalSemaphoreSignalParams paramsArray,
                                                    @Cast("unsigned int")
                                                    int numExtSems)

cudaWaitExternalSemaphoresAsync
```
@Cast("cudaError_t")
public static int cudaWaitExternalSemaphoresAsync(@Cast("const cudaExternalSemaphore_t*") @ByPtrPtr
                                                  CUexternalSemaphore_st extSemArray,
                                                  @Const
                                                  cudaExternalSemaphoreWaitParams paramsArray,
                                                  @Cast("unsigned int")
                                                  int numExtSems,
                                                  CUstream_st stream)
```
\brief Waits on a set of external semaphore objects Enqueues a wait operation on a set of externally allocated semaphore object in the specified stream. The operations will be executed when all prior operations in the stream complete. The exact semantics of waiting on a semaphore depends on the type of the object. If the semaphore object is any one of the following types: ::cudaExternalSemaphoreHandleTypeOpaqueFd, ::cudaExternalSemaphoreHandleTypeOpaqueWin32, ::cudaExternalSemaphoreHandleTypeOpaqueWin32Kmt then waiting on the semaphore will wait until the semaphore reaches the signaled state. The semaphore will then be reset to the unsignaled state. Therefore for every signal operation, there can only be one wait operation. If the semaphore object is any one of the following types: ::cudaExternalSemaphoreHandleTypeD3D12Fence, ::cudaExternalSemaphoreHandleTypeD3D11Fence then waiting on the semaphore will wait until the value of the semaphore is greater than or equal to ::cudaExternalSemaphoreWaitParams::params::fence::value. If the semaphore object is of the type ::cudaExternalSemaphoreHandleTypeNvSciSync then, waiting on the semaphore will wait until the ::cudaExternalSemaphoreSignalParams::params::nvSciSync::fence is signaled by the signaler of the NvSciSyncObj that was associated with this semaphore object. By default, waiting on such an external semaphore object causes appropriate memory synchronization operations to be performed over all external memory objects that are imported as ::cudaExternalMemoryHandleTypeNvSciBuf. This ensures that any subsequent accesses made by other importers of the same set of NvSciBuf memory object(s) are coherent. These operations can be skipped by specifying the flag ::cudaExternalSemaphoreWaitSkipNvSciBufMemSync, which can be used as a performance optimization when data coherency is not required. But specifying this flag in scenarios where data coherency is required results in undefined behavior. Also, for semaphore object of the type ::cudaExternalSemaphoreHandleTypeNvSciSync, if the NvSciSyncAttrList used to create the NvSciSyncObj had not set the flags in ::cudaDeviceGetNvSciSyncAttributes to cudaNvSciSyncAttrWait, this API will return cudaErrorNotSupported. If the semaphore object is any one of the following types: ::cudaExternalSemaphoreHandleTypeKeyedMutex, ::cudaExternalSemaphoreHandleTypeKeyedMutexKmt, then the keyed mutex will be acquired when it is released with the key specified in ::cudaExternalSemaphoreSignalParams::params::keyedmutex::key or until the timeout specified by ::cudaExternalSemaphoreSignalParams::params::keyedmutex::timeoutMs has lapsed. The timeout interval can either be a finite value specified in milliseconds or an infinite value. In case an infinite value is specified the timeout never elapses. The windows INFINITE macro must be used to specify infinite timeout

Parameters:

extSemArray - - External semaphores to be waited on

paramsArray - - Array of semaphore parameters

numExtSems - - Number of semaphores to wait on

stream - - Stream to enqueue the wait operations in

Returns:

::cudaSuccess, ::cudaErrorInvalidResourceHandle ::cudaErrorTimeout \notefnerr \note_init_rt \note_callback

cudaWaitExternalSemaphoresAsync

@Cast("cudaError_t")
public static int cudaWaitExternalSemaphoresAsync(@Cast("const cudaExternalSemaphore_t*") @ByPtrPtr
                                                  CUexternalSemaphore_st extSemArray,
                                                  @Const
                                                  cudaExternalSemaphoreWaitParams paramsArray,
                                                  @Cast("unsigned int")
                                                  int numExtSems)

cudaDestroyExternalSemaphore
```
@Cast("cudaError_t")
public static int cudaDestroyExternalSemaphore(CUexternalSemaphore_st extSem)
```
\brief Destroys an external semaphore Destroys an external semaphore object and releases any references to the underlying resource. Any outstanding signals or waits must have completed before the semaphore is destroyed.

Parameters:

extSem - - External semaphore to be destroyed

Returns:

::cudaSuccess, ::cudaErrorInvalidResourceHandle \notefnerr \note_init_rt \note_callback

cudaLaunchKernel
```
@Cast("cudaError_t")
public static int cudaLaunchKernel(@Const
                                   Pointer func,
                                   @ByVal
                                   dim3 gridDim,
                                   @ByVal
                                   dim3 blockDim,
                                   @Cast("void**")
                                   PointerPointer args,
                                   @Cast("size_t")
                                   long sharedMem,
                                   CUstream_st stream)
```
\brief Launches a device function The function invokes kernel \p func on \p gridDim (\p gridDim.x × \p gridDim.y × \p gridDim.z) grid of blocks. Each block contains \p blockDim (\p blockDim.x × \p blockDim.y × \p blockDim.z) threads. If the kernel has N parameters the \p args should point to array of N pointers. Each pointer, from args[0] to args[N - 1], point to the region of memory from which the actual parameter will be copied. For templated functions, pass the function symbol as follows: func_name \p sharedMem sets the amount of dynamic shared memory that will be available to each thread block. \p stream specifies a stream the invocation is associated to.

Parameters:

func - - Device function symbol

gridDim - - Grid dimentions

blockDim - - Block dimentions

args - - Arguments

sharedMem - - Shared memory

stream - - Stream identifier

Returns:

::cudaSuccess, ::cudaErrorInvalidDeviceFunction, ::cudaErrorInvalidConfiguration, ::cudaErrorLaunchFailure, ::cudaErrorLaunchTimeout, ::cudaErrorLaunchOutOfResources, ::cudaErrorSharedObjectInitFailed, ::cudaErrorInvalidPtx, ::cudaErrorNoKernelImageForDevice, ::cudaErrorJitCompilerNotFound \note_null_stream \notefnerr \note_init_rt \note_callback

cudaLaunchKernel

@Cast("cudaError_t")
public static int cudaLaunchKernel(@Const
                                   Pointer func,
                                   @ByVal
                                   dim3 gridDim,
                                   @ByVal
                                   dim3 blockDim,
                                   @Cast("void**") @ByPtrPtr
                                   Pointer args,
                                   @Cast("size_t")
                                   long sharedMem,
                                   CUstream_st stream)

cudaLaunchCooperativeKernel
```
@Cast("cudaError_t")
public static int cudaLaunchCooperativeKernel(@Const
                                              Pointer func,
                                              @ByVal
                                              dim3 gridDim,
                                              @ByVal
                                              dim3 blockDim,
                                              @Cast("void**")
                                              PointerPointer args,
                                              @Cast("size_t")
                                              long sharedMem,
                                              CUstream_st stream)
```
\brief Launches a device function where thread blocks can cooperate and synchronize as they execute The function invokes kernel \p func on \p gridDim (\p gridDim.x × \p gridDim.y × \p gridDim.z) grid of blocks. Each block contains \p blockDim (\p blockDim.x × \p blockDim.y × \p blockDim.z) threads. The device on which this kernel is invoked must have a non-zero value for the device attribute ::cudaDevAttrCooperativeLaunch. The total number of blocks launched cannot exceed the maximum number of blocks per multiprocessor as returned by ::cudaOccupancyMaxActiveBlocksPerMultiprocessor (or ::cudaOccupancyMaxActiveBlocksPerMultiprocessorWithFlags) times the number of multiprocessors as specified by the device attribute ::cudaDevAttrMultiProcessorCount. The kernel cannot make use of CUDA dynamic parallelism. If the kernel has N parameters the \p args should point to array of N pointers. Each pointer, from args[0] to args[N - 1], point to the region of memory from which the actual parameter will be copied. For templated functions, pass the function symbol as follows: func_name \p sharedMem sets the amount of dynamic shared memory that will be available to each thread block. \p stream specifies a stream the invocation is associated to.

Parameters:

func - - Device function symbol

gridDim - - Grid dimentions

blockDim - - Block dimentions

args - - Arguments

sharedMem - - Shared memory

stream - - Stream identifier

Returns:

::cudaSuccess, ::cudaErrorInvalidDeviceFunction, ::cudaErrorInvalidConfiguration, ::cudaErrorLaunchFailure, ::cudaErrorLaunchTimeout, ::cudaErrorLaunchOutOfResources, ::cudaErrorCooperativeLaunchTooLarge, ::cudaErrorSharedObjectInitFailed \note_null_stream \notefnerr \note_init_rt \note_callback

cudaLaunchCooperativeKernel

@Cast("cudaError_t")
public static int cudaLaunchCooperativeKernel(@Const
                                              Pointer func,
                                              @ByVal
                                              dim3 gridDim,
                                              @ByVal
                                              dim3 blockDim,
                                              @Cast("void**") @ByPtrPtr
                                              Pointer args,
                                              @Cast("size_t")
                                              long sharedMem,
                                              CUstream_st stream)

cudaLaunchCooperativeKernelMultiDevice
```
@Cast("cudaError_t")
public static int cudaLaunchCooperativeKernelMultiDevice(cudaLaunchParams launchParamsList,
                                                         @Cast("unsigned int")
                                                         int numDevices,
                                                         @Cast("unsigned int")
                                                         int flags)
```
\brief Launches device functions on multiple devices where thread blocks can cooperate and synchronize as they execute Invokes kernels as specified in the \p launchParamsList array where each element of the array specifies all the parameters required to perform a single kernel launch. These kernels can cooperate and synchronize as they execute. The size of the array is specified by \p numDevices. No two kernels can be launched on the same device. All the devices targeted by this multi-device launch must be identical. All devices must have a non-zero value for the device attribute ::cudaDevAttrCooperativeMultiDeviceLaunch. The same kernel must be launched on all devices. Note that any __device__ or __constant__ variables are independently instantiated on every device. It is the application's responsiblity to ensure these variables are initialized and used appropriately. The size of the grids as specified in blocks, the size of the blocks themselves and the amount of shared memory used by each thread block must also match across all launched kernels. The streams used to launch these kernels must have been created via either ::cudaStreamCreate or ::cudaStreamCreateWithPriority or ::cudaStreamCreateWithPriority. The NULL stream or ::cudaStreamLegacy or ::cudaStreamPerThread cannot be used. The total number of blocks launched per kernel cannot exceed the maximum number of blocks per multiprocessor as returned by ::cudaOccupancyMaxActiveBlocksPerMultiprocessor (or ::cudaOccupancyMaxActiveBlocksPerMultiprocessorWithFlags) times the number of multiprocessors as specified by the device attribute ::cudaDevAttrMultiProcessorCount. Since the total number of blocks launched per device has to match across all devices, the maximum number of blocks that can be launched per device will be limited by the device with the least number of multiprocessors. The kernel cannot make use of CUDA dynamic parallelism. The ::cudaLaunchParams structure is defined as:
```
        struct cudaLaunchParams
        {
            void *func;
            dim3 gridDim;
            dim3 blockDim;
            void **args;
            size_t sharedMem;
            cudaStream_t stream;
        };
 
```
where: - ::cudaLaunchParams::func specifies the kernel to be launched. This same functions must be launched on all devices. For templated functions, pass the function symbol as follows: func_name - ::cudaLaunchParams::gridDim specifies the width, height and depth of the grid in blocks. This must match across all kernels launched. - ::cudaLaunchParams::blockDim is the width, height and depth of each thread block. This must match across all kernels launched. - ::cudaLaunchParams::args specifies the arguments to the kernel. If the kernel has N parameters then ::cudaLaunchParams::args should point to array of N pointers. Each pointer, from ::cudaLaunchParams::args[0] to ::cudaLaunchParams::args[N - 1], point to the region of memory from which the actual parameter will be copied. - ::cudaLaunchParams::sharedMem is the dynamic shared-memory size per thread block in bytes. This must match across all kernels launched. - ::cudaLaunchParams::stream is the handle to the stream to perform the launch in. This cannot be the NULL stream or ::cudaStreamLegacy or ::cudaStreamPerThread. By default, the kernel won't begin execution on any GPU until all prior work in all the specified streams has completed. This behavior can be overridden by specifying the flag ::cudaCooperativeLaunchMultiDeviceNoPreSync. When this flag is specified, each kernel will only wait for prior work in the stream corresponding to that GPU to complete before it begins execution. Similarly, by default, any subsequent work pushed in any of the specified streams will not begin execution until the kernels on all GPUs have completed. This behavior can be overridden by specifying the flag ::cudaCooperativeLaunchMultiDeviceNoPostSync. When this flag is specified, any subsequent work pushed in any of the specified streams will only wait for the kernel launched on the GPU corresponding to that stream to complete before it begins execution.
Parameters:

launchParamsList - - List of launch parameters, one per device

numDevices - - Size of the \p launchParamsList array

flags - - Flags to control launch behavior

Returns:

::cudaSuccess, ::cudaErrorInvalidDeviceFunction, ::cudaErrorInvalidConfiguration, ::cudaErrorLaunchFailure, ::cudaErrorLaunchTimeout, ::cudaErrorLaunchOutOfResources, ::cudaErrorCooperativeLaunchTooLarge, ::cudaErrorSharedObjectInitFailed \note_null_stream \notefnerr \note_init_rt \note_callback

cudaLaunchCooperativeKernelMultiDevice

@Cast("cudaError_t")
public static int cudaLaunchCooperativeKernelMultiDevice(cudaLaunchParams launchParamsList,
                                                         @Cast("unsigned int")
                                                         int numDevices)

cudaFuncSetCacheConfig
```
@Cast("cudaError_t")
public static int cudaFuncSetCacheConfig(@Const
                                         Pointer func,
                                         @Cast("cudaFuncCache")
                                         int cacheConfig)
```
\brief Sets the preferred cache configuration for a device function On devices where the L1 cache and shared memory use the same hardware resources, this sets through \p cacheConfig the preferred cache configuration for the function specified via \p func. This is only a preference. The runtime will use the requested configuration if possible, but it is free to choose a different configuration if required to execute \p func. \p func is a device function symbol and must be declared as a \c __global__ function. If the specified function does not exist, then ::cudaErrorInvalidDeviceFunction is returned. For templated functions, pass the function symbol as follows: func_name This setting does nothing on devices where the size of the L1 cache and shared memory are fixed. Launching a kernel with a different preference than the most recent preference setting may insert a device-side synchronization point. The supported cache configurations are: - ::cudaFuncCachePreferNone: no preference for shared memory or L1 (default) - ::cudaFuncCachePreferShared: prefer larger shared memory and smaller L1 cache - ::cudaFuncCachePreferL1: prefer larger L1 cache and smaller shared memory - ::cudaFuncCachePreferEqual: prefer equal size L1 cache and shared memory

Parameters:

func - - Device function symbol

cacheConfig - - Requested cache configuration

Returns:

::cudaSuccess, ::cudaErrorInvalidDeviceFunction \notefnerr \note_string_api_deprecation2 \note_init_rt \note_callback

cudaFuncSetSharedMemConfig
```
@Cast("cudaError_t")
public static int cudaFuncSetSharedMemConfig(@Const
                                             Pointer func,
                                             @Cast("cudaSharedMemConfig")
                                             int config)
```
\brief Sets the shared memory configuration for a device function On devices with configurable shared memory banks, this function will force all subsequent launches of the specified device function to have the given shared memory bank size configuration. On any given launch of the function, the shared memory configuration of the device will be temporarily changed if needed to suit the function's preferred configuration. Changes in shared memory configuration between subsequent launches of functions, may introduce a device side synchronization point. Any per-function setting of shared memory bank size set via ::cudaFuncSetSharedMemConfig will override the device wide setting set by ::cudaDeviceSetSharedMemConfig. Changing the shared memory bank size will not increase shared memory usage or affect occupancy of kernels, but may have major effects on performance. Larger bank sizes will allow for greater potential bandwidth to shared memory, but will change what kinds of accesses to shared memory will result in bank conflicts. This function will do nothing on devices with fixed shared memory bank size. For templated functions, pass the function symbol as follows: func_name The supported bank configurations are: - ::cudaSharedMemBankSizeDefault: use the device's shared memory configuration when launching this function. - ::cudaSharedMemBankSizeFourByte: set shared memory bank width to be four bytes natively when launching this function. - ::cudaSharedMemBankSizeEightByte: set shared memory bank width to be eight bytes natively when launching this function.

Parameters:

func - - Device function symbol

config - - Requested shared memory configuration

Returns:

::cudaSuccess, ::cudaErrorInvalidDeviceFunction, ::cudaErrorInvalidValue, \notefnerr \note_string_api_deprecation2 \note_init_rt \note_callback

cudaFuncGetAttributes
```
@Cast("cudaError_t")
public static int cudaFuncGetAttributes(cudaFuncAttributes attr,
                                        @Const
                                        Pointer func)
```
\brief Find out attributes for a given function This function obtains the attributes of a function specified via \p func. \p func is a device function symbol and must be declared as a \c __global__ function. The fetched attributes are placed in \p attr. If the specified function does not exist, then ::cudaErrorInvalidDeviceFunction is returned. For templated functions, pass the function symbol as follows: func_name Note that some function attributes such as \ref ::cudaFuncAttributes::maxThreadsPerBlock "maxThreadsPerBlock" may vary based on the device that is currently being used.

Parameters:

attr - - Return pointer to function's attributes

func - - Device function symbol

Returns:

::cudaSuccess, ::cudaErrorInvalidDeviceFunction \notefnerr \note_string_api_deprecation2 \note_init_rt \note_callback

cudaFuncSetAttribute
```
@Cast("cudaError_t")
public static int cudaFuncSetAttribute(@Const
                                       Pointer func,
                                       @Cast("cudaFuncAttribute")
                                       int attr,
                                       int value)
```
\brief Set attributes for a given function This function sets the attributes of a function specified via \p func. The parameter \p func must be a pointer to a function that executes on the device. The parameter specified by \p func must be declared as a \p __global__ function. The enumeration defined by \p attr is set to the value defined by \p value. If the specified function does not exist, then ::cudaErrorInvalidDeviceFunction is returned. If the specified attribute cannot be written, or if the value is incorrect, then ::cudaErrorInvalidValue is returned. Valid values for \p attr are: - ::cudaFuncAttributeMaxDynamicSharedMemorySize - The requested maximum size in bytes of dynamically-allocated shared memory. The sum of this value and the function attribute ::sharedSizeBytes cannot exceed the device attribute ::cudaDevAttrMaxSharedMemoryPerBlockOptin. The maximal size of requestable dynamic shared memory may differ by GPU architecture. - ::cudaFuncAttributePreferredSharedMemoryCarveout - On devices where the L1 cache and shared memory use the same hardware resources, this sets the shared memory carveout preference, in percent of the total shared memory. See ::cudaDevAttrMaxSharedMemoryPerMultiprocessor. This is only a hint, and the driver can choose a different ratio if required to execute the function.

Parameters:

func - - Function to get attributes of

attr - - Attribute to set

value - - Value to set

Returns:

::cudaSuccess, ::cudaErrorInvalidDeviceFunction, ::cudaErrorInvalidValue \notefnerr \note_init_rt \note_callback \ref ::cudaLaunchKernel(const T *func, dim3 gridDim, dim3 blockDim, void **args, size_t sharedMem, cudaStream_t stream) "cudaLaunchKernel (C++ API)", \ref ::cudaFuncSetCacheConfig(T*, enum cudaFuncCache) "cudaFuncSetCacheConfig (C++ API)", \ref ::cudaFuncGetAttributes(struct cudaFuncAttributes*, const void*) "cudaFuncGetAttributes (C API)", ::cudaSetDoubleForDevice, ::cudaSetDoubleForHost

cudaSetDoubleForDevice
```
@Cast("cudaError_t")
@Deprecated
public static int cudaSetDoubleForDevice(DoublePointer d)
```
Deprecated.
This function is deprecated as of CUDA 7.5 Converts the double value of \p d to an internal float representation if the device does not support double arithmetic. If the device does natively support doubles, then this function does nothing.

\brief Converts a double argument to be executed on a device

Parameters:

d - - Double to convert

Returns:

::cudaSuccess \notefnerr \note_init_rt \note_callback

cudaSetDoubleForDevice

@Cast("cudaError_t")
@Deprecated
public static int cudaSetDoubleForDevice(DoubleBuffer d)

Deprecated.

cudaSetDoubleForDevice

@Cast("cudaError_t")
@Deprecated
public static int cudaSetDoubleForDevice(double[] d)

Deprecated.

cudaSetDoubleForHost
```
@Cast("cudaError_t")
@Deprecated
public static int cudaSetDoubleForHost(DoublePointer d)
```
Deprecated.
This function is deprecated as of CUDA 7.5 Converts the double value of \p d from a potentially internal float representation if the device does not support double arithmetic. If the device does natively support doubles, then this function does nothing.

\brief Converts a double argument after execution on a device

Parameters:

d - - Double to convert

Returns:

::cudaSuccess \notefnerr \note_init_rt \note_callback

cudaSetDoubleForHost

@Cast("cudaError_t")
@Deprecated
public static int cudaSetDoubleForHost(DoubleBuffer d)

Deprecated.

cudaSetDoubleForHost

@Cast("cudaError_t")
@Deprecated
public static int cudaSetDoubleForHost(double[] d)

Deprecated.

cudaLaunchHostFunc
```
@Cast("cudaError_t")
public static int cudaLaunchHostFunc(CUstream_st stream,
                                     cudaHostFn_t fn,
                                     Pointer userData)
```
\brief Enqueues a host function call in a stream Enqueues a host function to run in a stream. The function will be called after currently enqueued work and will block work added after it. The host function must not make any CUDA API calls. Attempting to use a CUDA API may result in ::cudaErrorNotPermitted, but this is not required. The host function must not perform any synchronization that may depend on outstanding CUDA work not mandated to run earlier. Host functions without a mandated order (such as in independent streams) execute in undefined order and may be serialized. For the purposes of Unified Memory, execution makes a number of guarantees:
- The stream is considered idle for the duration of the function's execution. Thus, for example, the function may always use memory attached to the stream it was enqueued in.
- The start of execution of the function has the same effect as synchronizing an event recorded in the same stream immediately prior to the function. It thus synchronizes streams which have been "joined" prior to the function.
- Adding device work to any stream does not have the effect of making the stream active until all preceding host functions and stream callbacks have executed. Thus, for example, a function might use global attached memory even if work has been added to another stream, if the work has been ordered behind the function call with an event.
- Completion of the function does not cause a stream to become active except as described above. The stream will remain idle if no device work follows the function, and will remain idle across consecutive host functions or stream callbacks without device work in between. Thus, for example, stream synchronization can be done by signaling from a host function at the end of the stream.
Note that, in constrast to ::cuStreamAddCallback, the function will not be called in the event of an error in the CUDA context.
Parameters:

hStream - - Stream to enqueue function call in

fn - - The function to call once preceding stream operations are complete

userData - - User-specified data to be passed to the function

Returns:

::cudaSuccess, ::cudaErrorInvalidResourceHandle, ::cudaErrorInvalidValue, ::cudaErrorNotSupported \note_null_stream \notefnerr \note_init_rt \note_callback

cudaOccupancyMaxActiveBlocksPerMultiprocessor

@Cast("cudaError_t")
public static int cudaOccupancyMaxActiveBlocksPerMultiprocessor(IntPointer numBlocks,
                                                                @Const
                                                                Pointer func,
                                                                int blockSize,
                                                                @Cast("size_t")
                                                                long dynamicSMemSize)

\brief Returns occupancy for a device function Returns in \p *numBlocks the maximum number of active blocks per streaming multiprocessor for the device function.

Parameters:: numBlocks - - Returned occupancy; func - - Kernel function for which occupancy is calculated; blockSize - - Block size the kernel is intended to be launched with; dynamicSMemSize - - Per-block dynamic shared memory usage intended, in bytes
Returns:: ::cudaSuccess, ::cudaErrorInvalidDevice, ::cudaErrorInvalidDeviceFunction, ::cudaErrorInvalidValue, ::cudaErrorUnknown, \notefnerr \note_init_rt \note_callback

cudaOccupancyMaxActiveBlocksPerMultiprocessor

@Cast("cudaError_t")
public static int cudaOccupancyMaxActiveBlocksPerMultiprocessor(IntBuffer numBlocks,
                                                                @Const
                                                                Pointer func,
                                                                int blockSize,
                                                                @Cast("size_t")
                                                                long dynamicSMemSize)

cudaOccupancyMaxActiveBlocksPerMultiprocessor

@Cast("cudaError_t")
public static int cudaOccupancyMaxActiveBlocksPerMultiprocessor(int[] numBlocks,
                                                                @Const
                                                                Pointer func,
                                                                int blockSize,
                                                                @Cast("size_t")
                                                                long dynamicSMemSize)

cudaOccupancyMaxActiveBlocksPerMultiprocessorWithFlags
```
@Cast("cudaError_t")
public static int cudaOccupancyMaxActiveBlocksPerMultiprocessorWithFlags(IntPointer numBlocks,
                                                                         @Const
                                                                         Pointer func,
                                                                         int blockSize,
                                                                         @Cast("size_t")
                                                                         long dynamicSMemSize,
                                                                         @Cast("unsigned int")
                                                                         int flags)
```
\brief Returns occupancy for a device function with the specified flags Returns in \p *numBlocks the maximum number of active blocks per streaming multiprocessor for the device function. The \p flags parameter controls how special cases are handled. Valid flags include: - ::cudaOccupancyDefault: keeps the default behavior as ::cudaOccupancyMaxActiveBlocksPerMultiprocessor - ::cudaOccupancyDisableCachingOverride: This flag suppresses the default behavior on platform where global caching affects occupancy. On such platforms, if caching is enabled, but per-block SM resource usage would result in zero occupancy, the occupancy calculator will calculate the occupancy as if caching is disabled. Setting this flag makes the occupancy calculator to return 0 in such cases. More information can be found about this feature in the "Unified L1/Texture Cache" section of the Maxwell tuning guide.

Parameters:

numBlocks - - Returned occupancy

func - - Kernel function for which occupancy is calculated

blockSize - - Block size the kernel is intended to be launched with

dynamicSMemSize - - Per-block dynamic shared memory usage intended, in bytes

flags - - Requested behavior for the occupancy calculator

Returns:

::cudaSuccess, ::cudaErrorInvalidDevice, ::cudaErrorInvalidDeviceFunction, ::cudaErrorInvalidValue, ::cudaErrorUnknown, \notefnerr \note_init_rt \note_callback

cudaOccupancyMaxActiveBlocksPerMultiprocessorWithFlags

@Cast("cudaError_t")
public static int cudaOccupancyMaxActiveBlocksPerMultiprocessorWithFlags(IntBuffer numBlocks,
                                                                         @Const
                                                                         Pointer func,
                                                                         int blockSize,
                                                                         @Cast("size_t")
                                                                         long dynamicSMemSize,
                                                                         @Cast("unsigned int")
                                                                         int flags)

cudaOccupancyMaxActiveBlocksPerMultiprocessorWithFlags

@Cast("cudaError_t")
public static int cudaOccupancyMaxActiveBlocksPerMultiprocessorWithFlags(int[] numBlocks,
                                                                         @Const
                                                                         Pointer func,
                                                                         int blockSize,
                                                                         @Cast("size_t")
                                                                         long dynamicSMemSize,
                                                                         @Cast("unsigned int")
                                                                         int flags)

cudaMallocManaged
```
@Cast("cudaError_t")
public static int cudaMallocManaged(@Cast("void**")
                                    PointerPointer devPtr,
                                    @Cast("size_t")
                                    long size,
                                    @Cast("unsigned int")
                                    int flags)
```
\brief Allocates memory that will be automatically managed by the Unified Memory system Allocates \p size bytes of managed memory on the device and returns in \p *devPtr a pointer to the allocated memory. If the device doesn't support allocating managed memory, ::cudaErrorNotSupported is returned. Support for managed memory can be queried using the device attribute ::cudaDevAttrManagedMemory. The allocated memory is suitably aligned for any kind of variable. The memory is not cleared. If \p size is 0, ::cudaMallocManaged returns ::cudaErrorInvalidValue. The pointer is valid on the CPU and on all GPUs in the system that support managed memory. All accesses to this pointer must obey the Unified Memory programming model. \p flags specifies the default stream association for this allocation. \p flags must be one of ::cudaMemAttachGlobal or ::cudaMemAttachHost. The default value for \p flags is ::cudaMemAttachGlobal. If ::cudaMemAttachGlobal is specified, then this memory is accessible from any stream on any device. If ::cudaMemAttachHost is specified, then the allocation should not be accessed from devices that have a zero value for the device attribute ::cudaDevAttrConcurrentManagedAccess; an explicit call to ::cudaStreamAttachMemAsync will be required to enable access on such devices. If the association is later changed via ::cudaStreamAttachMemAsync to a single stream, the default association, as specifed during ::cudaMallocManaged, is restored when that stream is destroyed. For __managed__ variables, the default association is always ::cudaMemAttachGlobal. Note that destroying a stream is an asynchronous operation, and as a result, the change to default association won't happen until all work in the stream has completed. Memory allocated with ::cudaMallocManaged should be released with ::cudaFree. Device memory oversubscription is possible for GPUs that have a non-zero value for the device attribute ::cudaDevAttrConcurrentManagedAccess. Managed memory on such GPUs may be evicted from device memory to host memory at any time by the Unified Memory driver in order to make room for other allocations. In a multi-GPU system where all GPUs have a non-zero value for the device attribute ::cudaDevAttrConcurrentManagedAccess, managed memory may not be populated when this API returns and instead may be populated on access. In such systems, managed memory can migrate to any processor's memory at any time. The Unified Memory driver will employ heuristics to maintain data locality and prevent excessive page faults to the extent possible. The application can also guide the driver about memory usage patterns via ::cudaMemAdvise. The application can also explicitly migrate memory to a desired processor's memory via ::cudaMemPrefetchAsync. In a multi-GPU system where all of the GPUs have a zero value for the device attribute ::cudaDevAttrConcurrentManagedAccess and all the GPUs have peer-to-peer support with each other, the physical storage for managed memory is created on the GPU which is active at the time ::cudaMallocManaged is called. All other GPUs will reference the data at reduced bandwidth via peer mappings over the PCIe bus. The Unified Memory driver does not migrate memory among such GPUs. In a multi-GPU system where not all GPUs have peer-to-peer support with each other and where the value of the device attribute ::cudaDevAttrConcurrentManagedAccess is zero for at least one of those GPUs, the location chosen for physical storage of managed memory is system-dependent. - On Linux, the location chosen will be device memory as long as the current set of active contexts are on devices that either have peer-to-peer support with each other or have a non-zero value for the device attribute ::cudaDevAttrConcurrentManagedAccess. If there is an active context on a GPU that does not have a non-zero value for that device attribute and it does not have peer-to-peer support with the other devices that have active contexts on them, then the location for physical storage will be 'zero-copy' or host memory. Note that this means that managed memory that is located in device memory is migrated to host memory if a new context is created on a GPU that doesn't have a non-zero value for the device attribute and does not support peer-to-peer with at least one of the other devices that has an active context. This in turn implies that context creation may fail if there is insufficient host memory to migrate all managed allocations. - On Windows, the physical storage is always created in 'zero-copy' or host memory. All GPUs will reference the data at reduced bandwidth over the PCIe bus. In these circumstances, use of the environment variable CUDA_VISIBLE_DEVICES is recommended to restrict CUDA to only use those GPUs that have peer-to-peer support. Alternatively, users can also set CUDA_MANAGED_FORCE_DEVICE_ALLOC to a non-zero value to force the driver to always use device memory for physical storage. When this environment variable is set to a non-zero value, all devices used in that process that support managed memory have to be peer-to-peer compatible with each other. The error ::cudaErrorInvalidDevice will be returned if a device that supports managed memory is used and it is not peer-to-peer compatible with any of the other managed memory supporting devices that were previously used in that process, even if ::cudaDeviceReset has been called on those devices. These environment variables are described in the CUDA programming guide under the "CUDA environment variables" section.

Parameters:

devPtr - - Pointer to allocated device memory

size - - Requested allocation size in bytes

flags - - Must be either ::cudaMemAttachGlobal or ::cudaMemAttachHost (defaults to ::cudaMemAttachGlobal)

Returns:

::cudaSuccess, ::cudaErrorMemoryAllocation, ::cudaErrorNotSupported, ::cudaErrorInvalidValue \notefnerr \note_init_rt \note_callback

cudaMallocManaged

@Cast("cudaError_t")
public static int cudaMallocManaged(@Cast("void**") @ByPtrPtr
                                    Pointer devPtr,
                                    @Cast("size_t")
                                    long size)

cudaMallocManaged

@Cast("cudaError_t")
public static int cudaMallocManaged(@Cast("void**") @ByPtrPtr
                                    Pointer devPtr,
                                    @Cast("size_t")
                                    long size,
                                    @Cast("unsigned int")
                                    int flags)

cudaMalloc
```
@Cast("cudaError_t")
public static int cudaMalloc(@Cast("void**")
                             PointerPointer devPtr,
                             @Cast("size_t")
                             long size)
```
\brief Allocate memory on the device Allocates \p size bytes of linear memory on the device and returns in \p *devPtr a pointer to the allocated memory. The allocated memory is suitably aligned for any kind of variable. The memory is not cleared. ::cudaMalloc() returns ::cudaErrorMemoryAllocation in case of failure. The device version of ::cudaFree cannot be used with a \p *devPtr allocated using the host API, and vice versa.

Parameters:

devPtr - - Pointer to allocated device memory

size - - Requested allocation size in bytes

Returns:

::cudaSuccess, ::cudaErrorInvalidValue, ::cudaErrorMemoryAllocation \notefnerr \note_init_rt \note_callback

cudaMalloc

@Cast("cudaError_t")
public static int cudaMalloc(@Cast("void**") @ByPtrPtr
                             Pointer devPtr,
                             @Cast("size_t")
                             long size)

cudaMallocHost
```
@Cast("cudaError_t")
public static int cudaMallocHost(@Cast("void**")
                                 PointerPointer ptr,
                                 @Cast("size_t")
                                 long size)
```
\brief Allocates page-locked memory on the host Allocates \p size bytes of host memory that is page-locked and accessible to the device. The driver tracks the virtual memory ranges allocated with this function and automatically accelerates calls to functions such as ::cudaMemcpy*(). Since the memory can be accessed directly by the device, it can be read or written with much higher bandwidth than pageable memory obtained with functions such as ::malloc(). Allocating excessive amounts of memory with ::cudaMallocHost() may degrade system performance, since it reduces the amount of memory available to the system for paging. As a result, this function is best used sparingly to allocate staging areas for data exchange between host and device.

Parameters:

ptr - - Pointer to allocated host memory

size - - Requested allocation size in bytes

Returns:

::cudaSuccess, ::cudaErrorInvalidValue, ::cudaErrorMemoryAllocation \notefnerr \note_init_rt \note_callback

cudaMallocHost

@Cast("cudaError_t")
public static int cudaMallocHost(@Cast("void**") @ByPtrPtr
                                 Pointer ptr,
                                 @Cast("size_t")
                                 long size)

cudaMallocPitch
```
@Cast("cudaError_t")
public static int cudaMallocPitch(@Cast("void**")
                                  PointerPointer devPtr,
                                  @Cast("size_t*")
                                  SizeTPointer pitch,
                                  @Cast("size_t")
                                  long width,
                                  @Cast("size_t")
                                  long height)
```
\brief Allocates pitched memory on the device Allocates at least \p width (in bytes) * \p height bytes of linear memory on the device and returns in \p *devPtr a pointer to the allocated memory. The function may pad the allocation to ensure that corresponding pointers in any given row will continue to meet the alignment requirements for coalescing as the address is updated from row to row. The pitch returned in \p *pitch by ::cudaMallocPitch() is the width in bytes of the allocation. The intended usage of \p pitch is as a separate parameter of the allocation, used to compute addresses within the 2D array. Given the row and column of an array element of type \p T, the address is computed as:
```
    T* pElement = (T*)((char*)BaseAddress + Row * pitch) + Column;
   
```
For allocations of 2D arrays, it is recommended that programmers consider performing pitch allocations using ::cudaMallocPitch(). Due to pitch alignment restrictions in the hardware, this is especially true if the application will be performing 2D memory copies between different regions of device memory (whether linear memory or CUDA arrays).
Parameters:

devPtr - - Pointer to allocated pitched device memory

pitch - - Pitch for allocation

width - - Requested pitched allocation width (in bytes)

height - - Requested pitched allocation height

Returns:

::cudaSuccess, ::cudaErrorInvalidValue, ::cudaErrorMemoryAllocation \notefnerr \note_init_rt \note_callback

cudaMallocPitch

@Cast("cudaError_t")
public static int cudaMallocPitch(@Cast("void**") @ByPtrPtr
                                  Pointer devPtr,
                                  @Cast("size_t*")
                                  SizeTPointer pitch,
                                  @Cast("size_t")
                                  long width,
                                  @Cast("size_t")
                                  long height)

cudaMallocArray
```
@Cast("cudaError_t")
public static int cudaMallocArray(@ByPtrPtr
                                  cudaArray array,
                                  @Const
                                  cudaChannelFormatDesc desc,
                                  @Cast("size_t")
                                  long width,
                                  @Cast("size_t")
                                  long height,
                                  @Cast("unsigned int")
                                  int flags)
```
\brief Allocate an array on the device Allocates a CUDA array according to the ::cudaChannelFormatDesc structure \p desc and returns a handle to the new CUDA array in \p *array. The ::cudaChannelFormatDesc is defined as:
```
    struct cudaChannelFormatDesc {
        int x, y, z, w;
    enum cudaChannelFormatKind f;
    };
    
```
where ::cudaChannelFormatKind is one of ::cudaChannelFormatKindSigned, ::cudaChannelFormatKindUnsigned, or ::cudaChannelFormatKindFloat. The \p flags parameter enables different options to be specified that affect the allocation, as follows. - ::cudaArrayDefault: This flag's value is defined to be 0 and provides default array allocation - ::cudaArraySurfaceLoadStore: Allocates an array that can be read from or written to using a surface reference - ::cudaArrayTextureGather: This flag indicates that texture gather operations will be performed on the array. \p width and \p height must meet certain size requirements. See ::cudaMalloc3DArray() for more details.
Parameters:

array - - Pointer to allocated array in device memory

desc - - Requested channel format

width - - Requested array allocation width

height - - Requested array allocation height

flags - - Requested properties of allocated array

Returns:

::cudaSuccess, ::cudaErrorInvalidValue, ::cudaErrorMemoryAllocation \notefnerr \note_init_rt \note_callback

cudaMallocArray

@Cast("cudaError_t")
public static int cudaMallocArray(@ByPtrPtr
                                  cudaArray array,
                                  @Const
                                  cudaChannelFormatDesc desc,
                                  @Cast("size_t")
                                  long width)

cudaFree
```
@Cast("cudaError_t")
public static int cudaFree(Pointer devPtr)
```
\brief Frees memory on the device Frees the memory space pointed to by \p devPtr, which must have been returned by a previous call to ::cudaMalloc() or ::cudaMallocPitch(). Otherwise, or if ::cudaFree(\p devPtr) has already been called before, an error is returned. If \p devPtr is 0, no operation is performed. ::cudaFree() returns ::cudaErrorValue in case of failure. The device version of ::cudaFree cannot be used with a \p *devPtr allocated using the host API, and vice versa.

Parameters:

devPtr - - Device pointer to memory to free

Returns:

::cudaSuccess, ::cudaErrorInvalidValue \notefnerr \note_init_rt \note_callback

cudaFreeHost
```
@Cast("cudaError_t")
public static int cudaFreeHost(Pointer ptr)
```
\brief Frees page-locked memory Frees the memory space pointed to by \p hostPtr, which must have been returned by a previous call to ::cudaMallocHost() or ::cudaHostAlloc().

Parameters:

ptr - - Pointer to memory to free

Returns:

::cudaSuccess, ::cudaErrorInvalidValue \notefnerr \note_init_rt \note_callback

cudaFreeArray
```
@Cast("cudaError_t")
public static int cudaFreeArray(cudaArray array)
```
\brief Frees an array on the device Frees the CUDA array \p array, which must have been returned by a previous call to ::cudaMallocArray(). If \p devPtr is 0, no operation is performed.

Parameters:

array - - Pointer to array to free

Returns:

::cudaSuccess, ::cudaErrorInvalidValue \notefnerr \note_init_rt \note_callback

cudaFreeMipmappedArray
```
@Cast("cudaError_t")
public static int cudaFreeMipmappedArray(cudaMipmappedArray mipmappedArray)
```
\brief Frees a mipmapped array on the device Frees the CUDA mipmapped array \p mipmappedArray, which must have been returned by a previous call to ::cudaMallocMipmappedArray(). If \p devPtr is 0, no operation is performed.

Parameters:

mipmappedArray - - Pointer to mipmapped array to free

Returns:

::cudaSuccess, ::cudaErrorInvalidValue \notefnerr \note_init_rt \note_callback

cudaHostAlloc
```
@Cast("cudaError_t")
public static int cudaHostAlloc(@Cast("void**")
                                PointerPointer pHost,
                                @Cast("size_t")
                                long size,
                                @Cast("unsigned int")
                                int flags)
```
\brief Allocates page-locked memory on the host Allocates \p size bytes of host memory that is page-locked and accessible to the device. The driver tracks the virtual memory ranges allocated with this function and automatically accelerates calls to functions such as ::cudaMemcpy(). Since the memory can be accessed directly by the device, it can be read or written with much higher bandwidth than pageable memory obtained with functions such as ::malloc(). Allocating excessive amounts of pinned memory may degrade system performance, since it reduces the amount of memory available to the system for paging. As a result, this function is best used sparingly to allocate staging areas for data exchange between host and device. The \p flags parameter enables different options to be specified that affect the allocation, as follows. - ::cudaHostAllocDefault: This flag's value is defined to be 0 and causes ::cudaHostAlloc() to emulate ::cudaMallocHost(). - ::cudaHostAllocPortable: The memory returned by this call will be considered as pinned memory by all CUDA contexts, not just the one that performed the allocation. - ::cudaHostAllocMapped: Maps the allocation into the CUDA address space. The device pointer to the memory may be obtained by calling ::cudaHostGetDevicePointer(). - ::cudaHostAllocWriteCombined: Allocates the memory as write-combined (WC). WC memory can be transferred across the PCI Express bus more quickly on some system configurations, but cannot be read efficiently by most CPUs. WC memory is a good option for buffers that will be written by the CPU and read by the device via mapped pinned memory or host->device transfers. All of these flags are orthogonal to one another: a developer may allocate memory that is portable, mapped and/or write-combined with no restrictions. In order for the ::cudaHostAllocMapped flag to have any effect, the CUDA context must support the ::cudaDeviceMapHost flag, which can be checked via ::cudaGetDeviceFlags(). The ::cudaDeviceMapHost flag is implicitly set for contexts created via the runtime API. The ::cudaHostAllocMapped flag may be specified on CUDA contexts for devices that do not support mapped pinned memory. The failure is deferred to ::cudaHostGetDevicePointer() because the memory may be mapped into other CUDA contexts via the ::cudaHostAllocPortable flag. Memory allocated by this function must be freed with ::cudaFreeHost().

Parameters:

pHost - - Device pointer to allocated memory

size - - Requested allocation size in bytes

flags - - Requested properties of allocated memory

Returns:

::cudaSuccess, ::cudaErrorInvalidValue, ::cudaErrorMemoryAllocation \notefnerr \note_init_rt \note_callback

cudaHostAlloc

@Cast("cudaError_t")
public static int cudaHostAlloc(@Cast("void**") @ByPtrPtr
                                Pointer pHost,
                                @Cast("size_t")
                                long size,
                                @Cast("unsigned int")
                                int flags)

cudaHostRegister
```
@Cast("cudaError_t")
public static int cudaHostRegister(Pointer ptr,
                                   @Cast("size_t")
                                   long size,
                                   @Cast("unsigned int")
                                   int flags)
```
\brief Registers an existing host memory range for use by CUDA Page-locks the memory range specified by \p ptr and \p size and maps it for the device(s) as specified by \p flags. This memory range also is added to the same tracking mechanism as ::cudaHostAlloc() to automatically accelerate calls to functions such as ::cudaMemcpy(). Since the memory can be accessed directly by the device, it can be read or written with much higher bandwidth than pageable memory that has not been registered. Page-locking excessive amounts of memory may degrade system performance, since it reduces the amount of memory available to the system for paging. As a result, this function is best used sparingly to register staging areas for data exchange between host and device. ::cudaHostRegister is supported only on I/O coherent devices that have a non-zero value for the device attribute ::cudaDevAttrHostRegisterSupported. The \p flags parameter enables different options to be specified that affect the allocation, as follows. - ::cudaHostRegisterDefault: On a system with unified virtual addressing, the memory will be both mapped and portable. On a system with no unified virtual addressing, the memory will be neither mapped nor portable. - ::cudaHostRegisterPortable: The memory returned by this call will be considered as pinned memory by all CUDA contexts, not just the one that performed the allocation. - ::cudaHostRegisterMapped: Maps the allocation into the CUDA address space. The device pointer to the memory may be obtained by calling ::cudaHostGetDevicePointer(). - ::cudaHostRegisterIoMemory: The passed memory pointer is treated as pointing to some memory-mapped I/O space, e.g. belonging to a third-party PCIe device, and it will marked as non cache-coherent and contiguous. All of these flags are orthogonal to one another: a developer may page-lock memory that is portable or mapped with no restrictions. The CUDA context must have been created with the ::cudaMapHost flag in order for the ::cudaHostRegisterMapped flag to have any effect. The ::cudaHostRegisterMapped flag may be specified on CUDA contexts for devices that do not support mapped pinned memory. The failure is deferred to ::cudaHostGetDevicePointer() because the memory may be mapped into other CUDA contexts via the ::cudaHostRegisterPortable flag. For devices that have a non-zero value for the device attribute ::cudaDevAttrCanUseHostPointerForRegisteredMem, the memory can also be accessed from the device using the host pointer \p ptr. The device pointer returned by ::cudaHostGetDevicePointer() may or may not match the original host pointer \p ptr and depends on the devices visible to the application. If all devices visible to the application have a non-zero value for the device attribute, the device pointer returned by ::cudaHostGetDevicePointer() will match the original pointer \p ptr. If any device visible to the application has a zero value for the device attribute, the device pointer returned by ::cudaHostGetDevicePointer() will not match the original host pointer \p ptr, but it will be suitable for use on all devices provided Unified Virtual Addressing is enabled. In such systems, it is valid to access the memory using either pointer on devices that have a non-zero value for the device attribute. Note however that such devices should access the memory using only of the two pointers and not both. The memory page-locked by this function must be unregistered with ::cudaHostUnregister().

Parameters:

ptr - - Host pointer to memory to page-lock

size - - Size in bytes of the address range to page-lock in bytes

flags - - Flags for allocation request

Returns:

::cudaSuccess, ::cudaErrorInvalidValue, ::cudaErrorMemoryAllocation, ::cudaErrorHostMemoryAlreadyRegistered, ::cudaErrorNotSupported \notefnerr \note_init_rt \note_callback

cudaHostUnregister
```
@Cast("cudaError_t")
public static int cudaHostUnregister(Pointer ptr)
```
\brief Unregisters a memory range that was registered with cudaHostRegister Unmaps the memory range whose base address is specified by \p ptr, and makes it pageable again. The base address must be the same one specified to ::cudaHostRegister().

Parameters:

ptr - - Host pointer to memory to unregister

Returns:

::cudaSuccess, ::cudaErrorInvalidValue, ::cudaErrorHostMemoryNotRegistered \notefnerr \note_init_rt \note_callback

cudaHostGetDevicePointer
```
@Cast("cudaError_t")
public static int cudaHostGetDevicePointer(@Cast("void**")
                                           PointerPointer pDevice,
                                           Pointer pHost,
                                           @Cast("unsigned int")
                                           int flags)
```
\brief Passes back device pointer of mapped host memory allocated by cudaHostAlloc or registered by cudaHostRegister Passes back the device pointer corresponding to the mapped, pinned host buffer allocated by ::cudaHostAlloc() or registered by ::cudaHostRegister(). ::cudaHostGetDevicePointer() will fail if the ::cudaDeviceMapHost flag was not specified before deferred context creation occurred, or if called on a device that does not support mapped, pinned memory. For devices that have a non-zero value for the device attribute ::cudaDevAttrCanUseHostPointerForRegisteredMem, the memory can also be accessed from the device using the host pointer \p pHost. The device pointer returned by ::cudaHostGetDevicePointer() may or may not match the original host pointer \p pHost and depends on the devices visible to the application. If all devices visible to the application have a non-zero value for the device attribute, the device pointer returned by ::cudaHostGetDevicePointer() will match the original pointer \p pHost. If any device visible to the application has a zero value for the device attribute, the device pointer returned by ::cudaHostGetDevicePointer() will not match the original host pointer \p pHost, but it will be suitable for use on all devices provided Unified Virtual Addressing is enabled. In such systems, it is valid to access the memory using either pointer on devices that have a non-zero value for the device attribute. Note however that such devices should access the memory using only of the two pointers and not both. \p flags provides for future releases. For now, it must be set to 0.

Parameters:

pDevice - - Returned device pointer for mapped memory

pHost - - Requested host pointer mapping

flags - - Flags for extensions (must be 0 for now)

Returns:

::cudaSuccess, ::cudaErrorInvalidValue, ::cudaErrorMemoryAllocation \notefnerr \note_init_rt \note_callback

cudaHostGetDevicePointer

@Cast("cudaError_t")
public static int cudaHostGetDevicePointer(@Cast("void**") @ByPtrPtr
                                           Pointer pDevice,
                                           Pointer pHost,
                                           @Cast("unsigned int")
                                           int flags)

cudaHostGetFlags
```
@Cast("cudaError_t")
public static int cudaHostGetFlags(@Cast("unsigned int*")
                                   IntPointer pFlags,
                                   Pointer pHost)
```
\brief Passes back flags used to allocate pinned host memory allocated by cudaHostAlloc ::cudaHostGetFlags() will fail if the input pointer does not reside in an address range allocated by ::cudaHostAlloc().

Parameters:

pFlags - - Returned flags word

pHost - - Host pointer

Returns:

::cudaSuccess, ::cudaErrorInvalidValue \notefnerr \note_init_rt \note_callback

cudaHostGetFlags

@Cast("cudaError_t")
public static int cudaHostGetFlags(@Cast("unsigned int*")
                                   IntBuffer pFlags,
                                   Pointer pHost)

cudaHostGetFlags

@Cast("cudaError_t")
public static int cudaHostGetFlags(@Cast("unsigned int*")
                                   int[] pFlags,
                                   Pointer pHost)

cudaMalloc3D
```
@Cast("cudaError_t")
public static int cudaMalloc3D(cudaPitchedPtr pitchedDevPtr,
                               @ByVal
                               cudaExtent extent)
```
\brief Allocates logical 1D, 2D, or 3D memory objects on the device Allocates at least \p width * \p height * \p depth bytes of linear memory on the device and returns a ::cudaPitchedPtr in which \p ptr is a pointer to the allocated memory. The function may pad the allocation to ensure hardware alignment requirements are met. The pitch returned in the \p pitch field of \p pitchedDevPtr is the width in bytes of the allocation. The returned ::cudaPitchedPtr contains additional fields \p xsize and \p ysize, the logical width and height of the allocation, which are equivalent to the \p width and \p height \p extent parameters provided by the programmer during allocation. For allocations of 2D and 3D objects, it is highly recommended that programmers perform allocations using ::cudaMalloc3D() or ::cudaMallocPitch(). Due to alignment restrictions in the hardware, this is especially true if the application will be performing memory copies involving 2D or 3D objects (whether linear memory or CUDA arrays).

Parameters:

pitchedDevPtr - - Pointer to allocated pitched device memory

extent - - Requested allocation size (\p width field in bytes)

Returns:

::cudaSuccess, ::cudaErrorInvalidValue, ::cudaErrorMemoryAllocation \notefnerr \note_init_rt \note_callback

cudaMalloc3DArray
```
@Cast("cudaError_t")
public static int cudaMalloc3DArray(@ByPtrPtr
                                    cudaArray array,
                                    @Const
                                    cudaChannelFormatDesc desc,
                                    @ByVal
                                    cudaExtent extent,
                                    @Cast("unsigned int")
                                    int flags)
```
\brief Allocate an array on the device Allocates a CUDA array according to the ::cudaChannelFormatDesc structure \p desc and returns a handle to the new CUDA array in \p *array. The ::cudaChannelFormatDesc is defined as:
```
    struct cudaChannelFormatDesc {
        int x, y, z, w;
        enum cudaChannelFormatKind f;
    };
    
```
where ::cudaChannelFormatKind is one of ::cudaChannelFormatKindSigned, ::cudaChannelFormatKindUnsigned, or ::cudaChannelFormatKindFloat. ::cudaMalloc3DArray() can allocate the following: - A 1D array is allocated if the height and depth extents are both zero. - A 2D array is allocated if only the depth extent is zero. - A 3D array is allocated if all three extents are non-zero. - A 1D layered CUDA array is allocated if only the height extent is zero and the cudaArrayLayered flag is set. Each layer is a 1D array. The number of layers is determined by the depth extent. - A 2D layered CUDA array is allocated if all three extents are non-zero and the cudaArrayLayered flag is set. Each layer is a 2D array. The number of layers is determined by the depth extent. - A cubemap CUDA array is allocated if all three extents are non-zero and the cudaArrayCubemap flag is set. Width must be equal to height, and depth must be six. A cubemap is a special type of 2D layered CUDA array, where the six layers represent the six faces of a cube. The order of the six layers in memory is the same as that listed in ::cudaGraphicsCubeFace. - A cubemap layered CUDA array is allocated if all three extents are non-zero, and both, cudaArrayCubemap and cudaArrayLayered flags are set. Width must be equal to height, and depth must be a multiple of six. A cubemap layered CUDA array is a special type of 2D layered CUDA array that consists of a collection of cubemaps. The first six layers represent the first cubemap, the next six layers form the second cubemap, and so on. The \p flags parameter enables different options to be specified that affect the allocation, as follows. - ::cudaArrayDefault: This flag's value is defined to be 0 and provides default array allocation - ::cudaArrayLayered: Allocates a layered CUDA array, with the depth extent indicating the number of layers - ::cudaArrayCubemap: Allocates a cubemap CUDA array. Width must be equal to height, and depth must be six. If the cudaArrayLayered flag is also set, depth must be a multiple of six. - ::cudaArraySurfaceLoadStore: Allocates a CUDA array that could be read from or written to using a surface reference. - ::cudaArrayTextureGather: This flag indicates that texture gather operations will be performed on the CUDA array. Texture gather can only be performed on 2D CUDA arrays. The width, height and depth extents must meet certain size requirements as listed in the following table. All values are specified in elements. Note that 2D CUDA arrays have different size requirements if the ::cudaArrayTextureGather flag is set. In that case, the valid range for (width, height, depth) is ((1,maxTexture2DGather[0]), (1,maxTexture2DGather[1]), 0). \xmlonly CUDA array type Valid extents that must always be met {(width range in elements), (height range), (depth range)} Valid extents with cudaArraySurfaceLoadStore set {(width range in elements), (height range), (depth range)} 1D { (1,maxTexture1D), 0, 0 } { (1,maxSurface1D), 0, 0 } 2D { (1,maxTexture2D[0]), (1,maxTexture2D[1]), 0 } { (1,maxSurface2D[0]), (1,maxSurface2D[1]), 0 } 3D { (1,maxTexture3D[0]), (1,maxTexture3D[1]), (1,maxTexture3D[2]) } OR { (1,maxTexture3DAlt[0]), (1,maxTexture3DAlt[1]), (1,maxTexture3DAlt[2]) } { (1,maxSurface3D[0]), (1,maxSurface3D[1]), (1,maxSurface3D[2]) } 1D Layered { (1,maxTexture1DLayered[0]), 0, (1,maxTexture1DLayered[1]) } { (1,maxSurface1DLayered[0]), 0, (1,maxSurface1DLayered[1]) } 2D Layered { (1,maxTexture2DLayered[0]), (1,maxTexture2DLayered[1]), (1,maxTexture2DLayered[2]) } { (1,maxSurface2DLayered[0]), (1,maxSurface2DLayered[1]), (1,maxSurface2DLayered[2]) } Cubemap { (1,maxTextureCubemap), (1,maxTextureCubemap), 6 } { (1,maxSurfaceCubemap), (1,maxSurfaceCubemap), 6 } Cubemap Layered { (1,maxTextureCubemapLayered[0]), (1,maxTextureCubemapLayered[0]), (1,maxTextureCubemapLayered[1]) } { (1,maxSurfaceCubemapLayered[0]), (1,maxSurfaceCubemapLayered[0]), (1,maxSurfaceCubemapLayered[1]) }

\endxmlonly
Parameters:

array - - Pointer to allocated array in device memory

desc - - Requested channel format

extent - - Requested allocation size (\p width field in elements)

flags - - Flags for extensions

Returns:

::cudaSuccess, ::cudaErrorInvalidValue, ::cudaErrorMemoryAllocation \notefnerr \note_init_rt \note_callback

cudaMalloc3DArray

@Cast("cudaError_t")
public static int cudaMalloc3DArray(@ByPtrPtr
                                    cudaArray array,
                                    @Const
                                    cudaChannelFormatDesc desc,
                                    @ByVal
                                    cudaExtent extent)

cudaMallocMipmappedArray
```
@Cast("cudaError_t")
public static int cudaMallocMipmappedArray(@ByPtrPtr
                                           cudaMipmappedArray mipmappedArray,
                                           @Const
                                           cudaChannelFormatDesc desc,
                                           @ByVal
                                           cudaExtent extent,
                                           @Cast("unsigned int")
                                           int numLevels,
                                           @Cast("unsigned int")
                                           int flags)
```
\brief Allocate a mipmapped array on the device Allocates a CUDA mipmapped array according to the ::cudaChannelFormatDesc structure \p desc and returns a handle to the new CUDA mipmapped array in \p *mipmappedArray. \p numLevels specifies the number of mipmap levels to be allocated. This value is clamped to the range [1, 1 + floor(log2(max(width, height, depth)))]. The ::cudaChannelFormatDesc is defined as:
```
    struct cudaChannelFormatDesc {
        int x, y, z, w;
        enum cudaChannelFormatKind f;
    };
    
```
where ::cudaChannelFormatKind is one of ::cudaChannelFormatKindSigned, ::cudaChannelFormatKindUnsigned, or ::cudaChannelFormatKindFloat. ::cudaMallocMipmappedArray() can allocate the following: - A 1D mipmapped array is allocated if the height and depth extents are both zero. - A 2D mipmapped array is allocated if only the depth extent is zero. - A 3D mipmapped array is allocated if all three extents are non-zero. - A 1D layered CUDA mipmapped array is allocated if only the height extent is zero and the cudaArrayLayered flag is set. Each layer is a 1D mipmapped array. The number of layers is determined by the depth extent. - A 2D layered CUDA mipmapped array is allocated if all three extents are non-zero and the cudaArrayLayered flag is set. Each layer is a 2D mipmapped array. The number of layers is determined by the depth extent. - A cubemap CUDA mipmapped array is allocated if all three extents are non-zero and the cudaArrayCubemap flag is set. Width must be equal to height, and depth must be six. The order of the six layers in memory is the same as that listed in ::cudaGraphicsCubeFace. - A cubemap layered CUDA mipmapped array is allocated if all three extents are non-zero, and both, cudaArrayCubemap and cudaArrayLayered flags are set. Width must be equal to height, and depth must be a multiple of six. A cubemap layered CUDA mipmapped array is a special type of 2D layered CUDA mipmapped array that consists of a collection of cubemap mipmapped arrays. The first six layers represent the first cubemap mipmapped array, the next six layers form the second cubemap mipmapped array, and so on. The \p flags parameter enables different options to be specified that affect the allocation, as follows. - ::cudaArrayDefault: This flag's value is defined to be 0 and provides default mipmapped array allocation - ::cudaArrayLayered: Allocates a layered CUDA mipmapped array, with the depth extent indicating the number of layers - ::cudaArrayCubemap: Allocates a cubemap CUDA mipmapped array. Width must be equal to height, and depth must be six. If the cudaArrayLayered flag is also set, depth must be a multiple of six. - ::cudaArraySurfaceLoadStore: This flag indicates that individual mipmap levels of the CUDA mipmapped array will be read from or written to using a surface reference. - ::cudaArrayTextureGather: This flag indicates that texture gather operations will be performed on the CUDA array. Texture gather can only be performed on 2D CUDA mipmapped arrays, and the gather operations are performed only on the most detailed mipmap level. The width, height and depth extents must meet certain size requirements as listed in the following table. All values are specified in elements. \xmlonly CUDA array type Valid extents that must always be met {(width range in elements), (height range), (depth range)} Valid extents with cudaArraySurfaceLoadStore set {(width range in elements), (height range), (depth range)} 1D { (1,maxTexture1DMipmap), 0, 0 } { (1,maxSurface1D), 0, 0 } 2D { (1,maxTexture2DMipmap[0]), (1,maxTexture2DMipmap[1]), 0 } { (1,maxSurface2D[0]), (1,maxSurface2D[1]), 0 } 3D { (1,maxTexture3D[0]), (1,maxTexture3D[1]), (1,maxTexture3D[2]) } OR { (1,maxTexture3DAlt[0]), (1,maxTexture3DAlt[1]), (1,maxTexture3DAlt[2]) } { (1,maxSurface3D[0]), (1,maxSurface3D[1]), (1,maxSurface3D[2]) } 1D Layered { (1,maxTexture1DLayered[0]), 0, (1,maxTexture1DLayered[1]) } { (1,maxSurface1DLayered[0]), 0, (1,maxSurface1DLayered[1]) } 2D Layered { (1,maxTexture2DLayered[0]), (1,maxTexture2DLayered[1]), (1,maxTexture2DLayered[2]) } { (1,maxSurface2DLayered[0]), (1,maxSurface2DLayered[1]), (1,maxSurface2DLayered[2]) } Cubemap { (1,maxTextureCubemap), (1,maxTextureCubemap), 6 } { (1,maxSurfaceCubemap), (1,maxSurfaceCubemap), 6 } Cubemap Layered { (1,maxTextureCubemapLayered[0]), (1,maxTextureCubemapLayered[0]), (1,maxTextureCubemapLayered[1]) } { (1,maxSurfaceCubemapLayered[0]), (1,maxSurfaceCubemapLayered[0]), (1,maxSurfaceCubemapLayered[1]) }

\endxmlonly
Parameters:

mipmappedArray - - Pointer to allocated mipmapped array in device memory

desc - - Requested channel format

extent - - Requested allocation size (\p width field in elements)

numLevels - - Number of mipmap levels to allocate

flags - - Flags for extensions

Returns:

::cudaSuccess, ::cudaErrorInvalidValue, ::cudaErrorMemoryAllocation \notefnerr \note_init_rt \note_callback

cudaMallocMipmappedArray

@Cast("cudaError_t")
public static int cudaMallocMipmappedArray(@ByPtrPtr
                                           cudaMipmappedArray mipmappedArray,
                                           @Const
                                           cudaChannelFormatDesc desc,
                                           @ByVal
                                           cudaExtent extent,
                                           @Cast("unsigned int")
                                           int numLevels)

cudaGetMipmappedArrayLevel
```
@Cast("cudaError_t")
public static int cudaGetMipmappedArrayLevel(@ByPtrPtr
                                             cudaArray levelArray,
                                             cudaMipmappedArray mipmappedArray,
                                             @Cast("unsigned int")
                                             int level)
```
\brief Gets a mipmap level of a CUDA mipmapped array Returns in \p *levelArray a CUDA array that represents a single mipmap level of the CUDA mipmapped array \p mipmappedArray. If \p level is greater than the maximum number of levels in this mipmapped array, ::cudaErrorInvalidValue is returned.

Parameters:

levelArray - - Returned mipmap level CUDA array

mipmappedArray - - CUDA mipmapped array

level - - Mipmap level

Returns:

::cudaSuccess, ::cudaErrorInvalidValue \notefnerr \note_init_rt \note_callback

cudaMemcpy3D
```
@Cast("cudaError_t")
public static int cudaMemcpy3D(@Const
                               cudaMemcpy3DParms p)
```
\brief Copies data between 3D objects
```
struct cudaExtent {
  size_t width;
  size_t height;
  size_t depth;
};
struct cudaExtent make_cudaExtent(size_t w, size_t h, size_t d);

struct cudaPos {
  size_t x;
  size_t y;
  size_t z;
};
struct cudaPos make_cudaPos(size_t x, size_t y, size_t z);

struct cudaMemcpy3DParms {
  cudaArray_t           srcArray;
  struct cudaPos        srcPos;
  struct cudaPitchedPtr srcPtr;
  cudaArray_t           dstArray;
  struct cudaPos        dstPos;
  struct cudaPitchedPtr dstPtr;
  struct cudaExtent     extent;
  enum cudaMemcpyKind   kind;
};
```
::cudaMemcpy3D() copies data betwen two 3D objects. The source and destination objects may be in either host memory, device memory, or a CUDA array. The source, destination, extent, and kind of copy performed is specified by the ::cudaMemcpy3DParms struct which should be initialized to zero before use:
```
cudaMemcpy3DParms myParms = {0};
```
The struct passed to ::cudaMemcpy3D() must specify one of \p srcArray or \p srcPtr and one of \p dstArray or \p dstPtr. Passing more than one non-zero source or destination will cause ::cudaMemcpy3D() to return an error. The \p srcPos and \p dstPos fields are optional offsets into the source and destination objects and are defined in units of each object's elements. The element for a host or device pointer is assumed to be unsigned char. The \p extent field defines the dimensions of the transferred area in elements. If a CUDA array is participating in the copy, the extent is defined in terms of that array's elements. If no CUDA array is participating in the copy then the extents are defined in elements of unsigned char. The \p kind field defines the direction of the copy. It must be one of ::cudaMemcpyHostToHost, ::cudaMemcpyHostToDevice, ::cudaMemcpyDeviceToHost, ::cudaMemcpyDeviceToDevice, or ::cudaMemcpyDefault. Passing ::cudaMemcpyDefault is recommended, in which case the type of transfer is inferred from the pointer values. However, ::cudaMemcpyDefault is only allowed on systems that support unified virtual addressing. For ::cudaMemcpyHostToHost or ::cudaMemcpyHostToDevice or ::cudaMemcpyDeviceToHost passed as kind and cudaArray type passed as source or destination, if the kind implies cudaArray type to be present on the host, ::cudaMemcpy3D() will disregard that implication and silently correct the kind based on the fact that cudaArray type can only be present on the device. If the source and destination are both arrays, ::cudaMemcpy3D() will return an error if they do not have the same element size. The source and destination object may not overlap. If overlapping source and destination objects are specified, undefined behavior will result. The source object must lie entirely within the region defined by \p srcPos and \p extent. The destination object must lie entirely within the region defined by \p dstPos and \p extent. ::cudaMemcpy3D() returns an error if the pitch of \p srcPtr or \p dstPtr exceeds the maximum allowed. The pitch of a ::cudaPitchedPtr allocated with ::cudaMalloc3D() will always be valid.
Parameters:

p - - 3D memory copy parameters

Returns:

::cudaSuccess, ::cudaErrorInvalidValue, ::cudaErrorInvalidPitchValue, ::cudaErrorInvalidMemcpyDirection \notefnerr \note_sync \note_init_rt \note_callback

cudaMemcpy3DPeer
```
@Cast("cudaError_t")
public static int cudaMemcpy3DPeer(@Const
                                   cudaMemcpy3DPeerParms p)
```
\brief Copies memory between devices Perform a 3D memory copy according to the parameters specified in \p p. See the definition of the ::cudaMemcpy3DPeerParms structure for documentation of its parameters. Note that this function is synchronous with respect to the host only if the source or destination of the transfer is host memory. Note also that this copy is serialized with respect to all pending and future asynchronous work in to the current device, the copy's source device, and the copy's destination device (use ::cudaMemcpy3DPeerAsync to avoid this synchronization).

Parameters:

p - - Parameters for the memory copy

Returns:

::cudaSuccess, ::cudaErrorInvalidValue, ::cudaErrorInvalidDevice \notefnerr \note_sync \note_init_rt \note_callback

cudaMemcpy3DAsync
```
@Cast("cudaError_t")
public static int cudaMemcpy3DAsync(@Const
                                    cudaMemcpy3DParms p,
                                    CUstream_st stream)
```
\brief Copies data between 3D objects
```
struct cudaExtent {
  size_t width;
  size_t height;
  size_t depth;
};
struct cudaExtent make_cudaExtent(size_t w, size_t h, size_t d);

struct cudaPos {
  size_t x;
  size_t y;
  size_t z;
};
struct cudaPos make_cudaPos(size_t x, size_t y, size_t z);

struct cudaMemcpy3DParms {
  cudaArray_t           srcArray;
  struct cudaPos        srcPos;
  struct cudaPitchedPtr srcPtr;
  cudaArray_t           dstArray;
  struct cudaPos        dstPos;
  struct cudaPitchedPtr dstPtr;
  struct cudaExtent     extent;
  enum cudaMemcpyKind   kind;
};
```
::cudaMemcpy3DAsync() copies data betwen two 3D objects. The source and destination objects may be in either host memory, device memory, or a CUDA array. The source, destination, extent, and kind of copy performed is specified by the ::cudaMemcpy3DParms struct which should be initialized to zero before use:
```
cudaMemcpy3DParms myParms = {0};
```
The struct passed to ::cudaMemcpy3DAsync() must specify one of \p srcArray or \p srcPtr and one of \p dstArray or \p dstPtr. Passing more than one non-zero source or destination will cause ::cudaMemcpy3DAsync() to return an error. The \p srcPos and \p dstPos fields are optional offsets into the source and destination objects and are defined in units of each object's elements. The element for a host or device pointer is assumed to be unsigned char. For CUDA arrays, positions must be in the range [0, 2048) for any dimension. The \p extent field defines the dimensions of the transferred area in elements. If a CUDA array is participating in the copy, the extent is defined in terms of that array's elements. If no CUDA array is participating in the copy then the extents are defined in elements of unsigned char. The \p kind field defines the direction of the copy. It must be one of ::cudaMemcpyHostToHost, ::cudaMemcpyHostToDevice, ::cudaMemcpyDeviceToHost, ::cudaMemcpyDeviceToDevice, or ::cudaMemcpyDefault. Passing ::cudaMemcpyDefault is recommended, in which case the type of transfer is inferred from the pointer values. However, ::cudaMemcpyDefault is only allowed on systems that support unified virtual addressing. For ::cudaMemcpyHostToHost or ::cudaMemcpyHostToDevice or ::cudaMemcpyDeviceToHost passed as kind and cudaArray type passed as source or destination, if the kind implies cudaArray type to be present on the host, ::cudaMemcpy3DAsync() will disregard that implication and silently correct the kind based on the fact that cudaArray type can only be present on the device. If the source and destination are both arrays, ::cudaMemcpy3DAsync() will return an error if they do not have the same element size. The source and destination object may not overlap. If overlapping source and destination objects are specified, undefined behavior will result. The source object must lie entirely within the region defined by \p srcPos and \p extent. The destination object must lie entirely within the region defined by \p dstPos and \p extent. ::cudaMemcpy3DAsync() returns an error if the pitch of \p srcPtr or \p dstPtr exceeds the maximum allowed. The pitch of a ::cudaPitchedPtr allocated with ::cudaMalloc3D() will always be valid. ::cudaMemcpy3DAsync() is asynchronous with respect to the host, so the call may return before the copy is complete. The copy can optionally be associated to a stream by passing a non-zero \p stream argument. If \p kind is ::cudaMemcpyHostToDevice or ::cudaMemcpyDeviceToHost and \p stream is non-zero, the copy may overlap with operations in other streams. The device version of this function only handles device to device copies and cannot be given local or shared pointers.
Parameters:

p - - 3D memory copy parameters

stream - - Stream identifier

Returns:

::cudaSuccess, ::cudaErrorInvalidValue, ::cudaErrorInvalidPitchValue, ::cudaErrorInvalidMemcpyDirection \notefnerr \note_async \note_null_stream \note_init_rt \note_callback

cudaMemcpy3DAsync

@Cast("cudaError_t")
public static int cudaMemcpy3DAsync(@Const
                                    cudaMemcpy3DParms p)

cudaMemcpy3DPeerAsync
```
@Cast("cudaError_t")
public static int cudaMemcpy3DPeerAsync(@Const
                                        cudaMemcpy3DPeerParms p,
                                        CUstream_st stream)
```
\brief Copies memory between devices asynchronously. Perform a 3D memory copy according to the parameters specified in \p p. See the definition of the ::cudaMemcpy3DPeerParms structure for documentation of its parameters.

Parameters:

p - - Parameters for the memory copy

stream - - Stream identifier

Returns:

::cudaSuccess, ::cudaErrorInvalidValue, ::cudaErrorInvalidDevice \notefnerr \note_async \note_null_stream \note_init_rt \note_callback

cudaMemcpy3DPeerAsync

@Cast("cudaError_t")
public static int cudaMemcpy3DPeerAsync(@Const
                                        cudaMemcpy3DPeerParms p)

cudaMemGetInfo
```
@Cast("cudaError_t")
public static int cudaMemGetInfo(@Cast("size_t*")
                                 SizeTPointer _free,
                                 @Cast("size_t*")
                                 SizeTPointer total)
```
\brief Gets free and total device memory Returns in \p *free and \p *total respectively, the free and total amount of memory available for allocation by the device in bytes.

Parameters:

free - - Returned free memory in bytes

total - - Returned total memory in bytes

Returns:

::cudaSuccess, ::cudaErrorInvalidValue, ::cudaErrorLaunchFailure \notefnerr \note_init_rt \note_callback

cudaArrayGetInfo
```
@Cast("cudaError_t")
public static int cudaArrayGetInfo(cudaChannelFormatDesc desc,
                                   cudaExtent extent,
                                   @Cast("unsigned int*")
                                   IntPointer flags,
                                   cudaArray array)
```
\brief Gets info about the specified cudaArray Returns in \p *desc, \p *extent and \p *flags respectively, the type, shape and flags of \p array. Any of \p *desc, \p *extent and \p *flags may be specified as NULL.

Parameters:

desc - - Returned array type

extent - - Returned array shape. 2D arrays will have depth of zero

flags - - Returned array flags

array - - The ::cudaArray to get info for

Returns:

::cudaSuccess, ::cudaErrorInvalidValue \notefnerr \note_init_rt \note_callback

cudaArrayGetInfo

@Cast("cudaError_t")
public static int cudaArrayGetInfo(cudaChannelFormatDesc desc,
                                   cudaExtent extent,
                                   @Cast("unsigned int*")
                                   IntBuffer flags,
                                   cudaArray array)

cudaArrayGetInfo

@Cast("cudaError_t")
public static int cudaArrayGetInfo(cudaChannelFormatDesc desc,
                                   cudaExtent extent,
                                   @Cast("unsigned int*")
                                   int[] flags,
                                   cudaArray array)

cudaMemcpy
```
@Cast("cudaError_t")
public static int cudaMemcpy(Pointer dst,
                             @Const
                             Pointer src,
                             @Cast("size_t")
                             long count,
                             @Cast("cudaMemcpyKind")
                             int kind)
```
\brief Copies data between host and device Copies \p count bytes from the memory area pointed to by \p src to the memory area pointed to by \p dst, where \p kind specifies the direction of the copy, and must be one of ::cudaMemcpyHostToHost, ::cudaMemcpyHostToDevice, ::cudaMemcpyDeviceToHost, ::cudaMemcpyDeviceToDevice, or ::cudaMemcpyDefault. Passing ::cudaMemcpyDefault is recommended, in which case the type of transfer is inferred from the pointer values. However, ::cudaMemcpyDefault is only allowed on systems that support unified virtual addressing. Calling ::cudaMemcpy() with dst and src pointers that do not match the direction of the copy results in an undefined behavior.

Parameters:

dst - - Destination memory address

src - - Source memory address

count - - Size in bytes to copy

kind - - Type of transfer

Returns:

::cudaSuccess, ::cudaErrorInvalidValue, ::cudaErrorInvalidMemcpyDirection \notefnerr \note_init_rt \note_callback \note_sync

cudaMemcpyPeer
```
@Cast("cudaError_t")
public static int cudaMemcpyPeer(Pointer dst,
                                 int dstDevice,
                                 @Const
                                 Pointer src,
                                 int srcDevice,
                                 @Cast("size_t")
                                 long count)
```
\brief Copies memory between two devices Copies memory from one device to memory on another device. \p dst is the base device pointer of the destination memory and \p dstDevice is the destination device. \p src is the base device pointer of the source memory and \p srcDevice is the source device. \p count specifies the number of bytes to copy. Note that this function is asynchronous with respect to the host, but serialized with respect all pending and future asynchronous work in to the current device, \p srcDevice, and \p dstDevice (use ::cudaMemcpyPeerAsync to avoid this synchronization).

Parameters:

dst - - Destination device pointer

dstDevice - - Destination device

src - - Source device pointer

srcDevice - - Source device

count - - Size of memory copy in bytes

Returns:

::cudaSuccess, ::cudaErrorInvalidValue, ::cudaErrorInvalidDevice \notefnerr \note_sync \note_init_rt \note_callback

cudaMemcpy2D
```
@Cast("cudaError_t")
public static int cudaMemcpy2D(Pointer dst,
                               @Cast("size_t")
                               long dpitch,
                               @Const
                               Pointer src,
                               @Cast("size_t")
                               long spitch,
                               @Cast("size_t")
                               long width,
                               @Cast("size_t")
                               long height,
                               @Cast("cudaMemcpyKind")
                               int kind)
```
\brief Copies data between host and device Copies a matrix (\p height rows of \p width bytes each) from the memory area pointed to by \p src to the memory area pointed to by \p dst, where \p kind specifies the direction of the copy, and must be one of ::cudaMemcpyHostToHost, ::cudaMemcpyHostToDevice, ::cudaMemcpyDeviceToHost, ::cudaMemcpyDeviceToDevice, or ::cudaMemcpyDefault. Passing ::cudaMemcpyDefault is recommended, in which case the type of transfer is inferred from the pointer values. However, ::cudaMemcpyDefault is only allowed on systems that support unified virtual addressing. \p dpitch and \p spitch are the widths in memory in bytes of the 2D arrays pointed to by \p dst and \p src, including any padding added to the end of each row. The memory areas may not overlap. \p width must not exceed either \p dpitch or \p spitch. Calling ::cudaMemcpy2D() with \p dst and \p src pointers that do not match the direction of the copy results in an undefined behavior. ::cudaMemcpy2D() returns an error if \p dpitch or \p spitch exceeds the maximum allowed.

Parameters:

dst - - Destination memory address

dpitch - - Pitch of destination memory

src - - Source memory address

spitch - - Pitch of source memory

width - - Width of matrix transfer (columns in bytes)

height - - Height of matrix transfer (rows)

kind - - Type of transfer

Returns:

::cudaSuccess, ::cudaErrorInvalidValue, ::cudaErrorInvalidPitchValue, ::cudaErrorInvalidMemcpyDirection \notefnerr \note_init_rt \note_callback

cudaMemcpy2DToArray
```
@Cast("cudaError_t")
public static int cudaMemcpy2DToArray(cudaArray dst,
                                      @Cast("size_t")
                                      long wOffset,
                                      @Cast("size_t")
                                      long hOffset,
                                      @Const
                                      Pointer src,
                                      @Cast("size_t")
                                      long spitch,
                                      @Cast("size_t")
                                      long width,
                                      @Cast("size_t")
                                      long height,
                                      @Cast("cudaMemcpyKind")
                                      int kind)
```
\brief Copies data between host and device Copies a matrix (\p height rows of \p width bytes each) from the memory area pointed to by \p src to the CUDA array \p dst starting at the upper left corner (\p wOffset, \p hOffset) where \p kind specifies the direction of the copy, and must be one of ::cudaMemcpyHostToHost, ::cudaMemcpyHostToDevice, ::cudaMemcpyDeviceToHost, ::cudaMemcpyDeviceToDevice, or ::cudaMemcpyDefault. Passing ::cudaMemcpyDefault is recommended, in which case the type of transfer is inferred from the pointer values. However, ::cudaMemcpyDefault is only allowed on systems that support unified virtual addressing. \p spitch is the width in memory in bytes of the 2D array pointed to by \p src, including any padding added to the end of each row. \p wOffset + \p width must not exceed the width of the CUDA array \p dst. \p width must not exceed \p spitch. ::cudaMemcpy2DToArray() returns an error if \p spitch exceeds the maximum allowed.

Parameters:

dst - - Destination memory address

wOffset - - Destination starting X offset

hOffset - - Destination starting Y offset

src - - Source memory address

spitch - - Pitch of source memory

width - - Width of matrix transfer (columns in bytes)

height - - Height of matrix transfer (rows)

kind - - Type of transfer

Returns:

::cudaSuccess, ::cudaErrorInvalidValue, ::cudaErrorInvalidPitchValue, ::cudaErrorInvalidMemcpyDirection \notefnerr \note_sync \note_init_rt \note_callback

cudaMemcpy2DFromArray
```
@Cast("cudaError_t")
public static int cudaMemcpy2DFromArray(Pointer dst,
                                        @Cast("size_t")
                                        long dpitch,
                                        cudaArray src,
                                        @Cast("size_t")
                                        long wOffset,
                                        @Cast("size_t")
                                        long hOffset,
                                        @Cast("size_t")
                                        long width,
                                        @Cast("size_t")
                                        long height,
                                        @Cast("cudaMemcpyKind")
                                        int kind)
```
\brief Copies data between host and device Copies a matrix (\p height rows of \p width bytes each) from the CUDA array \p srcArray starting at the upper left corner (\p wOffset, \p hOffset) to the memory area pointed to by \p dst, where \p kind specifies the direction of the copy, and must be one of ::cudaMemcpyHostToHost, ::cudaMemcpyHostToDevice, ::cudaMemcpyDeviceToHost, ::cudaMemcpyDeviceToDevice, or ::cudaMemcpyDefault. Passing ::cudaMemcpyDefault is recommended, in which case the type of transfer is inferred from the pointer values. However, ::cudaMemcpyDefault is only allowed on systems that support unified virtual addressing. \p dpitch is the width in memory in bytes of the 2D array pointed to by \p dst, including any padding added to the end of each row. \p wOffset + \p width must not exceed the width of the CUDA array \p src. \p width must not exceed \p dpitch. ::cudaMemcpy2DFromArray() returns an error if \p dpitch exceeds the maximum allowed.

Parameters:

dst - - Destination memory address

dpitch - - Pitch of destination memory

src - - Source memory address

wOffset - - Source starting X offset

hOffset - - Source starting Y offset

width - - Width of matrix transfer (columns in bytes)

height - - Height of matrix transfer (rows)

kind - - Type of transfer

Returns:

::cudaSuccess, ::cudaErrorInvalidValue, ::cudaErrorInvalidPitchValue, ::cudaErrorInvalidMemcpyDirection \notefnerr \note_sync \note_init_rt \note_callback

cudaMemcpy2DArrayToArray
```
@Cast("cudaError_t")
public static int cudaMemcpy2DArrayToArray(cudaArray dst,
                                           @Cast("size_t")
                                           long wOffsetDst,
                                           @Cast("size_t")
                                           long hOffsetDst,
                                           cudaArray src,
                                           @Cast("size_t")
                                           long wOffsetSrc,
                                           @Cast("size_t")
                                           long hOffsetSrc,
                                           @Cast("size_t")
                                           long width,
                                           @Cast("size_t")
                                           long height,
                                           @Cast("cudaMemcpyKind")
                                           int kind)
```
\brief Copies data between host and device Copies a matrix (\p height rows of \p width bytes each) from the CUDA array \p srcArray starting at the upper left corner (\p wOffsetSrc, \p hOffsetSrc) to the CUDA array \p dst starting at the upper left corner (\p wOffsetDst, \p hOffsetDst), where \p kind specifies the direction of the copy, and must be one of ::cudaMemcpyHostToHost, ::cudaMemcpyHostToDevice, ::cudaMemcpyDeviceToHost, ::cudaMemcpyDeviceToDevice, or ::cudaMemcpyDefault. Passing ::cudaMemcpyDefault is recommended, in which case the type of transfer is inferred from the pointer values. However, ::cudaMemcpyDefault is only allowed on systems that support unified virtual addressing. \p wOffsetDst + \p width must not exceed the width of the CUDA array \p dst. \p wOffsetSrc + \p width must not exceed the width of the CUDA array \p src.

Parameters:

dst - - Destination memory address

wOffsetDst - - Destination starting X offset

hOffsetDst - - Destination starting Y offset

src - - Source memory address

wOffsetSrc - - Source starting X offset

hOffsetSrc - - Source starting Y offset

width - - Width of matrix transfer (columns in bytes)

height - - Height of matrix transfer (rows)

kind - - Type of transfer

Returns:

::cudaSuccess, ::cudaErrorInvalidValue, ::cudaErrorInvalidMemcpyDirection \notefnerr \note_sync \note_init_rt \note_callback

cudaMemcpy2DArrayToArray

@Cast("cudaError_t")
public static int cudaMemcpy2DArrayToArray(cudaArray dst,
                                           @Cast("size_t")
                                           long wOffsetDst,
                                           @Cast("size_t")
                                           long hOffsetDst,
                                           cudaArray src,
                                           @Cast("size_t")
                                           long wOffsetSrc,
                                           @Cast("size_t")
                                           long hOffsetSrc,
                                           @Cast("size_t")
                                           long width,
                                           @Cast("size_t")
                                           long height)

cudaMemcpyToSymbol
```
@Cast("cudaError_t")
public static int cudaMemcpyToSymbol(@Const
                                     Pointer symbol,
                                     @Const
                                     Pointer src,
                                     @Cast("size_t")
                                     long count,
                                     @Cast("size_t")
                                     long offset,
                                     @Cast("cudaMemcpyKind")
                                     int kind)
```
\brief Copies data to the given symbol on the device Copies \p count bytes from the memory area pointed to by \p src to the memory area pointed to by \p offset bytes from the start of symbol \p symbol. The memory areas may not overlap. \p symbol is a variable that resides in global or constant memory space. \p kind can be either ::cudaMemcpyHostToDevice, ::cudaMemcpyDeviceToDevice, or ::cudaMemcpyDefault. Passing ::cudaMemcpyDefault is recommended, in which case the type of transfer is inferred from the pointer values. However, ::cudaMemcpyDefault is only allowed on systems that support unified virtual addressing.

Parameters:

symbol - - Device symbol address

src - - Source memory address

count - - Size in bytes to copy

offset - - Offset from start of symbol in bytes

kind - - Type of transfer

Returns:

::cudaSuccess, ::cudaErrorInvalidValue, ::cudaErrorInvalidSymbol, ::cudaErrorInvalidMemcpyDirection, ::cudaErrorNoKernelImageForDevice \notefnerr \note_sync \note_string_api_deprecation \note_init_rt \note_callback

cudaMemcpyToSymbol

@Cast("cudaError_t")
public static int cudaMemcpyToSymbol(@Const
                                     Pointer symbol,
                                     @Const
                                     Pointer src,
                                     @Cast("size_t")
                                     long count)

cudaMemcpyFromSymbol
```
@Cast("cudaError_t")
public static int cudaMemcpyFromSymbol(Pointer dst,
                                       @Const
                                       Pointer symbol,
                                       @Cast("size_t")
                                       long count,
                                       @Cast("size_t")
                                       long offset,
                                       @Cast("cudaMemcpyKind")
                                       int kind)
```
\brief Copies data from the given symbol on the device Copies \p count bytes from the memory area pointed to by \p offset bytes from the start of symbol \p symbol to the memory area pointed to by \p dst. The memory areas may not overlap. \p symbol is a variable that resides in global or constant memory space. \p kind can be either ::cudaMemcpyDeviceToHost, ::cudaMemcpyDeviceToDevice, or ::cudaMemcpyDefault. Passing ::cudaMemcpyDefault is recommended, in which case the type of transfer is inferred from the pointer values. However, ::cudaMemcpyDefault is only allowed on systems that support unified virtual addressing.

Parameters:

dst - - Destination memory address

symbol - - Device symbol address

count - - Size in bytes to copy

offset - - Offset from start of symbol in bytes

kind - - Type of transfer

Returns:

::cudaSuccess, ::cudaErrorInvalidValue, ::cudaErrorInvalidSymbol, ::cudaErrorInvalidMemcpyDirection, ::cudaErrorNoKernelImageForDevice \notefnerr \note_sync \note_string_api_deprecation \note_init_rt \note_callback

cudaMemcpyFromSymbol

@Cast("cudaError_t")
public static int cudaMemcpyFromSymbol(Pointer dst,
                                       @Const
                                       Pointer symbol,
                                       @Cast("size_t")
                                       long count)

cudaMemcpyAsync
```
@Cast("cudaError_t")
public static int cudaMemcpyAsync(Pointer dst,
                                  @Const
                                  Pointer src,
                                  @Cast("size_t")
                                  long count,
                                  @Cast("cudaMemcpyKind")
                                  int kind,
                                  CUstream_st stream)
```
\brief Copies data between host and device Copies \p count bytes from the memory area pointed to by \p src to the memory area pointed to by \p dst, where \p kind specifies the direction of the copy, and must be one of ::cudaMemcpyHostToHost, ::cudaMemcpyHostToDevice, ::cudaMemcpyDeviceToHost, ::cudaMemcpyDeviceToDevice, or ::cudaMemcpyDefault. Passing ::cudaMemcpyDefault is recommended, in which case the type of transfer is inferred from the pointer values. However, ::cudaMemcpyDefault is only allowed on systems that support unified virtual addressing. The memory areas may not overlap. Calling ::cudaMemcpyAsync() with \p dst and \p src pointers that do not match the direction of the copy results in an undefined behavior. ::cudaMemcpyAsync() is asynchronous with respect to the host, so the call may return before the copy is complete. The copy can optionally be associated to a stream by passing a non-zero \p stream argument. If \p kind is ::cudaMemcpyHostToDevice or ::cudaMemcpyDeviceToHost and the \p stream is non-zero, the copy may overlap with operations in other streams. The device version of this function only handles device to device copies and cannot be given local or shared pointers.

Parameters:

dst - - Destination memory address

src - - Source memory address

count - - Size in bytes to copy

kind - - Type of transfer

stream - - Stream identifier

Returns:

::cudaSuccess, ::cudaErrorInvalidValue, ::cudaErrorInvalidMemcpyDirection \notefnerr \note_async \note_null_stream \note_init_rt \note_callback

cudaMemcpyAsync

@Cast("cudaError_t")
public static int cudaMemcpyAsync(Pointer dst,
                                  @Const
                                  Pointer src,
                                  @Cast("size_t")
                                  long count,
                                  @Cast("cudaMemcpyKind")
                                  int kind)

cudaMemcpyPeerAsync
```
@Cast("cudaError_t")
public static int cudaMemcpyPeerAsync(Pointer dst,
                                      int dstDevice,
                                      @Const
                                      Pointer src,
                                      int srcDevice,
                                      @Cast("size_t")
                                      long count,
                                      CUstream_st stream)
```
\brief Copies memory between two devices asynchronously. Copies memory from one device to memory on another device. \p dst is the base device pointer of the destination memory and \p dstDevice is the destination device. \p src is the base device pointer of the source memory and \p srcDevice is the source device. \p count specifies the number of bytes to copy. Note that this function is asynchronous with respect to the host and all work on other devices.

Parameters:

dst - - Destination device pointer

dstDevice - - Destination device

src - - Source device pointer

srcDevice - - Source device

count - - Size of memory copy in bytes

stream - - Stream identifier

Returns:

::cudaSuccess, ::cudaErrorInvalidValue, ::cudaErrorInvalidDevice \notefnerr \note_async \note_null_stream \note_init_rt \note_callback

cudaMemcpyPeerAsync

@Cast("cudaError_t")
public static int cudaMemcpyPeerAsync(Pointer dst,
                                      int dstDevice,
                                      @Const
                                      Pointer src,
                                      int srcDevice,
                                      @Cast("size_t")
                                      long count)

cudaMemcpy2DAsync
```
@Cast("cudaError_t")
public static int cudaMemcpy2DAsync(Pointer dst,
                                    @Cast("size_t")
                                    long dpitch,
                                    @Const
                                    Pointer src,
                                    @Cast("size_t")
                                    long spitch,
                                    @Cast("size_t")
                                    long width,
                                    @Cast("size_t")
                                    long height,
                                    @Cast("cudaMemcpyKind")
                                    int kind,
                                    CUstream_st stream)
```
\brief Copies data between host and device Copies a matrix (\p height rows of \p width bytes each) from the memory area pointed to by \p src to the memory area pointed to by \p dst, where \p kind specifies the direction of the copy, and must be one of ::cudaMemcpyHostToHost, ::cudaMemcpyHostToDevice, ::cudaMemcpyDeviceToHost, ::cudaMemcpyDeviceToDevice, or ::cudaMemcpyDefault. Passing ::cudaMemcpyDefault is recommended, in which case the type of transfer is inferred from the pointer values. However, ::cudaMemcpyDefault is only allowed on systems that support unified virtual addressing. \p dpitch and \p spitch are the widths in memory in bytes of the 2D arrays pointed to by \p dst and \p src, including any padding added to the end of each row. The memory areas may not overlap. \p width must not exceed either \p dpitch or \p spitch. Calling ::cudaMemcpy2DAsync() with \p dst and \p src pointers that do not match the direction of the copy results in an undefined behavior. ::cudaMemcpy2DAsync() returns an error if \p dpitch or \p spitch is greater than the maximum allowed. ::cudaMemcpy2DAsync() is asynchronous with respect to the host, so the call may return before the copy is complete. The copy can optionally be associated to a stream by passing a non-zero \p stream argument. If \p kind is ::cudaMemcpyHostToDevice or ::cudaMemcpyDeviceToHost and \p stream is non-zero, the copy may overlap with operations in other streams. The device version of this function only handles device to device copies and cannot be given local or shared pointers.

Parameters:

dst - - Destination memory address

dpitch - - Pitch of destination memory

src - - Source memory address

spitch - - Pitch of source memory

width - - Width of matrix transfer (columns in bytes)

height - - Height of matrix transfer (rows)

kind - - Type of transfer

stream - - Stream identifier

Returns:

::cudaSuccess, ::cudaErrorInvalidValue, ::cudaErrorInvalidPitchValue, ::cudaErrorInvalidMemcpyDirection \notefnerr \note_async \note_null_stream \note_init_rt \note_callback

cudaMemcpy2DAsync

@Cast("cudaError_t")
public static int cudaMemcpy2DAsync(Pointer dst,
                                    @Cast("size_t")
                                    long dpitch,
                                    @Const
                                    Pointer src,
                                    @Cast("size_t")
                                    long spitch,
                                    @Cast("size_t")
                                    long width,
                                    @Cast("size_t")
                                    long height,
                                    @Cast("cudaMemcpyKind")
                                    int kind)

cudaMemcpy2DToArrayAsync
```
@Cast("cudaError_t")
public static int cudaMemcpy2DToArrayAsync(cudaArray dst,
                                           @Cast("size_t")
                                           long wOffset,
                                           @Cast("size_t")
                                           long hOffset,
                                           @Const
                                           Pointer src,
                                           @Cast("size_t")
                                           long spitch,
                                           @Cast("size_t")
                                           long width,
                                           @Cast("size_t")
                                           long height,
                                           @Cast("cudaMemcpyKind")
                                           int kind,
                                           CUstream_st stream)
```
\brief Copies data between host and device Copies a matrix (\p height rows of \p width bytes each) from the memory area pointed to by \p src to the CUDA array \p dst starting at the upper left corner (\p wOffset, \p hOffset) where \p kind specifies the direction of the copy, and must be one of ::cudaMemcpyHostToHost, ::cudaMemcpyHostToDevice, ::cudaMemcpyDeviceToHost, ::cudaMemcpyDeviceToDevice, or ::cudaMemcpyDefault. Passing ::cudaMemcpyDefault is recommended, in which case the type of transfer is inferred from the pointer values. However, ::cudaMemcpyDefault is only allowed on systems that support unified virtual addressing. \p spitch is the width in memory in bytes of the 2D array pointed to by \p src, including any padding added to the end of each row. \p wOffset + \p width must not exceed the width of the CUDA array \p dst. \p width must not exceed \p spitch. ::cudaMemcpy2DToArrayAsync() returns an error if \p spitch exceeds the maximum allowed. ::cudaMemcpy2DToArrayAsync() is asynchronous with respect to the host, so the call may return before the copy is complete. The copy can optionally be associated to a stream by passing a non-zero \p stream argument. If \p kind is ::cudaMemcpyHostToDevice or ::cudaMemcpyDeviceToHost and \p stream is non-zero, the copy may overlap with operations in other streams.

Parameters:

dst - - Destination memory address

wOffset - - Destination starting X offset

hOffset - - Destination starting Y offset

src - - Source memory address

spitch - - Pitch of source memory

width - - Width of matrix transfer (columns in bytes)

height - - Height of matrix transfer (rows)

kind - - Type of transfer

stream - - Stream identifier

Returns:

::cudaSuccess, ::cudaErrorInvalidValue, ::cudaErrorInvalidPitchValue, ::cudaErrorInvalidMemcpyDirection \notefnerr \note_async \note_null_stream \note_init_rt \note_callback

cudaMemcpy2DToArrayAsync

@Cast("cudaError_t")
public static int cudaMemcpy2DToArrayAsync(cudaArray dst,
                                           @Cast("size_t")
                                           long wOffset,
                                           @Cast("size_t")
                                           long hOffset,
                                           @Const
                                           Pointer src,
                                           @Cast("size_t")
                                           long spitch,
                                           @Cast("size_t")
                                           long width,
                                           @Cast("size_t")
                                           long height,
                                           @Cast("cudaMemcpyKind")
                                           int kind)

cudaMemcpy2DFromArrayAsync
```
@Cast("cudaError_t")
public static int cudaMemcpy2DFromArrayAsync(Pointer dst,
                                             @Cast("size_t")
                                             long dpitch,
                                             cudaArray src,
                                             @Cast("size_t")
                                             long wOffset,
                                             @Cast("size_t")
                                             long hOffset,
                                             @Cast("size_t")
                                             long width,
                                             @Cast("size_t")
                                             long height,
                                             @Cast("cudaMemcpyKind")
                                             int kind,
                                             CUstream_st stream)
```
\brief Copies data between host and device Copies a matrix (\p height rows of \p width bytes each) from the CUDA array \p srcArray starting at the upper left corner (\p wOffset, \p hOffset) to the memory area pointed to by \p dst, where \p kind specifies the direction of the copy, and must be one of ::cudaMemcpyHostToHost, ::cudaMemcpyHostToDevice, ::cudaMemcpyDeviceToHost, ::cudaMemcpyDeviceToDevice, or ::cudaMemcpyDefault. Passing ::cudaMemcpyDefault is recommended, in which case the type of transfer is inferred from the pointer values. However, ::cudaMemcpyDefault is only allowed on systems that support unified virtual addressing. \p dpitch is the width in memory in bytes of the 2D array pointed to by \p dst, including any padding added to the end of each row. \p wOffset + \p width must not exceed the width of the CUDA array \p src. \p width must not exceed \p dpitch. ::cudaMemcpy2DFromArrayAsync() returns an error if \p dpitch exceeds the maximum allowed. ::cudaMemcpy2DFromArrayAsync() is asynchronous with respect to the host, so the call may return before the copy is complete. The copy can optionally be associated to a stream by passing a non-zero \p stream argument. If \p kind is ::cudaMemcpyHostToDevice or ::cudaMemcpyDeviceToHost and \p stream is non-zero, the copy may overlap with operations in other streams.

Parameters:

dst - - Destination memory address

dpitch - - Pitch of destination memory

src - - Source memory address

wOffset - - Source starting X offset

hOffset - - Source starting Y offset

width - - Width of matrix transfer (columns in bytes)

height - - Height of matrix transfer (rows)

kind - - Type of transfer

stream - - Stream identifier

Returns:

::cudaSuccess, ::cudaErrorInvalidValue, ::cudaErrorInvalidPitchValue, ::cudaErrorInvalidMemcpyDirection \notefnerr \note_async \note_null_stream \note_init_rt \note_callback

cudaMemcpy2DFromArrayAsync

@Cast("cudaError_t")
public static int cudaMemcpy2DFromArrayAsync(Pointer dst,
                                             @Cast("size_t")
                                             long dpitch,
                                             cudaArray src,
                                             @Cast("size_t")
                                             long wOffset,
                                             @Cast("size_t")
                                             long hOffset,
                                             @Cast("size_t")
                                             long width,
                                             @Cast("size_t")
                                             long height,
                                             @Cast("cudaMemcpyKind")
                                             int kind)

cudaMemcpyToSymbolAsync
```
@Cast("cudaError_t")
public static int cudaMemcpyToSymbolAsync(@Const
                                          Pointer symbol,
                                          @Const
                                          Pointer src,
                                          @Cast("size_t")
                                          long count,
                                          @Cast("size_t")
                                          long offset,
                                          @Cast("cudaMemcpyKind")
                                          int kind,
                                          CUstream_st stream)
```
\brief Copies data to the given symbol on the device Copies \p count bytes from the memory area pointed to by \p src to the memory area pointed to by \p offset bytes from the start of symbol \p symbol. The memory areas may not overlap. \p symbol is a variable that resides in global or constant memory space. \p kind can be either ::cudaMemcpyHostToDevice, ::cudaMemcpyDeviceToDevice, or ::cudaMemcpyDefault. Passing ::cudaMemcpyDefault is recommended, in which case the type of transfer is inferred from the pointer values. However, ::cudaMemcpyDefault is only allowed on systems that support unified virtual addressing. ::cudaMemcpyToSymbolAsync() is asynchronous with respect to the host, so the call may return before the copy is complete. The copy can optionally be associated to a stream by passing a non-zero \p stream argument. If \p kind is ::cudaMemcpyHostToDevice and \p stream is non-zero, the copy may overlap with operations in other streams.

Parameters:

symbol - - Device symbol address

src - - Source memory address

count - - Size in bytes to copy

offset - - Offset from start of symbol in bytes

kind - - Type of transfer

stream - - Stream identifier

Returns:

::cudaSuccess, ::cudaErrorInvalidValue, ::cudaErrorInvalidSymbol, ::cudaErrorInvalidMemcpyDirection, ::cudaErrorNoKernelImageForDevice \notefnerr \note_async \note_null_stream \note_string_api_deprecation \note_init_rt \note_callback

cudaMemcpyToSymbolAsync

@Cast("cudaError_t")
public static int cudaMemcpyToSymbolAsync(@Const
                                          Pointer symbol,
                                          @Const
                                          Pointer src,
                                          @Cast("size_t")
                                          long count,
                                          @Cast("size_t")
                                          long offset,
                                          @Cast("cudaMemcpyKind")
                                          int kind)

cudaMemcpyFromSymbolAsync
```
@Cast("cudaError_t")
public static int cudaMemcpyFromSymbolAsync(Pointer dst,
                                            @Const
                                            Pointer symbol,
                                            @Cast("size_t")
                                            long count,
                                            @Cast("size_t")
                                            long offset,
                                            @Cast("cudaMemcpyKind")
                                            int kind,
                                            CUstream_st stream)
```
\brief Copies data from the given symbol on the device Copies \p count bytes from the memory area pointed to by \p offset bytes from the start of symbol \p symbol to the memory area pointed to by \p dst. The memory areas may not overlap. \p symbol is a variable that resides in global or constant memory space. \p kind can be either ::cudaMemcpyDeviceToHost, ::cudaMemcpyDeviceToDevice, or ::cudaMemcpyDefault. Passing ::cudaMemcpyDefault is recommended, in which case the type of transfer is inferred from the pointer values. However, ::cudaMemcpyDefault is only allowed on systems that support unified virtual addressing. ::cudaMemcpyFromSymbolAsync() is asynchronous with respect to the host, so the call may return before the copy is complete. The copy can optionally be associated to a stream by passing a non-zero \p stream argument. If \p kind is ::cudaMemcpyDeviceToHost and \p stream is non-zero, the copy may overlap with operations in other streams.

Parameters:

dst - - Destination memory address

symbol - - Device symbol address

count - - Size in bytes to copy

offset - - Offset from start of symbol in bytes

kind - - Type of transfer

stream - - Stream identifier

Returns:

::cudaSuccess, ::cudaErrorInvalidValue, ::cudaErrorInvalidSymbol, ::cudaErrorInvalidMemcpyDirection, ::cudaErrorNoKernelImageForDevice \notefnerr \note_async \note_null_stream \note_string_api_deprecation \note_init_rt \note_callback

cudaMemcpyFromSymbolAsync

@Cast("cudaError_t")
public static int cudaMemcpyFromSymbolAsync(Pointer dst,
                                            @Const
                                            Pointer symbol,
                                            @Cast("size_t")
                                            long count,
                                            @Cast("size_t")
                                            long offset,
                                            @Cast("cudaMemcpyKind")
                                            int kind)

cudaMemset
```
@Cast("cudaError_t")
public static int cudaMemset(Pointer devPtr,
                             int value,
                             @Cast("size_t")
                             long count)
```
\brief Initializes or sets device memory to a value Fills the first \p count bytes of the memory area pointed to by \p devPtr with the constant byte value \p value. Note that this function is asynchronous with respect to the host unless \p devPtr refers to pinned host memory.

Parameters:

devPtr - - Pointer to device memory

value - - Value to set for each byte of specified memory

count - - Size in bytes to set

Returns:

::cudaSuccess, ::cudaErrorInvalidValue, \notefnerr \note_memset \note_init_rt \note_callback

cudaMemset2D
```
@Cast("cudaError_t")
public static int cudaMemset2D(Pointer devPtr,
                               @Cast("size_t")
                               long pitch,
                               int value,
                               @Cast("size_t")
                               long width,
                               @Cast("size_t")
                               long height)
```
\brief Initializes or sets device memory to a value Sets to the specified value \p value a matrix (\p height rows of \p width bytes each) pointed to by \p dstPtr. \p pitch is the width in bytes of the 2D array pointed to by \p dstPtr, including any padding added to the end of each row. This function performs fastest when the pitch is one that has been passed back by ::cudaMallocPitch(). Note that this function is asynchronous with respect to the host unless \p devPtr refers to pinned host memory.

Parameters:

devPtr - - Pointer to 2D device memory

pitch - - Pitch in bytes of 2D device memory

value - - Value to set for each byte of specified memory

width - - Width of matrix set (columns in bytes)

height - - Height of matrix set (rows)

Returns:

::cudaSuccess, ::cudaErrorInvalidValue, \notefnerr \note_memset \note_init_rt \note_callback

cudaMemset3D
```
@Cast("cudaError_t")
public static int cudaMemset3D(@ByVal
                               cudaPitchedPtr pitchedDevPtr,
                               int value,
                               @ByVal
                               cudaExtent extent)
```
\brief Initializes or sets device memory to a value Initializes each element of a 3D array to the specified value \p value. The object to initialize is defined by \p pitchedDevPtr. The \p pitch field of \p pitchedDevPtr is the width in memory in bytes of the 3D array pointed to by \p pitchedDevPtr, including any padding added to the end of each row. The \p xsize field specifies the logical width of each row in bytes, while the \p ysize field specifies the height of each 2D slice in rows. The extents of the initialized region are specified as a \p width in bytes, a \p height in rows, and a \p depth in slices. Extents with \p width greater than or equal to the \p xsize of \p pitchedDevPtr may perform significantly faster than extents narrower than the \p xsize. Secondarily, extents with \p height equal to the \p ysize of \p pitchedDevPtr will perform faster than when the \p height is shorter than the \p ysize. This function performs fastest when the \p pitchedDevPtr has been allocated by ::cudaMalloc3D(). Note that this function is asynchronous with respect to the host unless \p pitchedDevPtr refers to pinned host memory.

Parameters:

pitchedDevPtr - - Pointer to pitched device memory

value - - Value to set for each byte of specified memory

extent - - Size parameters for where to set device memory (\p width field in bytes)

Returns:

::cudaSuccess, ::cudaErrorInvalidValue, \notefnerr \note_memset \note_init_rt \note_callback

cudaMemsetAsync
```
@Cast("cudaError_t")
public static int cudaMemsetAsync(Pointer devPtr,
                                  int value,
                                  @Cast("size_t")
                                  long count,
                                  CUstream_st stream)
```
\brief Initializes or sets device memory to a value Fills the first \p count bytes of the memory area pointed to by \p devPtr with the constant byte value \p value. ::cudaMemsetAsync() is asynchronous with respect to the host, so the call may return before the memset is complete. The operation can optionally be associated to a stream by passing a non-zero \p stream argument. If \p stream is non-zero, the operation may overlap with operations in other streams. The device version of this function only handles device to device copies and cannot be given local or shared pointers.

Parameters:

devPtr - - Pointer to device memory

value - - Value to set for each byte of specified memory

count - - Size in bytes to set

stream - - Stream identifier

Returns:

::cudaSuccess, ::cudaErrorInvalidValue, \notefnerr \note_memset \note_null_stream \note_init_rt \note_callback

cudaMemsetAsync

@Cast("cudaError_t")
public static int cudaMemsetAsync(Pointer devPtr,
                                  int value,
                                  @Cast("size_t")
                                  long count)

cudaMemset2DAsync
```
@Cast("cudaError_t")
public static int cudaMemset2DAsync(Pointer devPtr,
                                    @Cast("size_t")
                                    long pitch,
                                    int value,
                                    @Cast("size_t")
                                    long width,
                                    @Cast("size_t")
                                    long height,
                                    CUstream_st stream)
```
\brief Initializes or sets device memory to a value Sets to the specified value \p value a matrix (\p height rows of \p width bytes each) pointed to by \p dstPtr. \p pitch is the width in bytes of the 2D array pointed to by \p dstPtr, including any padding added to the end of each row. This function performs fastest when the pitch is one that has been passed back by ::cudaMallocPitch(). ::cudaMemset2DAsync() is asynchronous with respect to the host, so the call may return before the memset is complete. The operation can optionally be associated to a stream by passing a non-zero \p stream argument. If \p stream is non-zero, the operation may overlap with operations in other streams. The device version of this function only handles device to device copies and cannot be given local or shared pointers.

Parameters:

devPtr - - Pointer to 2D device memory

pitch - - Pitch in bytes of 2D device memory

value - - Value to set for each byte of specified memory

width - - Width of matrix set (columns in bytes)

height - - Height of matrix set (rows)

stream - - Stream identifier

Returns:

::cudaSuccess, ::cudaErrorInvalidValue, \notefnerr \note_memset \note_null_stream \note_init_rt \note_callback

cudaMemset2DAsync

@Cast("cudaError_t")
public static int cudaMemset2DAsync(Pointer devPtr,
                                    @Cast("size_t")
                                    long pitch,
                                    int value,
                                    @Cast("size_t")
                                    long width,
                                    @Cast("size_t")
                                    long height)

cudaMemset3DAsync
```
@Cast("cudaError_t")
public static int cudaMemset3DAsync(@ByVal
                                    cudaPitchedPtr pitchedDevPtr,
                                    int value,
                                    @ByVal
                                    cudaExtent extent,
                                    CUstream_st stream)
```
\brief Initializes or sets device memory to a value Initializes each element of a 3D array to the specified value \p value. The object to initialize is defined by \p pitchedDevPtr. The \p pitch field of \p pitchedDevPtr is the width in memory in bytes of the 3D array pointed to by \p pitchedDevPtr, including any padding added to the end of each row. The \p xsize field specifies the logical width of each row in bytes, while the \p ysize field specifies the height of each 2D slice in rows. The extents of the initialized region are specified as a \p width in bytes, a \p height in rows, and a \p depth in slices. Extents with \p width greater than or equal to the \p xsize of \p pitchedDevPtr may perform significantly faster than extents narrower than the \p xsize. Secondarily, extents with \p height equal to the \p ysize of \p pitchedDevPtr will perform faster than when the \p height is shorter than the \p ysize. This function performs fastest when the \p pitchedDevPtr has been allocated by ::cudaMalloc3D(). ::cudaMemset3DAsync() is asynchronous with respect to the host, so the call may return before the memset is complete. The operation can optionally be associated to a stream by passing a non-zero \p stream argument. If \p stream is non-zero, the operation may overlap with operations in other streams. The device version of this function only handles device to device copies and cannot be given local or shared pointers.

Parameters:

pitchedDevPtr - - Pointer to pitched device memory

value - - Value to set for each byte of specified memory

extent - - Size parameters for where to set device memory (\p width field in bytes)

stream - - Stream identifier

Returns:

::cudaSuccess, ::cudaErrorInvalidValue, \notefnerr \note_memset \note_null_stream \note_init_rt \note_callback

cudaMemset3DAsync

@Cast("cudaError_t")
public static int cudaMemset3DAsync(@ByVal
                                    cudaPitchedPtr pitchedDevPtr,
                                    int value,
                                    @ByVal
                                    cudaExtent extent)

cudaGetSymbolAddress
```
@Cast("cudaError_t")
public static int cudaGetSymbolAddress(@Cast("void**")
                                       PointerPointer devPtr,
                                       @Const
                                       Pointer symbol)
```
\brief Finds the address associated with a CUDA symbol Returns in \p *devPtr the address of symbol \p symbol on the device. \p symbol is a variable that resides in global or constant memory space. If \p symbol cannot be found, or if \p symbol is not declared in the global or constant memory space, \p *devPtr is unchanged and the error ::cudaErrorInvalidSymbol is returned.

Parameters:

devPtr - - Return device pointer associated with symbol

symbol - - Device symbol address

Returns:

::cudaSuccess, ::cudaErrorInvalidSymbol, ::cudaErrorNoKernelImageForDevice \notefnerr \note_string_api_deprecation \note_init_rt \note_callback

cudaGetSymbolAddress

@Cast("cudaError_t")
public static int cudaGetSymbolAddress(@Cast("void**") @ByPtrPtr
                                       Pointer devPtr,
                                       @Const
                                       Pointer symbol)

cudaGetSymbolSize
```
@Cast("cudaError_t")
public static int cudaGetSymbolSize(@Cast("size_t*")
                                    SizeTPointer size,
                                    @Const
                                    Pointer symbol)
```
\brief Finds the size of the object associated with a CUDA symbol Returns in \p *size the size of symbol \p symbol. \p symbol is a variable that resides in global or constant memory space. If \p symbol cannot be found, or if \p symbol is not declared in global or constant memory space, \p *size is unchanged and the error ::cudaErrorInvalidSymbol is returned.

Parameters:

size - - Size of object associated with symbol

symbol - - Device symbol address

Returns:

::cudaSuccess, ::cudaErrorInvalidSymbol, ::cudaErrorNoKernelImageForDevice \notefnerr \note_string_api_deprecation \note_init_rt \note_callback

cudaMemPrefetchAsync
```
@Cast("cudaError_t")
public static int cudaMemPrefetchAsync(@Const
                                       Pointer devPtr,
                                       @Cast("size_t")
                                       long count,
                                       int dstDevice,
                                       CUstream_st stream)
```
\brief Prefetches memory to the specified destination device Prefetches memory to the specified destination device. \p devPtr is the base device pointer of the memory to be prefetched and \p dstDevice is the destination device. \p count specifies the number of bytes to copy. \p stream is the stream in which the operation is enqueued. The memory range must refer to managed memory allocated via ::cudaMallocManaged or declared via __managed__ variables. Passing in cudaCpuDeviceId for \p dstDevice will prefetch the data to host memory. If \p dstDevice is a GPU, then the device attribute ::cudaDevAttrConcurrentManagedAccess must be non-zero. Additionally, \p stream must be associated with a device that has a non-zero value for the device attribute ::cudaDevAttrConcurrentManagedAccess. The start address and end address of the memory range will be rounded down and rounded up respectively to be aligned to CPU page size before the prefetch operation is enqueued in the stream. If no physical memory has been allocated for this region, then this memory region will be populated and mapped on the destination device. If there's insufficient memory to prefetch the desired region, the Unified Memory driver may evict pages from other ::cudaMallocManaged allocations to host memory in order to make room. Device memory allocated using ::cudaMalloc or ::cudaMallocArray will not be evicted. By default, any mappings to the previous location of the migrated pages are removed and mappings for the new location are only setup on \p dstDevice. The exact behavior however also depends on the settings applied to this memory range via ::cudaMemAdvise as described below: If ::cudaMemAdviseSetReadMostly was set on any subset of this memory range, then that subset will create a read-only copy of the pages on \p dstDevice. If ::cudaMemAdviseSetPreferredLocation was called on any subset of this memory range, then the pages will be migrated to \p dstDevice even if \p dstDevice is not the preferred location of any pages in the memory range. If ::cudaMemAdviseSetAccessedBy was called on any subset of this memory range, then mappings to those pages from all the appropriate processors are updated to refer to the new location if establishing such a mapping is possible. Otherwise, those mappings are cleared. Note that this API is not required for functionality and only serves to improve performance by allowing the application to migrate data to a suitable location before it is accessed. Memory accesses to this range are always coherent and are allowed even when the data is actively being migrated. Note that this function is asynchronous with respect to the host and all work on other devices.

Parameters:

devPtr - - Pointer to be prefetched

count - - Size in bytes

dstDevice - - Destination device to prefetch to

stream - - Stream to enqueue prefetch operation

Returns:

::cudaSuccess, ::cudaErrorInvalidValue, ::cudaErrorInvalidDevice \notefnerr \note_async \note_null_stream \note_init_rt \note_callback

cudaMemPrefetchAsync

@Cast("cudaError_t")
public static int cudaMemPrefetchAsync(@Const
                                       Pointer devPtr,
                                       @Cast("size_t")
                                       long count,
                                       int dstDevice)

cudaMemAdvise
```
@Cast("cudaError_t")
public static int cudaMemAdvise(@Const
                                Pointer devPtr,
                                @Cast("size_t")
                                long count,
                                @Cast("cudaMemoryAdvise")
                                int advice,
                                int device)
```
\brief Advise about the usage of a given memory range Advise the Unified Memory subsystem about the usage pattern for the memory range starting at \p devPtr with a size of \p count bytes. The start address and end address of the memory range will be rounded down and rounded up respectively to be aligned to CPU page size before the advice is applied. The memory range must refer to managed memory allocated via ::cudaMallocManaged or declared via __managed__ variables. The memory range could also refer to system-allocated pageable memory provided it represents a valid, host-accessible region of memory and all additional constraints imposed by \p advice as outlined below are also satisfied. Specifying an invalid system-allocated pageable memory range results in an error being returned. The \p advice parameter can take the following values: - ::cudaMemAdviseSetReadMostly: This implies that the data is mostly going to be read from and only occasionally written to. Any read accesses from any processor to this region will create a read-only copy of at least the accessed pages in that processor's memory. Additionally, if ::cudaMemPrefetchAsync is called on this region, it will create a read-only copy of the data on the destination processor. If any processor writes to this region, all copies of the corresponding page will be invalidated except for the one where the write occurred. The \p device argument is ignored for this advice. Note that for a page to be read-duplicated, the accessing processor must either be the CPU or a GPU that has a non-zero value for the device attribute ::cudaDevAttrConcurrentManagedAccess. Also, if a context is created on a device that does not have the device attribute ::cudaDevAttrConcurrentManagedAccess set, then read-duplication will not occur until all such contexts are destroyed. If the memory region refers to valid system-allocated pageable memory, then the accessing device must have a non-zero value for the device attribute ::cudaDevAttrPageableMemoryAccess for a read-only copy to be created on that device. Note however that if the accessing device also has a non-zero value for the device attribute ::cudaDevAttrPageableMemoryAccessUsesHostPageTables, then setting this advice will not create a read-only copy when that device accesses this memory region. - ::cudaMemAdviceUnsetReadMostly: Undoes the effect of ::cudaMemAdviceReadMostly and also prevents the Unified Memory driver from attempting heuristic read-duplication on the memory range. Any read-duplicated copies of the data will be collapsed into a single copy. The location for the collapsed copy will be the preferred location if the page has a preferred location and one of the read-duplicated copies was resident at that location. Otherwise, the location chosen is arbitrary. - ::cudaMemAdviseSetPreferredLocation: This advice sets the preferred location for the data to be the memory belonging to \p device. Passing in cudaCpuDeviceId for \p device sets the preferred location as host memory. If \p device is a GPU, then it must have a non-zero value for the device attribute ::cudaDevAttrConcurrentManagedAccess. Setting the preferred location does not cause data to migrate to that location immediately. Instead, it guides the migration policy when a fault occurs on that memory region. If the data is already in its preferred location and the faulting processor can establish a mapping without requiring the data to be migrated, then data migration will be avoided. On the other hand, if the data is not in its preferred location or if a direct mapping cannot be established, then it will be migrated to the processor accessing it. It is important to note that setting the preferred location does not prevent data prefetching done using ::cudaMemPrefetchAsync. Having a preferred location can override the page thrash detection and resolution logic in the Unified Memory driver. Normally, if a page is detected to be constantly thrashing between for example host and device memory, the page may eventually be pinned to host memory by the Unified Memory driver. But if the preferred location is set as device memory, then the page will continue to thrash indefinitely. If ::cudaMemAdviseSetReadMostly is also set on this memory region or any subset of it, then the policies associated with that advice will override the policies of this advice, unless read accesses from \p device will not result in a read-only copy being created on that device as outlined in description for the advice ::cudaMemAdviseSetReadMostly. If the memory region refers to valid system-allocated pageable memory, then \p device must have a non-zero value for the device attribute ::cudaDevAttrPageableMemoryAccess. Additionally, if \p device has a non-zero value for the device attribute ::cudaDevAttrPageableMemoryAccessUsesHostPageTables, then this call has no effect. Note however that this behavior may change in the future. - ::cudaMemAdviseUnsetPreferredLocation: Undoes the effect of ::cudaMemAdviseSetPreferredLocation and changes the preferred location to none. - ::cudaMemAdviseSetAccessedBy: This advice implies that the data will be accessed by \p device. Passing in ::cudaCpuDeviceId for \p device will set the advice for the CPU. If \p device is a GPU, then the device attribute ::cudaDevAttrConcurrentManagedAccess must be non-zero. This advice does not cause data migration and has no impact on the location of the data per se. Instead, it causes the data to always be mapped in the specified processor's page tables, as long as the location of the data permits a mapping to be established. If the data gets migrated for any reason, the mappings are updated accordingly. This advice is recommended in scenarios where data locality is not important, but avoiding faults is. Consider for example a system containing multiple GPUs with peer-to-peer access enabled, where the data located on one GPU is occasionally accessed by peer GPUs. In such scenarios, migrating data over to the other GPUs is not as important because the accesses are infrequent and the overhead of migration may be too high. But preventing faults can still help improve performance, and so having a mapping set up in advance is useful. Note that on CPU access of this data, the data may be migrated to host memory because the CPU typically cannot access device memory directly. Any GPU that had the ::cudaMemAdviceSetAccessedBy flag set for this data will now have its mapping updated to point to the page in host memory. If ::cudaMemAdviseSetReadMostly is also set on this memory region or any subset of it, then the policies associated with that advice will override the policies of this advice. Additionally, if the preferred location of this memory region or any subset of it is also \p device, then the policies associated with ::cudaMemAdviseSetPreferredLocation will override the policies of this advice. If the memory region refers to valid system-allocated pageable memory, then \p device must have a non-zero value for the device attribute ::cudaDevAttrPageableMemoryAccess. Additionally, if \p device has a non-zero value for the device attribute ::cudaDevAttrPageableMemoryAccessUsesHostPageTables, then this call has no effect. - ::cudaMemAdviseUnsetAccessedBy: Undoes the effect of ::cudaMemAdviseSetAccessedBy. Any mappings to the data from \p device may be removed at any time causing accesses to result in non-fatal page faults. If the memory region refers to valid system-allocated pageable memory, then \p device must have a non-zero value for the device attribute ::cudaDevAttrPageableMemoryAccess. Additionally, if \p device has a non-zero value for the device attribute ::cudaDevAttrPageableMemoryAccessUsesHostPageTables, then this call has no effect.

Parameters:

devPtr - - Pointer to memory to set the advice for

count - - Size in bytes of the memory range

advice - - Advice to be applied for the specified memory range

device - - Device to apply the advice for

Returns:

::cudaSuccess, ::cudaErrorInvalidValue, ::cudaErrorInvalidDevice \notefnerr \note_async \note_null_stream \note_init_rt \note_callback

cudaMemRangeGetAttribute
```
@Cast("cudaError_t")
public static int cudaMemRangeGetAttribute(Pointer data,
                                           @Cast("size_t")
                                           long dataSize,
                                           @Cast("cudaMemRangeAttribute")
                                           int attribute,
                                           @Const
                                           Pointer devPtr,
                                           @Cast("size_t")
                                           long count)
```
\brief Query an attribute of a given memory range Query an attribute about the memory range starting at \p devPtr with a size of \p count bytes. The memory range must refer to managed memory allocated via ::cudaMallocManaged or declared via __managed__ variables. The \p attribute parameter can take the following values: - ::cudaMemRangeAttributeReadMostly: If this attribute is specified, \p data will be interpreted as a 32-bit integer, and \p dataSize must be 4. The result returned will be 1 if all pages in the given memory range have read-duplication enabled, or 0 otherwise. - ::cudaMemRangeAttributePreferredLocation: If this attribute is specified, \p data will be interpreted as a 32-bit integer, and \p dataSize must be 4. The result returned will be a GPU device id if all pages in the memory range have that GPU as their preferred location, or it will be cudaCpuDeviceId if all pages in the memory range have the CPU as their preferred location, or it will be cudaInvalidDeviceId if either all the pages don't have the same preferred location or some of the pages don't have a preferred location at all. Note that the actual location of the pages in the memory range at the time of the query may be different from the preferred location. - ::cudaMemRangeAttributeAccessedBy: If this attribute is specified, \p data will be interpreted as an array of 32-bit integers, and \p dataSize must be a non-zero multiple of 4. The result returned will be a list of device ids that had ::cudaMemAdviceSetAccessedBy set for that entire memory range. If any device does not have that advice set for the entire memory range, that device will not be included. If \p data is larger than the number of devices that have that advice set for that memory range, cudaInvalidDeviceId will be returned in all the extra space provided. For ex., if \p dataSize is 12 (i.e. \p data has 3 elements) and only device 0 has the advice set, then the result returned will be { 0, cudaInvalidDeviceId, cudaInvalidDeviceId }. If \p data is smaller than the number of devices that have that advice set, then only as many devices will be returned as can fit in the array. There is no guarantee on which specific devices will be returned, however. - ::cudaMemRangeAttributeLastPrefetchLocation: If this attribute is specified, \p data will be interpreted as a 32-bit integer, and \p dataSize must be 4. The result returned will be the last location to which all pages in the memory range were prefetched explicitly via ::cudaMemPrefetchAsync. This will either be a GPU id or cudaCpuDeviceId depending on whether the last location for prefetch was a GPU or the CPU respectively. If any page in the memory range was never explicitly prefetched or if all pages were not prefetched to the same location, cudaInvalidDeviceId will be returned. Note that this simply returns the last location that the applicaton requested to prefetch the memory range to. It gives no indication as to whether the prefetch operation to that location has completed or even begun.

Parameters:

data - - A pointers to a memory location where the result of each attribute query will be written to.

dataSize - - Array containing the size of data

attribute - - The attribute to query

devPtr - - Start of the range to query

count - - Size of the range to query

Returns:

::cudaSuccess, ::cudaErrorInvalidValue \notefnerr \note_async \note_null_stream \note_init_rt \note_callback

cudaMemRangeGetAttributes
```
@Cast("cudaError_t")
public static int cudaMemRangeGetAttributes(@Cast("void**")
                                            PointerPointer data,
                                            @Cast("size_t*")
                                            SizeTPointer dataSizes,
                                            @Cast("cudaMemRangeAttribute*")
                                            IntPointer attributes,
                                            @Cast("size_t")
                                            long numAttributes,
                                            @Const
                                            Pointer devPtr,
                                            @Cast("size_t")
                                            long count)
```
\brief Query attributes of a given memory range. Query attributes of the memory range starting at \p devPtr with a size of \p count bytes. The memory range must refer to managed memory allocated via ::cudaMallocManaged or declared via __managed__ variables. The \p attributes array will be interpreted to have \p numAttributes entries. The \p dataSizes array will also be interpreted to have \p numAttributes entries. The results of the query will be stored in \p data. The list of supported attributes are given below. Please refer to ::cudaMemRangeGetAttribute for attribute descriptions and restrictions. - ::cudaMemRangeAttributeReadMostly - ::cudaMemRangeAttributePreferredLocation - ::cudaMemRangeAttributeAccessedBy - ::cudaMemRangeAttributeLastPrefetchLocation

Parameters:

data - - A two-dimensional array containing pointers to memory locations where the result of each attribute query will be written to.

dataSizes - - Array containing the sizes of each result

attributes - - An array of attributes to query (numAttributes and the number of attributes in this array should match)

numAttributes - - Number of attributes to query

devPtr - - Start of the range to query

count - - Size of the range to query

Returns:

::cudaSuccess, ::cudaErrorInvalidValue \notefnerr \note_init_rt \note_callback

cudaMemRangeGetAttributes

@Cast("cudaError_t")
public static int cudaMemRangeGetAttributes(@Cast("void**") @ByPtrPtr
                                            Pointer data,
                                            @Cast("size_t*")
                                            SizeTPointer dataSizes,
                                            @Cast("cudaMemRangeAttribute*")
                                            IntPointer attributes,
                                            @Cast("size_t")
                                            long numAttributes,
                                            @Const
                                            Pointer devPtr,
                                            @Cast("size_t")
                                            long count)

cudaMemRangeGetAttributes

@Cast("cudaError_t")
public static int cudaMemRangeGetAttributes(@Cast("void**") @ByPtrPtr
                                            Pointer data,
                                            @Cast("size_t*")
                                            SizeTPointer dataSizes,
                                            @Cast("cudaMemRangeAttribute*")
                                            IntBuffer attributes,
                                            @Cast("size_t")
                                            long numAttributes,
                                            @Const
                                            Pointer devPtr,
                                            @Cast("size_t")
                                            long count)

cudaMemRangeGetAttributes

@Cast("cudaError_t")
public static int cudaMemRangeGetAttributes(@Cast("void**") @ByPtrPtr
                                            Pointer data,
                                            @Cast("size_t*")
                                            SizeTPointer dataSizes,
                                            @Cast("cudaMemRangeAttribute*")
                                            int[] attributes,
                                            @Cast("size_t")
                                            long numAttributes,
                                            @Const
                                            Pointer devPtr,
                                            @Cast("size_t")
                                            long count)

cudaMemcpyToArray
```
@Cast("cudaError_t")
@Deprecated
public static int cudaMemcpyToArray(cudaArray dst,
                                    @Cast("size_t")
                                    long wOffset,
                                    @Cast("size_t")
                                    long hOffset,
                                    @Const
                                    Pointer src,
                                    @Cast("size_t")
                                    long count,
                                    @Cast("cudaMemcpyKind")
                                    int kind)
```
Deprecated.
Copies \p count bytes from the memory area pointed to by \p src to the CUDA array \p dst starting at the upper left corner (\p wOffset, \p hOffset), where \p kind specifies the direction of the copy, and must be one of ::cudaMemcpyHostToHost, ::cudaMemcpyHostToDevice, ::cudaMemcpyDeviceToHost, ::cudaMemcpyDeviceToDevice, or ::cudaMemcpyDefault. Passing ::cudaMemcpyDefault is recommended, in which case the type of transfer is inferred from the pointer values. However, ::cudaMemcpyDefault is only allowed on systems that support unified virtual addressing.

\brief Copies data between host and device

Parameters:

dst - - Destination memory address

wOffset - - Destination starting X offset

hOffset - - Destination starting Y offset

src - - Source memory address

count - - Size in bytes to copy

kind - - Type of transfer

Returns:

::cudaSuccess, ::cudaErrorInvalidValue, ::cudaErrorInvalidMemcpyDirection \notefnerr \note_sync \note_init_rt \note_callback

cudaMemcpyFromArray
```
@Cast("cudaError_t")
@Deprecated
public static int cudaMemcpyFromArray(Pointer dst,
                                      cudaArray src,
                                      @Cast("size_t")
                                      long wOffset,
                                      @Cast("size_t")
                                      long hOffset,
                                      @Cast("size_t")
                                      long count,
                                      @Cast("cudaMemcpyKind")
                                      int kind)
```
Deprecated.
Copies \p count bytes from the CUDA array \p src starting at the upper left corner (\p wOffset, hOffset) to the memory area pointed to by \p dst, where \p kind specifies the direction of the copy, and must be one of ::cudaMemcpyHostToHost, ::cudaMemcpyHostToDevice, ::cudaMemcpyDeviceToHost, ::cudaMemcpyDeviceToDevice, or ::cudaMemcpyDefault. Passing ::cudaMemcpyDefault is recommended, in which case the type of transfer is inferred from the pointer values. However, ::cudaMemcpyDefault is only allowed on systems that support unified virtual addressing.

\brief Copies data between host and device

Parameters:

dst - - Destination memory address

src - - Source memory address

wOffset - - Source starting X offset

hOffset - - Source starting Y offset

count - - Size in bytes to copy

kind - - Type of transfer

Returns:

::cudaSuccess, ::cudaErrorInvalidValue, ::cudaErrorInvalidMemcpyDirection \notefnerr \note_sync \note_init_rt \note_callback

cudaMemcpyArrayToArray

@Cast("cudaError_t")
@Deprecated
public static int cudaMemcpyArrayToArray(cudaArray dst,
                                         @Cast("size_t")
                                         long wOffsetDst,
                                         @Cast("size_t")
                                         long hOffsetDst,
                                         cudaArray src,
                                         @Cast("size_t")
                                         long wOffsetSrc,
                                         @Cast("size_t")
                                         long hOffsetSrc,
                                         @Cast("size_t")
                                         long count,
                                         @Cast("cudaMemcpyKind")
                                         int kind)

Deprecated.

Copies \p count bytes from the CUDA array \p src starting at the upper left corner (\p wOffsetSrc, \p hOffsetSrc) to the CUDA array \p dst starting at the upper left corner (\p wOffsetDst, \p hOffsetDst) where \p kind specifies the direction of the copy, and must be one of ::cudaMemcpyHostToHost, ::cudaMemcpyHostToDevice, ::cudaMemcpyDeviceToHost, ::cudaMemcpyDeviceToDevice, or ::cudaMemcpyDefault. Passing ::cudaMemcpyDefault is recommended, in which case the type of transfer is inferred from the pointer values. However, ::cudaMemcpyDefault is only allowed on systems that support unified virtual addressing.

\brief Copies data between host and device

Parameters:: dst - - Destination memory address; wOffsetDst - - Destination starting X offset; hOffsetDst - - Destination starting Y offset; src - - Source memory address; wOffsetSrc - - Source starting X offset; hOffsetSrc - - Source starting Y offset; count - - Size in bytes to copy; kind - - Type of transfer
Returns:: ::cudaSuccess, ::cudaErrorInvalidValue, ::cudaErrorInvalidMemcpyDirection \notefnerr \note_init_rt \note_callback

cudaMemcpyArrayToArray

@Cast("cudaError_t")
@Deprecated
public static int cudaMemcpyArrayToArray(cudaArray dst,
                                         @Cast("size_t")
                                         long wOffsetDst,
                                         @Cast("size_t")
                                         long hOffsetDst,
                                         cudaArray src,
                                         @Cast("size_t")
                                         long wOffsetSrc,
                                         @Cast("size_t")
                                         long hOffsetSrc,
                                         @Cast("size_t")
                                         long count)

Deprecated.

cudaMemcpyToArrayAsync
```
@Cast("cudaError_t")
@Deprecated
public static int cudaMemcpyToArrayAsync(cudaArray dst,
                                         @Cast("size_t")
                                         long wOffset,
                                         @Cast("size_t")
                                         long hOffset,
                                         @Const
                                         Pointer src,
                                         @Cast("size_t")
                                         long count,
                                         @Cast("cudaMemcpyKind")
                                         int kind,
                                         CUstream_st stream)
```
Deprecated.
Copies \p count bytes from the memory area pointed to by \p src to the CUDA array \p dst starting at the upper left corner (\p wOffset, \p hOffset), where \p kind specifies the direction of the copy, and must be one of ::cudaMemcpyHostToHost, ::cudaMemcpyHostToDevice, ::cudaMemcpyDeviceToHost, ::cudaMemcpyDeviceToDevice, or ::cudaMemcpyDefault. Passing ::cudaMemcpyDefault is recommended, in which case the type of transfer is inferred from the pointer values. However, ::cudaMemcpyDefault is only allowed on systems that support unified virtual addressing. ::cudaMemcpyToArrayAsync() is asynchronous with respect to the host, so the call may return before the copy is complete. The copy can optionally be associated to a stream by passing a non-zero \p stream argument. If \p kind is ::cudaMemcpyHostToDevice or ::cudaMemcpyDeviceToHost and \p stream is non-zero, the copy may overlap with operations in other streams.

\brief Copies data between host and device

Parameters:

dst - - Destination memory address

wOffset - - Destination starting X offset

hOffset - - Destination starting Y offset

src - - Source memory address

count - - Size in bytes to copy

kind - - Type of transfer

stream - - Stream identifier

Returns:

::cudaSuccess, ::cudaErrorInvalidValue, ::cudaErrorInvalidMemcpyDirection \notefnerr \note_async \note_null_stream \note_init_rt \note_callback

cudaMemcpyToArrayAsync

@Cast("cudaError_t")
@Deprecated
public static int cudaMemcpyToArrayAsync(cudaArray dst,
                                         @Cast("size_t")
                                         long wOffset,
                                         @Cast("size_t")
                                         long hOffset,
                                         @Const
                                         Pointer src,
                                         @Cast("size_t")
                                         long count,
                                         @Cast("cudaMemcpyKind")
                                         int kind)

Deprecated.

cudaMemcpyFromArrayAsync
```
@Cast("cudaError_t")
@Deprecated
public static int cudaMemcpyFromArrayAsync(Pointer dst,
                                           cudaArray src,
                                           @Cast("size_t")
                                           long wOffset,
                                           @Cast("size_t")
                                           long hOffset,
                                           @Cast("size_t")
                                           long count,
                                           @Cast("cudaMemcpyKind")
                                           int kind,
                                           CUstream_st stream)
```
Deprecated.
Copies \p count bytes from the CUDA array \p src starting at the upper left corner (\p wOffset, hOffset) to the memory area pointed to by \p dst, where \p kind specifies the direction of the copy, and must be one of ::cudaMemcpyHostToHost, ::cudaMemcpyHostToDevice, ::cudaMemcpyDeviceToHost, ::cudaMemcpyDeviceToDevice, or ::cudaMemcpyDefault. Passing ::cudaMemcpyDefault is recommended, in which case the type of transfer is inferred from the pointer values. However, ::cudaMemcpyDefault is only allowed on systems that support unified virtual addressing. ::cudaMemcpyFromArrayAsync() is asynchronous with respect to the host, so the call may return before the copy is complete. The copy can optionally be associated to a stream by passing a non-zero \p stream argument. If \p kind is ::cudaMemcpyHostToDevice or ::cudaMemcpyDeviceToHost and \p stream is non-zero, the copy may overlap with operations in other streams.

\brief Copies data between host and device

Parameters:

dst - - Destination memory address

src - - Source memory address

wOffset - - Source starting X offset

hOffset - - Source starting Y offset

count - - Size in bytes to copy

kind - - Type of transfer

stream - - Stream identifier

Returns:

::cudaSuccess, ::cudaErrorInvalidValue, ::cudaErrorInvalidMemcpyDirection \notefnerr \note_async \note_null_stream \note_init_rt \note_callback

cudaMemcpyFromArrayAsync

@Cast("cudaError_t")
@Deprecated
public static int cudaMemcpyFromArrayAsync(Pointer dst,
                                           cudaArray src,
                                           @Cast("size_t")
                                           long wOffset,
                                           @Cast("size_t")
                                           long hOffset,
                                           @Cast("size_t")
                                           long count,
                                           @Cast("cudaMemcpyKind")
                                           int kind)

Deprecated.

cudaPointerGetAttributes
```
@Cast("cudaError_t")
public static int cudaPointerGetAttributes(cudaPointerAttributes attributes,
                                           @Const
                                           Pointer ptr)
```
\brief Returns attributes about a specified pointer Returns in \p *attributes the attributes of the pointer \p ptr. If pointer was not allocated in, mapped by or registered with context supporting unified addressing ::cudaErrorInvalidValue is returned. \note In CUDA 11.0 forward passing host pointer will return ::cudaMemoryTypeUnregistered in ::cudaPointerAttributes::type and call will return ::cudaSuccess. The ::cudaPointerAttributes structure is defined as:
```
    struct cudaPointerAttributes {
        enum cudaMemoryType memoryType;
        enum cudaMemoryType type;
        int device;
        void *devicePointer;
        void *hostPointer;
        int isManaged;
    }
    
```
In this structure, the individual fields mean - \ref ::cudaPointerAttributes::memoryType identifies the location of the memory associated with pointer \p ptr. It can be ::cudaMemoryTypeHost for host memory or ::cudaMemoryTypeDevice for device and managed memory. It has been deprecated in favour of ::cudaPointerAttributes::type. - \ref ::cudaPointerAttributes::type identifies type of memory. It can be ::cudaMemoryTypeUnregistered for unregistered host memory, ::cudaMemoryTypeHost for registered host memory, ::cudaMemoryTypeDevice for device memory or ::cudaMemoryTypeManaged for managed memory. - \ref ::cudaPointerAttributes::device "device" is the device against which \p ptr was allocated. If \p ptr has memory type ::cudaMemoryTypeDevice then this identifies the device on which the memory referred to by \p ptr physically resides. If \p ptr has memory type ::cudaMemoryTypeHost then this identifies the device which was current when the allocation was made (and if that device is deinitialized then this allocation will vanish with that device's state). - \ref ::cudaPointerAttributes::devicePointer "devicePointer" is the device pointer alias through which the memory referred to by \p ptr may be accessed on the current device. If the memory referred to by \p ptr cannot be accessed directly by the current device then this is NULL. - \ref ::cudaPointerAttributes::hostPointer "hostPointer" is the host pointer alias through which the memory referred to by \p ptr may be accessed on the host. If the memory referred to by \p ptr cannot be accessed directly by the host then this is NULL. - \ref ::cudaPointerAttributes::isManaged "isManaged" indicates if the pointer \p ptr points to managed memory or not. It has been deprecated in favour of ::cudaPointerAttributes::type.
Parameters:

attributes - - Attributes for the specified pointer

ptr - - Pointer to get attributes for

Returns:

::cudaSuccess, ::cudaErrorInvalidDevice, ::cudaErrorInvalidValue \note_init_rt \note_callback

cudaDeviceCanAccessPeer
```
@Cast("cudaError_t")
public static int cudaDeviceCanAccessPeer(IntPointer canAccessPeer,
                                          int device,
                                          int peerDevice)
```
\brief Queries if a device may directly access a peer device's memory. Returns in \p *canAccessPeer a value of 1 if device \p device is capable of directly accessing memory from \p peerDevice and 0 otherwise. If direct access of \p peerDevice from \p device is possible, then access may be enabled by calling ::cudaDeviceEnablePeerAccess().

Parameters:

canAccessPeer - - Returned access capability

device - - Device from which allocations on \p peerDevice are to be directly accessed.

peerDevice - - Device on which the allocations to be directly accessed by \p device reside.

Returns:

::cudaSuccess, ::cudaErrorInvalidDevice \notefnerr \note_init_rt \note_callback

cudaDeviceCanAccessPeer

@Cast("cudaError_t")
public static int cudaDeviceCanAccessPeer(IntBuffer canAccessPeer,
                                          int device,
                                          int peerDevice)

cudaDeviceCanAccessPeer

@Cast("cudaError_t")
public static int cudaDeviceCanAccessPeer(int[] canAccessPeer,
                                          int device,
                                          int peerDevice)

cudaDeviceEnablePeerAccess
```
@Cast("cudaError_t")
public static int cudaDeviceEnablePeerAccess(int peerDevice,
                                             @Cast("unsigned int")
                                             int flags)
```
\brief Enables direct access to memory allocations on a peer device. On success, all allocations from \p peerDevice will immediately be accessible by the current device. They will remain accessible until access is explicitly disabled using ::cudaDeviceDisablePeerAccess() or either device is reset using ::cudaDeviceReset(). Note that access granted by this call is unidirectional and that in order to access memory on the current device from \p peerDevice, a separate symmetric call to ::cudaDeviceEnablePeerAccess() is required. Note that there are both device-wide and system-wide limitations per system configuration, as noted in the CUDA Programming Guide under the section "Peer-to-Peer Memory Access". Returns ::cudaErrorInvalidDevice if ::cudaDeviceCanAccessPeer() indicates that the current device cannot directly access memory from \p peerDevice. Returns ::cudaErrorPeerAccessAlreadyEnabled if direct access of \p peerDevice from the current device has already been enabled. Returns ::cudaErrorInvalidValue if \p flags is not 0.

Parameters:

peerDevice - - Peer device to enable direct access to from the current device

flags - - Reserved for future use and must be set to 0

Returns:

::cudaSuccess, ::cudaErrorInvalidDevice, ::cudaErrorPeerAccessAlreadyEnabled, ::cudaErrorInvalidValue \notefnerr \note_init_rt \note_callback

cudaDeviceDisablePeerAccess
```
@Cast("cudaError_t")
public static int cudaDeviceDisablePeerAccess(int peerDevice)
```
\brief Disables direct access to memory allocations on a peer device. Returns ::cudaErrorPeerAccessNotEnabled if direct access to memory on \p peerDevice has not yet been enabled from the current device.

Parameters:

peerDevice - - Peer device to disable direct access to

Returns:

::cudaSuccess, ::cudaErrorPeerAccessNotEnabled, ::cudaErrorInvalidDevice \notefnerr \note_init_rt \note_callback

cudaGraphicsUnregisterResource
```
@Cast("cudaError_t")
public static int cudaGraphicsUnregisterResource(cudaGraphicsResource resource)
```
\brief Unregisters a graphics resource for access by CUDA Unregisters the graphics resource \p resource so it is not accessible by CUDA unless registered again. If \p resource is invalid then ::cudaErrorInvalidResourceHandle is returned.

Parameters:

resource - - Resource to unregister

Returns:

::cudaSuccess, ::cudaErrorInvalidResourceHandle, ::cudaErrorUnknown \notefnerr \note_init_rt \note_callback

cudaGraphicsResourceSetMapFlags
```
@Cast("cudaError_t")
public static int cudaGraphicsResourceSetMapFlags(cudaGraphicsResource resource,
                                                  @Cast("unsigned int")
                                                  int flags)
```
\brief Set usage flags for mapping a graphics resource Set \p flags for mapping the graphics resource \p resource. Changes to \p flags will take effect the next time \p resource is mapped. The \p flags argument may be any of the following: - ::cudaGraphicsMapFlagsNone: Specifies no hints about how \p resource will be used. It is therefore assumed that CUDA may read from or write to \p resource. - ::cudaGraphicsMapFlagsReadOnly: Specifies that CUDA will not write to \p resource. - ::cudaGraphicsMapFlagsWriteDiscard: Specifies CUDA will not read from \p resource and will write over the entire contents of \p resource, so none of the data previously stored in \p resource will be preserved. If \p resource is presently mapped for access by CUDA then ::cudaErrorUnknown is returned. If \p flags is not one of the above values then ::cudaErrorInvalidValue is returned.

Parameters:

resource - - Registered resource to set flags for

flags - - Parameters for resource mapping

Returns:

::cudaSuccess, ::cudaErrorInvalidValue, ::cudaErrorInvalidResourceHandle, ::cudaErrorUnknown, \notefnerr \note_init_rt \note_callback

cudaGraphicsMapResources
```
@Cast("cudaError_t")
public static int cudaGraphicsMapResources(int count,
                                           @ByPtrPtr
                                           cudaGraphicsResource resources,
                                           CUstream_st stream)
```
\brief Map graphics resources for access by CUDA Maps the \p count graphics resources in \p resources for access by CUDA. The resources in \p resources may be accessed by CUDA until they are unmapped. The graphics API from which \p resources were registered should not access any resources while they are mapped by CUDA. If an application does so, the results are undefined. This function provides the synchronization guarantee that any graphics calls issued before ::cudaGraphicsMapResources() will complete before any subsequent CUDA work issued in \p stream begins. If \p resources contains any duplicate entries then ::cudaErrorInvalidResourceHandle is returned. If any of \p resources are presently mapped for access by CUDA then ::cudaErrorUnknown is returned.

Parameters:

count - - Number of resources to map

resources - - Resources to map for CUDA

stream - - Stream for synchronization

Returns:

::cudaSuccess, ::cudaErrorInvalidResourceHandle, ::cudaErrorUnknown \note_null_stream \notefnerr \note_init_rt \note_callback

cudaGraphicsMapResources

@Cast("cudaError_t")
public static int cudaGraphicsMapResources(int count,
                                           @ByPtrPtr
                                           cudaGraphicsResource resources)

cudaGraphicsUnmapResources
```
@Cast("cudaError_t")
public static int cudaGraphicsUnmapResources(int count,
                                             @ByPtrPtr
                                             cudaGraphicsResource resources,
                                             CUstream_st stream)
```
\brief Unmap graphics resources. Unmaps the \p count graphics resources in \p resources. Once unmapped, the resources in \p resources may not be accessed by CUDA until they are mapped again. This function provides the synchronization guarantee that any CUDA work issued in \p stream before ::cudaGraphicsUnmapResources() will complete before any subsequently issued graphics work begins. If \p resources contains any duplicate entries then ::cudaErrorInvalidResourceHandle is returned. If any of \p resources are not presently mapped for access by CUDA then ::cudaErrorUnknown is returned.

Parameters:

count - - Number of resources to unmap

resources - - Resources to unmap

stream - - Stream for synchronization

Returns:

::cudaSuccess, ::cudaErrorInvalidResourceHandle, ::cudaErrorUnknown \note_null_stream \notefnerr \note_init_rt \note_callback

cudaGraphicsUnmapResources

@Cast("cudaError_t")
public static int cudaGraphicsUnmapResources(int count,
                                             @ByPtrPtr
                                             cudaGraphicsResource resources)

cudaGraphicsResourceGetMappedPointer
```
@Cast("cudaError_t")
public static int cudaGraphicsResourceGetMappedPointer(@Cast("void**")
                                                       PointerPointer devPtr,
                                                       @Cast("size_t*")
                                                       SizeTPointer size,
                                                       cudaGraphicsResource resource)
```
\brief Get an device pointer through which to access a mapped graphics resource. Returns in \p *devPtr a pointer through which the mapped graphics resource \p resource may be accessed. Returns in \p *size the size of the memory in bytes which may be accessed from that pointer. The value set in \p devPtr may change every time that \p resource is mapped. If \p resource is not a buffer then it cannot be accessed via a pointer and ::cudaErrorUnknown is returned. If \p resource is not mapped then ::cudaErrorUnknown is returned. *

Parameters:

devPtr - - Returned pointer through which \p resource may be accessed

size - - Returned size of the buffer accessible starting at \p *devPtr

resource - - Mapped resource to access

Returns:

::cudaSuccess, ::cudaErrorInvalidValue, ::cudaErrorInvalidResourceHandle, ::cudaErrorUnknown \notefnerr \note_init_rt \note_callback

cudaGraphicsResourceGetMappedPointer

@Cast("cudaError_t")
public static int cudaGraphicsResourceGetMappedPointer(@Cast("void**") @ByPtrPtr
                                                       Pointer devPtr,
                                                       @Cast("size_t*")
                                                       SizeTPointer size,
                                                       cudaGraphicsResource resource)

cudaGraphicsSubResourceGetMappedArray
```
@Cast("cudaError_t")
public static int cudaGraphicsSubResourceGetMappedArray(@ByPtrPtr
                                                        cudaArray array,
                                                        cudaGraphicsResource resource,
                                                        @Cast("unsigned int")
                                                        int arrayIndex,
                                                        @Cast("unsigned int")
                                                        int mipLevel)
```
\brief Get an array through which to access a subresource of a mapped graphics resource. Returns in \p *array an array through which the subresource of the mapped graphics resource \p resource which corresponds to array index \p arrayIndex and mipmap level \p mipLevel may be accessed. The value set in \p array may change every time that \p resource is mapped. If \p resource is not a texture then it cannot be accessed via an array and ::cudaErrorUnknown is returned. If \p arrayIndex is not a valid array index for \p resource then ::cudaErrorInvalidValue is returned. If \p mipLevel is not a valid mipmap level for \p resource then ::cudaErrorInvalidValue is returned. If \p resource is not mapped then ::cudaErrorUnknown is returned.

Parameters:

array - - Returned array through which a subresource of \p resource may be accessed

resource - - Mapped resource to access

arrayIndex - - Array index for array textures or cubemap face index as defined by ::cudaGraphicsCubeFace for cubemap textures for the subresource to access

mipLevel - - Mipmap level for the subresource to access

Returns:

::cudaSuccess, ::cudaErrorInvalidValue, ::cudaErrorInvalidResourceHandle, ::cudaErrorUnknown \notefnerr \note_init_rt \note_callback

cudaGraphicsResourceGetMappedMipmappedArray
```
@Cast("cudaError_t")
public static int cudaGraphicsResourceGetMappedMipmappedArray(@ByPtrPtr
                                                              cudaMipmappedArray mipmappedArray,
                                                              cudaGraphicsResource resource)
```
\brief Get a mipmapped array through which to access a mapped graphics resource. Returns in \p *mipmappedArray a mipmapped array through which the mapped graphics resource \p resource may be accessed. The value set in \p mipmappedArray may change every time that \p resource is mapped. If \p resource is not a texture then it cannot be accessed via an array and ::cudaErrorUnknown is returned. If \p resource is not mapped then ::cudaErrorUnknown is returned.

Parameters:

mipmappedArray - - Returned mipmapped array through which \p resource may be accessed

resource - - Mapped resource to access

Returns:

::cudaSuccess, ::cudaErrorInvalidValue, ::cudaErrorInvalidResourceHandle, ::cudaErrorUnknown \notefnerr \note_init_rt \note_callback

cudaBindTexture
```
@Cast("cudaError_t")
public static int cudaBindTexture(@Cast("size_t*")
                                  SizeTPointer offset,
                                  @Const
                                  textureReference texref,
                                  @Const
                                  Pointer devPtr,
                                  @Const
                                  cudaChannelFormatDesc desc,
                                  @Cast("size_t")
                                  long size)
```
Deprecated.
Binds \p size bytes of the memory area pointed to by \p devPtr to the texture reference \p texref. \p desc describes how the memory is interpreted when fetching values from the texture. Any memory previously bound to \p texref is unbound. Since the hardware enforces an alignment requirement on texture base addresses, \ref ::cudaBindTexture(size_t*, const struct textureReference*, const void*, const struct cudaChannelFormatDesc*, size_t) "cudaBindTexture()" returns in \p *offset a byte offset that must be applied to texture fetches in order to read from the desired memory. This offset must be divided by the texel size and passed to kernels that read from the texture so they can be applied to the ::tex1Dfetch() function. If the device memory pointer was returned from ::cudaMalloc(), the offset is guaranteed to be 0 and NULL may be passed as the \p offset parameter. The total number of elements (or texels) in the linear address range cannot exceed ::cudaDeviceProp::maxTexture1DLinear[0]. The number of elements is computed as (\p size / elementSize), where elementSize is determined from \p desc.

\brief Binds a memory area to a texture

Parameters:

offset - - Offset in bytes

texref - - Texture to bind

devPtr - - Memory area on device

desc - - Channel format

size - - Size of the memory area pointed to by devPtr

Returns:

::cudaSuccess, ::cudaErrorInvalidValue, ::cudaErrorInvalidTexture \notefnerr \note_init_rt \note_callback

cudaBindTexture

@Cast("cudaError_t")
public static int cudaBindTexture(@Cast("size_t*")
                                  SizeTPointer offset,
                                  @Const
                                  textureReference texref,
                                  @Const
                                  Pointer devPtr,
                                  @Const
                                  cudaChannelFormatDesc desc)

cudaBindTexture2D
```
@Cast("cudaError_t")
public static int cudaBindTexture2D(@Cast("size_t*")
                                    SizeTPointer offset,
                                    @Const
                                    textureReference texref,
                                    @Const
                                    Pointer devPtr,
                                    @Const
                                    cudaChannelFormatDesc desc,
                                    @Cast("size_t")
                                    long width,
                                    @Cast("size_t")
                                    long height,
                                    @Cast("size_t")
                                    long pitch)
```
Deprecated.
Binds the 2D memory area pointed to by \p devPtr to the texture reference \p texref. The size of the area is constrained by \p width in texel units, \p height in texel units, and \p pitch in byte units. \p desc describes how the memory is interpreted when fetching values from the texture. Any memory previously bound to \p texref is unbound. Since the hardware enforces an alignment requirement on texture base addresses, ::cudaBindTexture2D() returns in \p *offset a byte offset that must be applied to texture fetches in order to read from the desired memory. This offset must be divided by the texel size and passed to kernels that read from the texture so they can be applied to the ::tex2D() function. If the device memory pointer was returned from ::cudaMalloc(), the offset is guaranteed to be 0 and NULL may be passed as the \p offset parameter. \p width and \p height, which are specified in elements (or texels), cannot exceed ::cudaDeviceProp::maxTexture2DLinear[0] and ::cudaDeviceProp::maxTexture2DLinear[1] respectively. \p pitch, which is specified in bytes, cannot exceed ::cudaDeviceProp::maxTexture2DLinear[2]. The driver returns ::cudaErrorInvalidValue if \p pitch is not a multiple of ::cudaDeviceProp::texturePitchAlignment.

\brief Binds a 2D memory area to a texture

Parameters:

offset - - Offset in bytes

texref - - Texture reference to bind

devPtr - - 2D memory area on device

desc - - Channel format

width - - Width in texel units

height - - Height in texel units

pitch - - Pitch in bytes

Returns:

::cudaSuccess, ::cudaErrorInvalidValue, ::cudaErrorInvalidTexture \notefnerr \note_init_rt \note_callback

cudaBindTextureToArray

@Cast("cudaError_t")
public static int cudaBindTextureToArray(@Const
                                         textureReference texref,
                                         cudaArray array,
                                         @Const
                                         cudaChannelFormatDesc desc)

Deprecated.

Binds the CUDA array \p array to the texture reference \p texref. \p desc describes how the memory is interpreted when fetching values from the texture. Any CUDA array previously bound to \p texref is unbound.

\brief Binds an array to a texture

Parameters:: texref - - Texture to bind; array - - Memory array on device; desc - - Channel format
Returns:: ::cudaSuccess, ::cudaErrorInvalidValue, ::cudaErrorInvalidTexture \notefnerr \note_init_rt \note_callback

cudaBindTextureToMipmappedArray

@Cast("cudaError_t")
public static int cudaBindTextureToMipmappedArray(@Const
                                                  textureReference texref,
                                                  cudaMipmappedArray mipmappedArray,
                                                  @Const
                                                  cudaChannelFormatDesc desc)

Deprecated.

Binds the CUDA mipmapped array \p mipmappedArray to the texture reference \p texref. \p desc describes how the memory is interpreted when fetching values from the texture. Any CUDA mipmapped array previously bound to \p texref is unbound.

\brief Binds a mipmapped array to a texture

Parameters:: texref - - Texture to bind; mipmappedArray - - Memory mipmapped array on device; desc - - Channel format
Returns:: ::cudaSuccess, ::cudaErrorInvalidValue, ::cudaErrorInvalidTexture \notefnerr \note_init_rt \note_callback

cudaUnbindTexture
```
@Cast("cudaError_t")
public static int cudaUnbindTexture(@Const
                                    textureReference texref)
```
Deprecated.
Unbinds the texture bound to \p texref. If \p texref is not currently bound, no operation is performed.

\brief Unbinds a texture

Parameters:

texref - - Texture to unbind

Returns:

::cudaSuccess, ::cudaErrorInvalidTexture \notefnerr \note_init_rt \note_callback

cudaGetTextureAlignmentOffset

@Cast("cudaError_t")
public static int cudaGetTextureAlignmentOffset(@Cast("size_t*")
                                                SizeTPointer offset,
                                                @Const
                                                textureReference texref)

Deprecated.

Returns in \p *offset the offset that was returned when texture reference \p texref was bound.

\brief Get the alignment offset of a texture

Parameters:: offset - - Offset of texture reference in bytes; texref - - Texture to get offset of
Returns:: ::cudaSuccess, ::cudaErrorInvalidTexture, ::cudaErrorInvalidTextureBinding \notefnerr \note_init_rt \note_callback

cudaGetTextureReference
```
@Cast("cudaError_t")
public static int cudaGetTextureReference(@Cast("const textureReference**")
                                          PointerPointer texref,
                                          @Const
                                          Pointer symbol)
```
Deprecated.
Returns in \p *texref the structure associated to the texture reference defined by symbol \p symbol.

\brief Get the texture reference associated with a symbol

Parameters:

texref - - Texture reference associated with symbol

symbol - - Texture to get reference for

Returns:

::cudaSuccess, ::cudaErrorInvalidTexture \notefnerr \note_string_api_deprecation_50 \note_init_rt \note_callback

cudaGetTextureReference

@Cast("cudaError_t")
public static int cudaGetTextureReference(@Const @ByPtrPtr
                                          textureReference texref,
                                          @Const
                                          Pointer symbol)

cudaBindSurfaceToArray

@Cast("cudaError_t")
public static int cudaBindSurfaceToArray(@Const
                                         surfaceReference surfref,
                                         cudaArray array,
                                         @Const
                                         cudaChannelFormatDesc desc)

Deprecated.

Binds the CUDA array \p array to the surface reference \p surfref. \p desc describes how the memory is interpreted when fetching values from the surface. Any CUDA array previously bound to \p surfref is unbound.

\brief Binds an array to a surface

Parameters:: surfref - - Surface to bind; array - - Memory array on device; desc - - Channel format
Returns:: ::cudaSuccess, ::cudaErrorInvalidValue, ::cudaErrorInvalidSurface \notefnerr \note_init_rt \note_callback

cudaGetSurfaceReference
```
@Cast("cudaError_t")
public static int cudaGetSurfaceReference(@Cast("const surfaceReference**")
                                          PointerPointer surfref,
                                          @Const
                                          Pointer symbol)
```
Deprecated.
Returns in \p *surfref the structure associated to the surface reference defined by symbol \p symbol.

\brief Get the surface reference associated with a symbol

Parameters:

surfref - - Surface reference associated with symbol

symbol - - Surface to get reference for

Returns:

::cudaSuccess, ::cudaErrorInvalidSurface \notefnerr \note_string_api_deprecation_50 \note_init_rt \note_callback

cudaGetSurfaceReference

@Cast("cudaError_t")
public static int cudaGetSurfaceReference(@Const @ByPtrPtr
                                          surfaceReference surfref,
                                          @Const
                                          Pointer symbol)

cudaGetChannelDesc
```
@Cast("cudaError_t")
public static int cudaGetChannelDesc(cudaChannelFormatDesc desc,
                                     cudaArray array)
```
\brief Get the channel descriptor of an array Returns in \p *desc the channel descriptor of the CUDA array \p array.

Parameters:

desc - - Channel format

array - - Memory array on device

Returns:

::cudaSuccess, ::cudaErrorInvalidValue \notefnerr \note_init_rt \note_callback

cudaCreateChannelDesc

@ByVal
public static cudaChannelFormatDesc cudaCreateChannelDesc(int x,
                                                          int y,
                                                          int z,
                                                          int w,
                                                          @Cast("cudaChannelFormatKind")
                                                          int f)

\brief Returns a channel descriptor using the specified format Returns a channel descriptor with format \p f and number of bits of each component \p x, \p y, \p z, and \p w. The ::cudaChannelFormatDesc is defined as:


  struct cudaChannelFormatDesc {
    int x, y, z, w;
    enum cudaChannelFormatKind f;
  };

where ::cudaChannelFormatKind is one of ::cudaChannelFormatKindSigned, ::cudaChannelFormatKindUnsigned, or ::cudaChannelFormatKindFloat.

Parameters:: x - - X component; y - - Y component; z - - Z component; w - - W component; f - - Channel format
Returns:: Channel descriptor with format \p f

cudaCreateTextureObject
```
@Cast("cudaError_t")
public static int cudaCreateTextureObject(@Cast("cudaTextureObject_t*")
                                          LongPointer pTexObject,
                                          @Const
                                          cudaResourceDesc pResDesc,
                                          @Const
                                          cudaTextureDesc pTexDesc,
                                          @Const
                                          cudaResourceViewDesc pResViewDesc)
```
\brief Creates a texture object Creates a texture object and returns it in \p pTexObject. \p pResDesc describes the data to texture from. \p pTexDesc describes how the data should be sampled. \p pResViewDesc is an optional argument that specifies an alternate format for the data described by \p pResDesc, and also describes the subresource region to restrict access to when texturing. \p pResViewDesc can only be specified if the type of resource is a CUDA array or a CUDA mipmapped array. Texture objects are only supported on devices of compute capability 3.0 or higher. Additionally, a texture object is an opaque value, and, as such, should only be accessed through CUDA API calls. The ::cudaResourceDesc structure is defined as:
```
        struct cudaResourceDesc {
            enum cudaResourceType resType;

            union {
                struct {
                    cudaArray_t array;
                } array;
                struct {
                    cudaMipmappedArray_t mipmap;
                } mipmap;
                struct {
                    void *devPtr;
                    struct cudaChannelFormatDesc desc;
                    size_t sizeInBytes;
                } linear;
                struct {
                    void *devPtr;
                    struct cudaChannelFormatDesc desc;
                    size_t width;
                    size_t height;
                    size_t pitchInBytes;
                } pitch2D;
            } res;
        };
 
```
where: - ::cudaResourceDesc::resType specifies the type of resource to texture from. CUresourceType is defined as:
```
        enum cudaResourceType {
            cudaResourceTypeArray          = 0x00,
            cudaResourceTypeMipmappedArray = 0x01,
            cudaResourceTypeLinear         = 0x02,
            cudaResourceTypePitch2D        = 0x03
        };
 
```
\par If ::cudaResourceDesc::resType is set to ::cudaResourceTypeArray, ::cudaResourceDesc::res::array::array must be set to a valid CUDA array handle. \par If ::cudaResourceDesc::resType is set to ::cudaResourceTypeMipmappedArray, ::cudaResourceDesc::res::mipmap::mipmap must be set to a valid CUDA mipmapped array handle and ::cudaTextureDesc::normalizedCoords must be set to true. \par If ::cudaResourceDesc::resType is set to ::cudaResourceTypeLinear, ::cudaResourceDesc::res::linear::devPtr must be set to a valid device pointer, that is aligned to ::cudaDeviceProp::textureAlignment. ::cudaResourceDesc::res::linear::desc describes the format and the number of components per array element. ::cudaResourceDesc::res::linear::sizeInBytes specifies the size of the array in bytes. The total number of elements in the linear address range cannot exceed ::cudaDeviceProp::maxTexture1DLinear. The number of elements is computed as (sizeInBytes / sizeof(desc)). \par If ::cudaResourceDesc::resType is set to ::cudaResourceTypePitch2D, ::cudaResourceDesc::res::pitch2D::devPtr must be set to a valid device pointer, that is aligned to ::cudaDeviceProp::textureAlignment. ::cudaResourceDesc::res::pitch2D::desc describes the format and the number of components per array element. ::cudaResourceDesc::res::pitch2D::width and ::cudaResourceDesc::res::pitch2D::height specify the width and height of the array in elements, and cannot exceed ::cudaDeviceProp::maxTexture2DLinear[0] and ::cudaDeviceProp::maxTexture2DLinear[1] respectively. ::cudaResourceDesc::res::pitch2D::pitchInBytes specifies the pitch between two rows in bytes and has to be aligned to ::cudaDeviceProp::texturePitchAlignment. Pitch cannot exceed ::cudaDeviceProp::maxTexture2DLinear[2]. The ::cudaTextureDesc struct is defined as
```
        struct cudaTextureDesc {
            enum cudaTextureAddressMode addressMode[3];
            enum cudaTextureFilterMode  filterMode;
            enum cudaTextureReadMode    readMode;
            int                         sRGB;
            float                       borderColor[4];
            int                         normalizedCoords;
            unsigned int                maxAnisotropy;
            enum cudaTextureFilterMode  mipmapFilterMode;
            float                       mipmapLevelBias;
            float                       minMipmapLevelClamp;
            float                       maxMipmapLevelClamp;
        };
 
```
where - ::cudaTextureDesc::addressMode specifies the addressing mode for each dimension of the texture data. ::cudaTextureAddressMode is defined as:
```
        enum cudaTextureAddressMode {
            cudaAddressModeWrap   = 0,
            cudaAddressModeClamp  = 1,
            cudaAddressModeMirror = 2,
            cudaAddressModeBorder = 3
        };
   
```
This is ignored if ::cudaResourceDesc::resType is ::cudaResourceTypeLinear. Also, if ::cudaTextureDesc::normalizedCoords is set to zero, ::cudaAddressModeWrap and ::cudaAddressModeMirror won't be supported and will be switched to ::cudaAddressModeClamp. - ::cudaTextureDesc::filterMode specifies the filtering mode to be used when fetching from the texture. ::cudaTextureFilterMode is defined as:
```
        enum cudaTextureFilterMode {
            cudaFilterModePoint  = 0,
            cudaFilterModeLinear = 1
        };
   
```
This is ignored if ::cudaResourceDesc::resType is ::cudaResourceTypeLinear. - ::cudaTextureDesc::readMode specifies whether integer data should be converted to floating point or not. ::cudaTextureReadMode is defined as:
```
        enum cudaTextureReadMode {
            cudaReadModeElementType     = 0,
            cudaReadModeNormalizedFloat = 1
        };
   
```
Note that this applies only to 8-bit and 16-bit integer formats. 32-bit integer format would not be promoted, regardless of whether or not this ::cudaTextureDesc::readMode is set ::cudaReadModeNormalizedFloat is specified. - ::cudaTextureDesc::sRGB specifies whether sRGB to linear conversion should be performed during texture fetch. - ::cudaTextureDesc::borderColor specifies the float values of color. where: ::cudaTextureDesc::borderColor[0] contains value of 'R', ::cudaTextureDesc::borderColor[1] contains value of 'G', ::cudaTextureDesc::borderColor[2] contains value of 'B', ::cudaTextureDesc::borderColor[3] contains value of 'A' Note that application using integer border color values will need to
these values to float. The values are set only when the addressing mode specified by ::cudaTextureDesc::addressMode is cudaAddressModeBorder. - ::cudaTextureDesc::normalizedCoords specifies whether the texture coordinates will be normalized or not. - ::cudaTextureDesc::maxAnisotropy specifies the maximum anistropy ratio to be used when doing anisotropic filtering. This value will be clamped to the range [1,16]. - ::cudaTextureDesc::mipmapFilterMode specifies the filter mode when the calculated mipmap level lies between two defined mipmap levels. - ::cudaTextureDesc::mipmapLevelBias specifies the offset to be applied to the calculated mipmap level. - ::cudaTextureDesc::minMipmapLevelClamp specifies the lower end of the mipmap level range to clamp access to. - ::cudaTextureDesc::maxMipmapLevelClamp specifies the upper end of the mipmap level range to clamp access to. The ::cudaResourceViewDesc struct is defined as
```
        struct cudaResourceViewDesc {
            enum cudaResourceViewFormat format;
            size_t                      width;
            size_t                      height;
            size_t                      depth;
            unsigned int                firstMipmapLevel;
            unsigned int                lastMipmapLevel;
            unsigned int                firstLayer;
            unsigned int                lastLayer;
        };
 
```
where: - ::cudaResourceViewDesc::format specifies how the data contained in the CUDA array or CUDA mipmapped array should be interpreted. Note that this can incur a change in size of the texture data. If the resource view format is a block compressed format, then the underlying CUDA array or CUDA mipmapped array has to have a 32-bit unsigned integer format with 2 or 4 channels, depending on the block compressed format. For ex., BC1 and BC4 require the underlying CUDA array to have a 32-bit unsigned int with 2 channels. The other BC formats require the underlying resource to have the same 32-bit unsigned int format but with 4 channels. - ::cudaResourceViewDesc::width specifies the new width of the texture data. If the resource view format is a block compressed format, this value has to be 4 times the original width of the resource. For non block compressed formats, this value has to be equal to that of the original resource. - ::cudaResourceViewDesc::height specifies the new height of the texture data. If the resource view format is a block compressed format, this value has to be 4 times the original height of the resource. For non block compressed formats, this value has to be equal to that of the original resource. - ::cudaResourceViewDesc::depth specifies the new depth of the texture data. This value has to be equal to that of the original resource. - ::cudaResourceViewDesc::firstMipmapLevel specifies the most detailed mipmap level. This will be the new mipmap level zero. For non-mipmapped resources, this value has to be zero.::cudaTextureDesc::minMipmapLevelClamp and ::cudaTextureDesc::maxMipmapLevelClamp will be relative to this value. For ex., if the firstMipmapLevel is set to 2, and a minMipmapLevelClamp of 1.2 is specified, then the actual minimum mipmap level clamp will be 3.2. - ::cudaResourceViewDesc::lastMipmapLevel specifies the least detailed mipmap level. For non-mipmapped resources, this value has to be zero. - ::cudaResourceViewDesc::firstLayer specifies the first layer index for layered textures. This will be the new layer zero. For non-layered resources, this value has to be zero. - ::cudaResourceViewDesc::lastLayer specifies the last layer index for layered textures. For non-layered resources, this value has to be zero.
Parameters:

pTexObject - - Texture object to create

pResDesc - - Resource descriptor

pTexDesc - - Texture descriptor

pResViewDesc - - Resource view descriptor

Returns:

::cudaSuccess, ::cudaErrorInvalidValue \note_init_rt \note_callback

cudaCreateTextureObject

@Cast("cudaError_t")
public static int cudaCreateTextureObject(@Cast("cudaTextureObject_t*")
                                          LongBuffer pTexObject,
                                          @Const
                                          cudaResourceDesc pResDesc,
                                          @Const
                                          cudaTextureDesc pTexDesc,
                                          @Const
                                          cudaResourceViewDesc pResViewDesc)

cudaCreateTextureObject

@Cast("cudaError_t")
public static int cudaCreateTextureObject(@Cast("cudaTextureObject_t*")
                                          long[] pTexObject,
                                          @Const
                                          cudaResourceDesc pResDesc,
                                          @Const
                                          cudaTextureDesc pTexDesc,
                                          @Const
                                          cudaResourceViewDesc pResViewDesc)

cudaDestroyTextureObject
```
@Cast("cudaError_t")
public static int cudaDestroyTextureObject(@Cast("cudaTextureObject_t")
                                           long texObject)
```
\brief Destroys a texture object Destroys the texture object specified by \p texObject.

Parameters:

texObject - - Texture object to destroy

Returns:

::cudaSuccess, ::cudaErrorInvalidValue \note_init_rt \note_callback

cudaGetTextureObjectResourceDesc
```
@Cast("cudaError_t")
public static int cudaGetTextureObjectResourceDesc(cudaResourceDesc pResDesc,
                                                   @Cast("cudaTextureObject_t")
                                                   long texObject)
```
\brief Returns a texture object's resource descriptor Returns the resource descriptor for the texture object specified by \p texObject.

Parameters:

pResDesc - - Resource descriptor

texObject - - Texture object

Returns:

::cudaSuccess, ::cudaErrorInvalidValue \note_init_rt \note_callback

cudaGetTextureObjectTextureDesc
```
@Cast("cudaError_t")
public static int cudaGetTextureObjectTextureDesc(cudaTextureDesc pTexDesc,
                                                  @Cast("cudaTextureObject_t")
                                                  long texObject)
```
\brief Returns a texture object's texture descriptor Returns the texture descriptor for the texture object specified by \p texObject.

Parameters:

pTexDesc - - Texture descriptor

texObject - - Texture object

Returns:

::cudaSuccess, ::cudaErrorInvalidValue \note_init_rt \note_callback

cudaGetTextureObjectResourceViewDesc
```
@Cast("cudaError_t")
public static int cudaGetTextureObjectResourceViewDesc(cudaResourceViewDesc pResViewDesc,
                                                       @Cast("cudaTextureObject_t")
                                                       long texObject)
```
\brief Returns a texture object's resource view descriptor Returns the resource view descriptor for the texture object specified by \p texObject. If no resource view was specified, ::cudaErrorInvalidValue is returned.

Parameters:

pResViewDesc - - Resource view descriptor

texObject - - Texture object

Returns:

::cudaSuccess, ::cudaErrorInvalidValue \note_init_rt \note_callback

cudaCreateSurfaceObject
```
@Cast("cudaError_t")
public static int cudaCreateSurfaceObject(@Cast("cudaSurfaceObject_t*")
                                          LongPointer pSurfObject,
                                          @Const
                                          cudaResourceDesc pResDesc)
```
\brief Creates a surface object Creates a surface object and returns it in \p pSurfObject. \p pResDesc describes the data to perform surface load/stores on. ::cudaResourceDesc::resType must be ::cudaResourceTypeArray and ::cudaResourceDesc::res::array::array must be set to a valid CUDA array handle. Surface objects are only supported on devices of compute capability 3.0 or higher. Additionally, a surface object is an opaque value, and, as such, should only be accessed through CUDA API calls.

Parameters:

pSurfObject - - Surface object to create

pResDesc - - Resource descriptor

Returns:

::cudaSuccess, ::cudaErrorInvalidValue, ::cudaErrorInvalidChannelDescriptor, ::cudaErrorInvalidResourceHandle \note_init_rt \note_callback

cudaCreateSurfaceObject

@Cast("cudaError_t")
public static int cudaCreateSurfaceObject(@Cast("cudaSurfaceObject_t*")
                                          LongBuffer pSurfObject,
                                          @Const
                                          cudaResourceDesc pResDesc)

cudaCreateSurfaceObject

@Cast("cudaError_t")
public static int cudaCreateSurfaceObject(@Cast("cudaSurfaceObject_t*")
                                          long[] pSurfObject,
                                          @Const
                                          cudaResourceDesc pResDesc)

cudaDestroySurfaceObject
```
@Cast("cudaError_t")
public static int cudaDestroySurfaceObject(@Cast("cudaSurfaceObject_t")
                                           long surfObject)
```
\brief Destroys a surface object Destroys the surface object specified by \p surfObject.

Parameters:

surfObject - - Surface object to destroy

Returns:

::cudaSuccess, ::cudaErrorInvalidValue \note_init_rt \note_callback

cudaGetSurfaceObjectResourceDesc
```
@Cast("cudaError_t")
public static int cudaGetSurfaceObjectResourceDesc(cudaResourceDesc pResDesc,
                                                   @Cast("cudaSurfaceObject_t")
                                                   long surfObject)
```
\brief Returns a surface object's resource descriptor Returns the resource descriptor for the surface object specified by \p surfObject.

Parameters:

pResDesc - - Resource descriptor

surfObject - - Surface object

Returns:

::cudaSuccess, ::cudaErrorInvalidValue \note_init_rt \note_callback

cudaDriverGetVersion
```
@Cast("cudaError_t")
public static int cudaDriverGetVersion(IntPointer driverVersion)
```
\brief Returns the latest version of CUDA supported by the driver Returns in \p *driverVersion the latest version of CUDA supported by the driver. The version is returned as (1000 × major + 10 × minor). For example, CUDA 9.2 would be represented by 9020. If no driver is installed, then 0 is returned as the driver version. This function automatically returns ::cudaErrorInvalidValue if \p driverVersion is NULL.

Parameters:

driverVersion - - Returns the CUDA driver version.

Returns:

::cudaSuccess, ::cudaErrorInvalidValue \notefnerr \note_init_rt \note_callback

cudaDriverGetVersion

@Cast("cudaError_t")
public static int cudaDriverGetVersion(IntBuffer driverVersion)

cudaDriverGetVersion

@Cast("cudaError_t")
public static int cudaDriverGetVersion(int[] driverVersion)

cudaRuntimeGetVersion
```
@Cast("cudaError_t")
public static int cudaRuntimeGetVersion(IntPointer runtimeVersion)
```
\brief Returns the CUDA Runtime version Returns in \p *runtimeVersion the version number of the current CUDA Runtime instance. The version is returned as (1000 × major + 10 × minor). For example, CUDA 9.2 would be represented by 9020. This function automatically returns ::cudaErrorInvalidValue if the \p runtimeVersion argument is NULL.

Parameters:

runtimeVersion - - Returns the CUDA Runtime version.

Returns:

::cudaSuccess, ::cudaErrorInvalidValue \note_init_rt \note_callback

cudaRuntimeGetVersion

@Cast("cudaError_t")
public static int cudaRuntimeGetVersion(IntBuffer runtimeVersion)

cudaRuntimeGetVersion

@Cast("cudaError_t")
public static int cudaRuntimeGetVersion(int[] runtimeVersion)

cudaGraphCreate
```
@Cast("cudaError_t")
public static int cudaGraphCreate(@ByPtrPtr
                                  CUgraph_st pGraph,
                                  @Cast("unsigned int")
                                  int flags)
```
\brief Creates a graph Creates an empty graph, which is returned via \p pGraph.

Parameters:

pGraph - - Returns newly created graph

flags - - Graph creation flags, must be 0

Returns:

::cudaSuccess, ::cudaErrorInvalidValue, ::cudaErrorMemoryAllocation \note_graph_thread_safety \notefnerr \note_init_rt \note_callback

cudaGraphAddKernelNode
```
@Cast("cudaError_t")
public static int cudaGraphAddKernelNode(@ByPtrPtr
                                         CUgraphNode_st pGraphNode,
                                         CUgraph_st graph,
                                         @Cast("const cudaGraphNode_t*") @ByPtrPtr
                                         CUgraphNode_st pDependencies,
                                         @Cast("size_t")
                                         long numDependencies,
                                         @Const
                                         cudaKernelNodeParams pNodeParams)
```
\brief Creates a kernel execution node and adds it to a graph Creates a new kernel execution node and adds it to \p graph with \p numDependencies dependencies specified via \p pDependencies and arguments specified in \p pNodeParams. It is possible for \p numDependencies to be 0, in which case the node will be placed at the root of the graph. \p pDependencies may not have any duplicate entries. A handle to the new node will be returned in \p pGraphNode. The cudaKernelNodeParams structure is defined as:
```
  struct cudaKernelNodeParams
  {
      void* func;
      dim3 gridDim;
      dim3 blockDim;
      unsigned int sharedMemBytes;
      void **kernelParams;
      void **extra;
  };
 
```
When the graph is launched, the node will invoke kernel \p func on a (\p gridDim.x x \p gridDim.y x \p gridDim.z) grid of blocks. Each block contains (\p blockDim.x x \p blockDim.y x \p blockDim.z) threads. \p sharedMem sets the amount of dynamic shared memory that will be available to each thread block. Kernel parameters to \p func can be specified in one of two ways: 1) Kernel parameters can be specified via \p kernelParams. If the kernel has N parameters, then \p kernelParams needs to be an array of N pointers. Each pointer, from \p kernelParams[0] to \p kernelParams[N-1], points to the region of memory from which the actual parameter will be copied. The number of kernel parameters and their offsets and sizes do not need to be specified as that information is retrieved directly from the kernel's image. 2) Kernel parameters can also be packaged by the application into a single buffer that is passed in via \p extra. This places the burden on the application of knowing each kernel parameter's size and alignment/padding within the buffer. The \p extra parameter exists to allow this function to take additional less commonly used arguments. \p extra specifies a list of names of extra settings and their corresponding values. Each extra setting name is immediately followed by the corresponding value. The list must be terminated with either NULL or CU_LAUNCH_PARAM_END. - ::CU_LAUNCH_PARAM_END, which indicates the end of the \p extra array; - ::CU_LAUNCH_PARAM_BUFFER_POINTER, which specifies that the next value in \p extra will be a pointer to a buffer containing all the kernel parameters for launching kernel \p func; - ::CU_LAUNCH_PARAM_BUFFER_SIZE, which specifies that the next value in \p extra will be a pointer to a size_t containing the size of the buffer specified with ::CU_LAUNCH_PARAM_BUFFER_POINTER; The error ::cudaErrorInvalidValue will be returned if kernel parameters are specified with both \p kernelParams and \p extra (i.e. both \p kernelParams and \p extra are non-NULL). The \p kernelParams or \p extra array, as well as the argument values it points to, are copied during this call. \note Kernels launched using graphs must not use texture and surface references. Reading or writing through any texture or surface reference is undefined behavior. This restriction does not apply to texture and surface objects.
Parameters:

pGraphNode - - Returns newly created node

graph - - Graph to which to add the node

pDependencies - - Dependencies of the node

numDependencies - - Number of dependencies

pNodeParams - - Parameters for the GPU execution node

Returns:

::cudaSuccess, ::cudaErrorInvalidValue, ::cudaErrorInvalidDeviceFunction \note_graph_thread_safety \notefnerr \note_init_rt \note_callback

cudaGraphKernelNodeGetParams
```
@Cast("cudaError_t")
public static int cudaGraphKernelNodeGetParams(CUgraphNode_st node,
                                               cudaKernelNodeParams pNodeParams)
```
\brief Returns a kernel node's parameters Returns the parameters of kernel node \p node in \p pNodeParams. The \p kernelParams or \p extra array returned in \p pNodeParams, as well as the argument values it points to, are owned by the node. This memory remains valid until the node is destroyed or its parameters are modified, and should not be modified directly. Use ::cudaGraphKernelNodeSetParams to update the parameters of this node. The params will contain either \p kernelParams or \p extra, according to which of these was most recently set on the node.

Parameters:

node - - Node to get the parameters for

pNodeParams - - Pointer to return the parameters

Returns:

::cudaSuccess, ::cudaErrorInvalidValue, ::cudaErrorInvalidDeviceFunction \note_graph_thread_safety \notefnerr \note_init_rt \note_callback

cudaGraphKernelNodeSetParams
```
@Cast("cudaError_t")
public static int cudaGraphKernelNodeSetParams(CUgraphNode_st node,
                                               @Const
                                               cudaKernelNodeParams pNodeParams)
```
\brief Sets a kernel node's parameters Sets the parameters of kernel node \p node to \p pNodeParams.

Parameters:

node - - Node to set the parameters for

pNodeParams - - Parameters to copy

Returns:

::cudaSuccess, ::cudaErrorInvalidValue, ::cudaErrorInvalidResourceHandle, ::cudaErrorMemoryAllocation \note_graph_thread_safety \notefnerr \note_init_rt \note_callback

cudaGraphAddMemcpyNode
```
@Cast("cudaError_t")
public static int cudaGraphAddMemcpyNode(@ByPtrPtr
                                         CUgraphNode_st pGraphNode,
                                         CUgraph_st graph,
                                         @Cast("const cudaGraphNode_t*") @ByPtrPtr
                                         CUgraphNode_st pDependencies,
                                         @Cast("size_t")
                                         long numDependencies,
                                         @Const
                                         cudaMemcpy3DParms pCopyParams)
```
\brief Creates a memcpy node and adds it to a graph Creates a new memcpy node and adds it to \p graph with \p numDependencies dependencies specified via \p pDependencies. It is possible for \p numDependencies to be 0, in which case the node will be placed at the root of the graph. \p pDependencies may not have any duplicate entries. A handle to the new node will be returned in \p pGraphNode. When the graph is launched, the node will perform the memcpy described by \p pCopyParams. See ::cudaMemcpy3D() for a description of the structure and its restrictions. Memcpy nodes have some additional restrictions with regards to managed memory, if the system contains at least one device which has a zero value for the device attribute ::cudaDevAttrConcurrentManagedAccess.

Parameters:

pGraphNode - - Returns newly created node

graph - - Graph to which to add the node

pDependencies - - Dependencies of the node

numDependencies - - Number of dependencies

pCopyParams - - Parameters for the memory copy

Returns:

::cudaSuccess, ::cudaErrorInvalidValue \note_graph_thread_safety \notefnerr \note_init_rt \note_callback

cudaGraphMemcpyNodeGetParams
```
@Cast("cudaError_t")
public static int cudaGraphMemcpyNodeGetParams(CUgraphNode_st node,
                                               cudaMemcpy3DParms pNodeParams)
```
\brief Returns a memcpy node's parameters Returns the parameters of memcpy node \p node in \p pNodeParams.

Parameters:

node - - Node to get the parameters for

pNodeParams - - Pointer to return the parameters

Returns:

::cudaSuccess, ::cudaErrorInvalidValue \note_graph_thread_safety \notefnerr \note_init_rt \note_callback

cudaGraphMemcpyNodeSetParams
```
@Cast("cudaError_t")
public static int cudaGraphMemcpyNodeSetParams(CUgraphNode_st node,
                                               @Const
                                               cudaMemcpy3DParms pNodeParams)
```
\brief Sets a memcpy node's parameters Sets the parameters of memcpy node \p node to \p pNodeParams.

Parameters:

node - - Node to set the parameters for

pNodeParams - - Parameters to copy

Returns:

::cudaSuccess, ::cudaErrorInvalidValue, \note_graph_thread_safety \notefnerr \note_init_rt \note_callback

cudaGraphAddMemsetNode
```
@Cast("cudaError_t")
public static int cudaGraphAddMemsetNode(@ByPtrPtr
                                         CUgraphNode_st pGraphNode,
                                         CUgraph_st graph,
                                         @Cast("const cudaGraphNode_t*") @ByPtrPtr
                                         CUgraphNode_st pDependencies,
                                         @Cast("size_t")
                                         long numDependencies,
                                         @Const
                                         cudaMemsetParams pMemsetParams)
```
\brief Creates a memset node and adds it to a graph Creates a new memset node and adds it to \p graph with \p numDependencies dependencies specified via \p pDependencies. It is possible for \p numDependencies to be 0, in which case the node will be placed at the root of the graph. \p pDependencies may not have any duplicate entries. A handle to the new node will be returned in \p pGraphNode. The element size must be 1, 2, or 4 bytes. When the graph is launched, the node will perform the memset described by \p pMemsetParams.

Parameters:

pGraphNode - - Returns newly created node

graph - - Graph to which to add the node

pDependencies - - Dependencies of the node

numDependencies - - Number of dependencies

pMemsetParams - - Parameters for the memory set

Returns:

::cudaSuccess, ::cudaErrorInvalidValue, ::cudaErrorInvalidDevice \note_graph_thread_safety \notefnerr \note_init_rt \note_callback

cudaGraphMemsetNodeGetParams
```
@Cast("cudaError_t")
public static int cudaGraphMemsetNodeGetParams(CUgraphNode_st node,
                                               cudaMemsetParams pNodeParams)
```
\brief Returns a memset node's parameters Returns the parameters of memset node \p node in \p pNodeParams.

Parameters:

node - - Node to get the parameters for

pNodeParams - - Pointer to return the parameters

Returns:

::cudaSuccess, ::cudaErrorInvalidValue \note_graph_thread_safety \notefnerr \note_init_rt \note_callback

cudaGraphMemsetNodeSetParams
```
@Cast("cudaError_t")
public static int cudaGraphMemsetNodeSetParams(CUgraphNode_st node,
                                               @Const
                                               cudaMemsetParams pNodeParams)
```
\brief Sets a memset node's parameters Sets the parameters of memset node \p node to \p pNodeParams.

Parameters:

node - - Node to set the parameters for

pNodeParams - - Parameters to copy

Returns:

::cudaSuccess, ::cudaErrorInvalidValue \note_graph_thread_safety \notefnerr \note_init_rt \note_callback

cudaGraphAddHostNode
```
@Cast("cudaError_t")
public static int cudaGraphAddHostNode(@ByPtrPtr
                                       CUgraphNode_st pGraphNode,
                                       CUgraph_st graph,
                                       @Cast("const cudaGraphNode_t*") @ByPtrPtr
                                       CUgraphNode_st pDependencies,
                                       @Cast("size_t")
                                       long numDependencies,
                                       @Const
                                       cudaHostNodeParams pNodeParams)
```
\brief Creates a host execution node and adds it to a graph Creates a new CPU execution node and adds it to \p graph with \p numDependencies dependencies specified via \p pDependencies and arguments specified in \p pNodeParams. It is possible for \p numDependencies to be 0, in which case the node will be placed at the root of the graph. \p pDependencies may not have any duplicate entries. A handle to the new node will be returned in \p pGraphNode. When the graph is launched, the node will invoke the specified CPU function. Host nodes are not supported under MPS with pre-Volta GPUs.

Parameters:

pGraphNode - - Returns newly created node

graph - - Graph to which to add the node

pDependencies - - Dependencies of the node

numDependencies - - Number of dependencies

pNodeParams - - Parameters for the host node

Returns:

::cudaSuccess, ::cudaErrorNotSupported, ::cudaErrorInvalidValue \note_graph_thread_safety \notefnerr \note_init_rt \note_callback

cudaGraphHostNodeGetParams
```
@Cast("cudaError_t")
public static int cudaGraphHostNodeGetParams(CUgraphNode_st node,
                                             cudaHostNodeParams pNodeParams)
```
\brief Returns a host node's parameters Returns the parameters of host node \p node in \p pNodeParams.

Parameters:

node - - Node to get the parameters for

pNodeParams - - Pointer to return the parameters

Returns:

::cudaSuccess, ::cudaErrorInvalidValue \note_graph_thread_safety \notefnerr \note_init_rt \note_callback

cudaGraphHostNodeSetParams
```
@Cast("cudaError_t")
public static int cudaGraphHostNodeSetParams(CUgraphNode_st node,
                                             @Const
                                             cudaHostNodeParams pNodeParams)
```
\brief Sets a host node's parameters Sets the parameters of host node \p node to \p nodeParams.

Parameters:

node - - Node to set the parameters for

pNodeParams - - Parameters to copy

Returns:

::cudaSuccess, ::cudaErrorInvalidValue \note_graph_thread_safety \notefnerr \note_init_rt \note_callback

cudaGraphAddChildGraphNode
```
@Cast("cudaError_t")
public static int cudaGraphAddChildGraphNode(@ByPtrPtr
                                             CUgraphNode_st pGraphNode,
                                             CUgraph_st graph,
                                             @Cast("const cudaGraphNode_t*") @ByPtrPtr
                                             CUgraphNode_st pDependencies,
                                             @Cast("size_t")
                                             long numDependencies,
                                             CUgraph_st childGraph)
```
\brief Creates a child graph node and adds it to a graph Creates a new node which executes an embedded graph, and adds it to \p graph with \p numDependencies dependencies specified via \p pDependencies. It is possible for \p numDependencies to be 0, in which case the node will be placed at the root of the graph. \p pDependencies may not have any duplicate entries. A handle to the new node will be returned in \p pGraphNode. The node executes an embedded child graph. The child graph is cloned in this call.

Parameters:

pGraphNode - - Returns newly created node

graph - - Graph to which to add the node

pDependencies - - Dependencies of the node

numDependencies - - Number of dependencies

childGraph - - The graph to clone into this node

Returns:

::cudaSuccess, ::cudaErrorInvalidValue \note_graph_thread_safety \notefnerr \note_init_rt \note_callback

cudaGraphChildGraphNodeGetGraph
```
@Cast("cudaError_t")
public static int cudaGraphChildGraphNodeGetGraph(CUgraphNode_st node,
                                                  @ByPtrPtr
                                                  CUgraph_st pGraph)
```
\brief Gets a handle to the embedded graph of a child graph node Gets a handle to the embedded graph in a child graph node. This call does not clone the graph. Changes to the graph will be reflected in the node, and the node retains ownership of the graph.

Parameters:

node - - Node to get the embedded graph for

pGraph - - Location to store a handle to the graph

Returns:

::cudaSuccess, ::cudaErrorInvalidValue \note_graph_thread_safety \notefnerr \note_init_rt \note_callback

cudaGraphAddEmptyNode
```
@Cast("cudaError_t")
public static int cudaGraphAddEmptyNode(@ByPtrPtr
                                        CUgraphNode_st pGraphNode,
                                        CUgraph_st graph,
                                        @Cast("const cudaGraphNode_t*") @ByPtrPtr
                                        CUgraphNode_st pDependencies,
                                        @Cast("size_t")
                                        long numDependencies)
```
\brief Creates an empty node and adds it to a graph Creates a new node which performs no operation, and adds it to \p graph with \p numDependencies dependencies specified via \p pDependencies. It is possible for \p numDependencies to be 0, in which case the node will be placed at the root of the graph. \p pDependencies may not have any duplicate entries. A handle to the new node will be returned in \p pGraphNode. An empty node performs no operation during execution, but can be used for transitive ordering. For example, a phased execution graph with 2 groups of n nodes with a barrier between them can be represented using an empty node and 2*n dependency edges, rather than no empty node and n^2 dependency edges.

Parameters:

pGraphNode - - Returns newly created node

graph - - Graph to which to add the node

pDependencies - - Dependencies of the node

numDependencies - - Number of dependencies

Returns:

::cudaSuccess, ::cudaErrorInvalidValue \note_graph_thread_safety \note_init_rt \note_callback

cudaGraphClone
```
@Cast("cudaError_t")
public static int cudaGraphClone(@ByPtrPtr
                                 CUgraph_st pGraphClone,
                                 CUgraph_st originalGraph)
```
\brief Clones a graph This function creates a copy of \p originalGraph and returns it in \p pGraphClone. All parameters are copied into the cloned graph. The original graph may be modified after this call without affecting the clone. Child graph nodes in the original graph are recursively copied into the clone.

Parameters:

pGraphClone - - Returns newly created cloned graph

originalGraph - - Graph to clone

Returns:

::cudaSuccess, ::cudaErrorInvalidValue, ::cudaErrorMemoryAllocation \note_graph_thread_safety \notefnerr \note_init_rt \note_callback

cudaGraphNodeFindInClone
```
@Cast("cudaError_t")
public static int cudaGraphNodeFindInClone(@ByPtrPtr
                                           CUgraphNode_st pNode,
                                           CUgraphNode_st originalNode,
                                           CUgraph_st clonedGraph)
```
\brief Finds a cloned version of a node This function returns the node in \p clonedGraph corresponding to \p originalNode in the original graph. \p clonedGraph must have been cloned from \p originalGraph via ::cudaGraphClone. \p originalNode must have been in \p originalGraph at the time of the call to ::cudaGraphClone, and the corresponding cloned node in \p clonedGraph must not have been removed. The cloned node is then returned via \p pClonedNode.

Parameters:

pNode - - Returns handle to the cloned node

originalNode - - Handle to the original node

clonedGraph - - Cloned graph to query

Returns:

::cudaSuccess, ::cudaErrorInvalidValue \note_graph_thread_safety \notefnerr \note_init_rt \note_callback

cudaGraphNodeGetType

@Cast("cudaError_t")
public static int cudaGraphNodeGetType(CUgraphNode_st node,
                                       @Cast("cudaGraphNodeType*")
                                       IntPointer pType)

\brief Returns a node's type Returns the node type of \p node in \p pType.

Parameters:: node - - Node to query; pType - - Pointer to return the node type
Returns:: ::cudaSuccess, ::cudaErrorInvalidValue \note_graph_thread_safety \notefnerr \note_init_rt \note_callback

cudaGraphNodeGetType

@Cast("cudaError_t")
public static int cudaGraphNodeGetType(CUgraphNode_st node,
                                       @Cast("cudaGraphNodeType*")
                                       IntBuffer pType)

cudaGraphNodeGetType

@Cast("cudaError_t")
public static int cudaGraphNodeGetType(CUgraphNode_st node,
                                       @Cast("cudaGraphNodeType*")
                                       int[] pType)

cudaGraphGetNodes
```
@Cast("cudaError_t")
public static int cudaGraphGetNodes(CUgraph_st graph,
                                    @ByPtrPtr
                                    CUgraphNode_st nodes,
                                    @Cast("size_t*")
                                    SizeTPointer numNodes)
```
\brief Returns a graph's nodes Returns a list of \p graph's nodes. \p nodes may be NULL, in which case this function will return the number of nodes in \p numNodes. Otherwise, \p numNodes entries will be filled in. If \p numNodes is higher than the actual number of nodes, the remaining entries in \p nodes will be set to NULL, and the number of nodes actually obtained will be returned in \p numNodes.

Parameters:

graph - - Graph to query

nodes - - Pointer to return the nodes

numNodes - - See description

Returns:

::cudaSuccess, ::cudaErrorInvalidValue \note_graph_thread_safety \notefnerr \note_init_rt \note_callback

cudaGraphGetRootNodes
```
@Cast("cudaError_t")
public static int cudaGraphGetRootNodes(CUgraph_st graph,
                                        @ByPtrPtr
                                        CUgraphNode_st pRootNodes,
                                        @Cast("size_t*")
                                        SizeTPointer pNumRootNodes)
```
\brief Returns a graph's root nodes Returns a list of \p graph's root nodes. \p pRootNodes may be NULL, in which case this function will return the number of root nodes in \p pNumRootNodes. Otherwise, \p pNumRootNodes entries will be filled in. If \p pNumRootNodes is higher than the actual number of root nodes, the remaining entries in \p pRootNodes will be set to NULL, and the number of nodes actually obtained will be returned in \p pNumRootNodes.

Parameters:

graph - - Graph to query

pRootNodes - - Pointer to return the root nodes

pNumRootNodes - - See description

Returns:

::cudaSuccess, ::cudaErrorInvalidValue \note_graph_thread_safety \notefnerr \note_init_rt \note_callback

cudaGraphGetEdges
```
@Cast("cudaError_t")
public static int cudaGraphGetEdges(CUgraph_st graph,
                                    @ByPtrPtr
                                    CUgraphNode_st from,
                                    @ByPtrPtr
                                    CUgraphNode_st to,
                                    @Cast("size_t*")
                                    SizeTPointer numEdges)
```
\brief Returns a graph's dependency edges Returns a list of \p graph's dependency edges. Edges are returned via corresponding indices in \p from and \p to; that is, the node in \p to[i] has a dependency on the node in \p from[i]. \p from and \p to may both be NULL, in which case this function only returns the number of edges in \p numEdges. Otherwise, \p numEdges entries will be filled in. If \p numEdges is higher than the actual number of edges, the remaining entries in \p from and \p to will be set to NULL, and the number of edges actually returned will be written to \p numEdges.

Parameters:

graph - - Graph to get the edges from

from - - Location to return edge endpoints

to - - Location to return edge endpoints

numEdges - - See description

Returns:

::cudaSuccess, ::cudaErrorInvalidValue \note_graph_thread_safety \notefnerr \note_init_rt \note_callback

cudaGraphNodeGetDependencies
```
@Cast("cudaError_t")
public static int cudaGraphNodeGetDependencies(CUgraphNode_st node,
                                               @ByPtrPtr
                                               CUgraphNode_st pDependencies,
                                               @Cast("size_t*")
                                               SizeTPointer pNumDependencies)
```
\brief Returns a node's dependencies Returns a list of \p node's dependencies. \p pDependencies may be NULL, in which case this function will return the number of dependencies in \p pNumDependencies. Otherwise, \p pNumDependencies entries will be filled in. If \p pNumDependencies is higher than the actual number of dependencies, the remaining entries in \p pDependencies will be set to NULL, and the number of nodes actually obtained will be returned in \p pNumDependencies.

Parameters:

node - - Node to query

pDependencies - - Pointer to return the dependencies

pNumDependencies - - See description

Returns:

::cudaSuccess, ::cudaErrorInvalidValue \note_graph_thread_safety \notefnerr \note_init_rt \note_callback

cudaGraphNodeGetDependentNodes
```
@Cast("cudaError_t")
public static int cudaGraphNodeGetDependentNodes(CUgraphNode_st node,
                                                 @ByPtrPtr
                                                 CUgraphNode_st pDependentNodes,
                                                 @Cast("size_t*")
                                                 SizeTPointer pNumDependentNodes)
```
\brief Returns a node's dependent nodes Returns a list of \p node's dependent nodes. \p pDependentNodes may be NULL, in which case this function will return the number of dependent nodes in \p pNumDependentNodes. Otherwise, \p pNumDependentNodes entries will be filled in. If \p pNumDependentNodes is higher than the actual number of dependent nodes, the remaining entries in \p pDependentNodes will be set to NULL, and the number of nodes actually obtained will be returned in \p pNumDependentNodes.

Parameters:

node - - Node to query

pDependentNodes - - Pointer to return the dependent nodes

pNumDependentNodes - - See description

Returns:

::cudaSuccess, ::cudaErrorInvalidValue \note_graph_thread_safety \notefnerr \note_init_rt \note_callback

cudaGraphAddDependencies

@Cast("cudaError_t")
public static int cudaGraphAddDependencies(CUgraph_st graph,
                                           @Cast("const cudaGraphNode_t*") @ByPtrPtr
                                           CUgraphNode_st from,
                                           @Cast("const cudaGraphNode_t*") @ByPtrPtr
                                           CUgraphNode_st to,
                                           @Cast("size_t")
                                           long numDependencies)

\brief Adds dependency edges to a graph. The number of dependencies to be added is defined by \p numDependencies Elements in \p pFrom and \p pTo at corresponding indices define a dependency. Each node in \p pFrom and \p pTo must belong to \p graph. If \p numDependencies is 0, elements in \p pFrom and \p pTo will be ignored. Specifying an existing dependency will return an error.

Parameters:: graph - - Graph to which dependencies are added; from - - Array of nodes that provide the dependencies; to - - Array of dependent nodes; numDependencies - - Number of dependencies to be added
Returns:: ::cudaSuccess, ::cudaErrorInvalidValue \note_graph_thread_safety \notefnerr \note_init_rt \note_callback

cudaGraphRemoveDependencies

@Cast("cudaError_t")
public static int cudaGraphRemoveDependencies(CUgraph_st graph,
                                              @Cast("const cudaGraphNode_t*") @ByPtrPtr
                                              CUgraphNode_st from,
                                              @Cast("const cudaGraphNode_t*") @ByPtrPtr
                                              CUgraphNode_st to,
                                              @Cast("size_t")
                                              long numDependencies)

\brief Removes dependency edges from a graph. The number of \p pDependencies to be removed is defined by \p numDependencies. Elements in \p pFrom and \p pTo at corresponding indices define a dependency. Each node in \p pFrom and \p pTo must belong to \p graph. If \p numDependencies is 0, elements in \p pFrom and \p pTo will be ignored. Specifying a non-existing dependency will return an error.

Parameters:: graph - - Graph from which to remove dependencies; from - - Array of nodes that provide the dependencies; to - - Array of dependent nodes; numDependencies - - Number of dependencies to be removed
Returns:: ::cudaSuccess, ::cudaErrorInvalidValue \note_graph_thread_safety \notefnerr \note_init_rt \note_callback

cudaGraphDestroyNode
```
@Cast("cudaError_t")
public static int cudaGraphDestroyNode(CUgraphNode_st node)
```
\brief Remove a node from the graph Removes \p node from its graph. This operation also severs any dependencies of other nodes on \p node and vice versa.

Parameters:

node - - Node to remove

Returns:

::cudaSuccess, ::cudaErrorInvalidValue \note_graph_thread_safety \notefnerr \note_init_rt \note_callback

cudaGraphInstantiate
```
@Cast("cudaError_t")
public static int cudaGraphInstantiate(@ByPtrPtr
                                       CUgraphExec_st pGraphExec,
                                       CUgraph_st graph,
                                       @ByPtrPtr
                                       CUgraphNode_st pErrorNode,
                                       @Cast("char*")
                                       BytePointer pLogBuffer,
                                       @Cast("size_t")
                                       long bufferSize)
```
\brief Creates an executable graph from a graph Instantiates \p graph as an executable graph. The graph is validated for any structural constraints or intra-node constraints which were not previously validated. If instantiation is successful, a handle to the instantiated graph is returned in \p pGraphExec. If there are any errors, diagnostic information may be returned in \p pErrorNode and \p pLogBuffer. This is the primary way to inspect instantiation errors. The output will be null terminated unless the diagnostics overflow the buffer. In this case, they will be truncated, and the last byte can be inspected to determine if truncation occurred.

Parameters:

pGraphExec - - Returns instantiated graph

graph - - Graph to instantiate

pErrorNode - - In case of an instantiation error, this may be modified to indicate a node contributing to the error

pLogBuffer - - A character buffer to store diagnostic messages

bufferSize - - Size of the log buffer in bytes

Returns:

::cudaSuccess, ::cudaErrorInvalidValue \note_graph_thread_safety \notefnerr \note_init_rt \note_callback

cudaGraphInstantiate

@Cast("cudaError_t")
public static int cudaGraphInstantiate(@ByPtrPtr
                                       CUgraphExec_st pGraphExec,
                                       CUgraph_st graph,
                                       @ByPtrPtr
                                       CUgraphNode_st pErrorNode,
                                       @Cast("char*")
                                       ByteBuffer pLogBuffer,
                                       @Cast("size_t")
                                       long bufferSize)

cudaGraphInstantiate

@Cast("cudaError_t")
public static int cudaGraphInstantiate(@ByPtrPtr
                                       CUgraphExec_st pGraphExec,
                                       CUgraph_st graph,
                                       @ByPtrPtr
                                       CUgraphNode_st pErrorNode,
                                       @Cast("char*")
                                       byte[] pLogBuffer,
                                       @Cast("size_t")
                                       long bufferSize)

cudaGraphExecKernelNodeSetParams
```
@Cast("cudaError_t")
public static int cudaGraphExecKernelNodeSetParams(CUgraphExec_st hGraphExec,
                                                   CUgraphNode_st node,
                                                   @Const
                                                   cudaKernelNodeParams pNodeParams)
```
\brief Sets the parameters for a kernel node in the given graphExec Sets the parameters of a kernel node in an executable graph \p hGraphExec. The node is identified by the corresponding node \p node in the non-executable graph, from which the executable graph was instantiated. \p node must not have been removed from the original graph. The \p func field of \p nodeParams cannot be modified and must match the original value. All other values can be modified. The modifications only affect future launches of \p hGraphExec. Already enqueued or running launches of \p hGraphExec are not affected by this call. \p node is also not modified by this call.

Parameters:

hGraphExec - - The executable graph in which to set the specified node

node - - kernel node from the graph from which graphExec was instantiated

pNodeParams - - Updated Parameters to set

Returns:

::cudaSuccess, ::cudaErrorInvalidValue, \note_graph_thread_safety \notefnerr \note_init_rt \note_callback

cudaGraphExecMemcpyNodeSetParams
```
@Cast("cudaError_t")
public static int cudaGraphExecMemcpyNodeSetParams(CUgraphExec_st hGraphExec,
                                                   CUgraphNode_st node,
                                                   @Const
                                                   cudaMemcpy3DParms pNodeParams)
```
\brief Sets the parameters for a memcpy node in the given graphExec. Updates the work represented by \p node in \p hGraphExec as though \p node had contained \p pNodeParams at instantiation. \p node must remain in the graph which was used to instantiate \p hGraphExec. Changed edges to and from \p node are ignored. The source and destination memory in \p pNodeParams must be allocated from the same contexts as the original source and destination memory. Both the instantiation-time memory operands and the memory operands in \p pNodeParams must be 1-dimensional. Zero-length operations are not supported. The modifications only affect future launches of \p hGraphExec. Already enqueued or running launches of \p hGraphExec are not affected by this call. \p node is also not modified by this call. Returns cudaErrorInvalidValue if the memory operands’ mappings changed or either the original or new memory operands are multidimensional.

Parameters:

hGraphExec - - The executable graph in which to set the specified node

nodei - - Memcpy node from the graph which was used to instantiate graphExec

pNodeParams - - Updated Parameters to set

Returns:

::cudaSuccess, ::cudaErrorInvalidValue, \note_graph_thread_safety \notefnerr \note_init_rt \note_callback

cudaGraphExecMemsetNodeSetParams
```
@Cast("cudaError_t")
public static int cudaGraphExecMemsetNodeSetParams(CUgraphExec_st hGraphExec,
                                                   CUgraphNode_st node,
                                                   @Const
                                                   cudaMemsetParams pNodeParams)
```
\brief Sets the parameters for a memset node in the given graphExec. Updates the work represented by \p node in \p hGraphExec as though \p node had contained \p pNodeParams at instantiation. \p node must remain in the graph which was used to instantiate \p hGraphExec. Changed edges to and from \p node are ignored. The destination memory in \p pNodeParams must be allocated from the same context as the original destination memory. Both the instantiation-time memory operand and the memory operand in \p pNodeParams must be 1-dimensional. Zero-length operations are not supported. The modifications only affect future launches of \p hGraphExec. Already enqueued or running launches of \p hGraphExec are not affected by this call. \p node is also not modified by this call. Returns cudaErrorInvalidValue if the memory operand’s mappings changed or either the original or new memory operand are multidimensional.

Parameters:

hGraphExec - - The executable graph in which to set the specified node

node - - Memset node from the graph which was used to instantiate graphExec

pNodeParams - - Updated Parameters to set

Returns:

::cudaSuccess, ::cudaErrorInvalidValue, \note_graph_thread_safety \notefnerr \note_init_rt \note_callback

cudaGraphExecHostNodeSetParams
```
@Cast("cudaError_t")
public static int cudaGraphExecHostNodeSetParams(CUgraphExec_st hGraphExec,
                                                 CUgraphNode_st node,
                                                 @Const
                                                 cudaHostNodeParams pNodeParams)
```
\brief Sets the parameters for a host node in the given graphExec. Updates the work represented by \p node in \p hGraphExec as though \p node had contained \p pNodeParams at instantiation. \p node must remain in the graph which was used to instantiate \p hGraphExec. Changed edges to and from \p node are ignored. The modifications only affect future launches of \p hGraphExec. Already enqueued or running launches of \p hGraphExec are not affected by this call. \p node is also not modified by this call.

Parameters:

hGraphExec - - The executable graph in which to set the specified node

node - - Host node from the graph which was used to instantiate graphExec

pNodeParams - - Updated Parameters to set

Returns:

::cudaSuccess, ::cudaErrorInvalidValue, \note_graph_thread_safety \notefnerr \note_init_rt \note_callback

cudaGraphExecUpdate
```
@Cast("cudaError_t")
public static int cudaGraphExecUpdate(CUgraphExec_st hGraphExec,
                                      CUgraph_st hGraph,
                                      @ByPtrPtr
                                      CUgraphNode_st hErrorNode_out,
                                      @Cast("cudaGraphExecUpdateResult*")
                                      IntPointer updateResult_out)
```
\brief Check whether an executable graph can be updated with a graph and perform the update if possible Updates the node parameters in the instantiated graph specified by \p hGraphExec with the node parameters in a topologically identical graph specified by \p hGraph. Limitations: - Kernel nodes: - The function must not change (same restriction as cudaGraphExecKernelNodeSetParams()) - Memset and memcpy nodes: - The CUDA device(s) to which the operand(s) was allocated/mapped cannot change. - The source/destination memory must be allocated from the same contexts as the original source/destination memory. - Only 1D memsets can be changed. - Additional memcpy node restrictions: - Changing either the source or destination memory type(i.e. CU_MEMORYTYPE_DEVICE, CU_MEMORYTYPE_ARRAY, etc.) is not supported. Note: The API may add further restrictions in future releases. The return code should always be checked. Some node types are not currently supported: - Empty graph nodes(cudaGraphNodeTypeEmpty) - Child graphs(cudaGraphNodeTypeGraph). cudaGraphExecUpdate sets \p updateResult_out to cudaGraphExecUpdateErrorTopologyChanged under the following conditions: - The count of nodes directly in \p hGraphExec and \p hGraph differ, in which case \p hErrorNode_out is NULL. - A node is deleted in \p hGraph but not not its pair from \p hGraphExec, in which case \p hErrorNode_out is NULL. - A node is deleted in \p hGraphExec but not its pair from \p hGraph, in which case \p hErrorNode_out is the pairless node from \p hGraph. - The dependent nodes of a pair differ, in which case \p hErrorNode_out is the node from \p hGraph. cudaGraphExecUpdate sets \p updateResult_out to: - cudaGraphExecUpdateError if passed an invalid value. - cudaGraphExecUpdateErrorTopologyChanged if the graph topology changed - cudaGraphExecUpdateErrorNodeTypeChanged if the type of a node changed, in which case \p hErrorNode_out is set to the node from \p hGraph. - cudaGraphExecUpdateErrorFunctionChanged if the func field of a kernel changed, in which case \p hErrorNode_out is set to the node from \p hGraph - cudaGraphExecUpdateErrorParametersChanged if any parameters to a node changed in a way that is not supported, in which case \p hErrorNode_out is set to the node from \p hGraph - cudaGraphExecUpdateErrorNotSupported if something about a node is unsupported, like the node’s type or configuration, in which case \p hErrorNode_out is set to the node from \p hGraph If \p updateResult_out isn’t set in one of the situations described above, the update check passes and cudaGraphExecUpdate updates \p hGraphExec to match the contents of \p hGraph. If an error happens during the update, \p updateResult_out will be set to cudaGraphExecUpdateError; otherwise, \p updateResult_out is set to cudaGraphExecUpdateSuccess. cudaGraphExecUpdate returns cudaSuccess when the updated was performed successfully. It returns cudaErrorGraphExecUpdateFailure if the graph update was not performed because it included changes which violated constraints specific to instantiated graph update.

Parameters:

hGraphExec - The instantiated graph to be updated

hGraph - The graph containing the updated parameters

hErrorNode_out - The node which caused the permissibility check to forbid the update, if any

updateResult_out - Whether the graph update was permitted. If was forbidden, the reason why

Returns:

::cudaSuccess, ::cudaErrorGraphExecUpdateFailure, \note_graph_thread_safety \notefnerr \note_init_rt \note_callback

cudaGraphExecUpdate

@Cast("cudaError_t")
public static int cudaGraphExecUpdate(CUgraphExec_st hGraphExec,
                                      CUgraph_st hGraph,
                                      @ByPtrPtr
                                      CUgraphNode_st hErrorNode_out,
                                      @Cast("cudaGraphExecUpdateResult*")
                                      IntBuffer updateResult_out)

cudaGraphExecUpdate

@Cast("cudaError_t")
public static int cudaGraphExecUpdate(CUgraphExec_st hGraphExec,
                                      CUgraph_st hGraph,
                                      @ByPtrPtr
                                      CUgraphNode_st hErrorNode_out,
                                      @Cast("cudaGraphExecUpdateResult*")
                                      int[] updateResult_out)

cudaGraphLaunch
```
@Cast("cudaError_t")
public static int cudaGraphLaunch(CUgraphExec_st graphExec,
                                  CUstream_st stream)
```
\brief Launches an executable graph in a stream Executes \p graphExec in \p stream. Only one instance of \p graphExec may be executing at a time. Each launch is ordered behind both any previous work in \p stream and any previous launches of \p graphExec. To execute a graph concurrently, it must be instantiated multiple times into multiple executable graphs.

Parameters:

graphExec - - Executable graph to launch

stream - - Stream in which to launch the graph

Returns:

::cudaSuccess, ::cudaErrorInvalidValue \note_graph_thread_safety \notefnerr \note_init_rt \note_callback

cudaGraphExecDestroy
```
@Cast("cudaError_t")
public static int cudaGraphExecDestroy(CUgraphExec_st graphExec)
```
\brief Destroys an executable graph Destroys the executable graph specified by \p graphExec.

Parameters:

graphExec - - Executable graph to destroy

Returns:

::cudaSuccess, ::cudaErrorInvalidValue \note_graph_thread_safety \notefnerr \note_init_rt \note_callback

cudaGraphDestroy
```
@Cast("cudaError_t")
public static int cudaGraphDestroy(CUgraph_st graph)
```
\brief Destroys a graph Destroys the graph specified by \p graph, as well as all of its nodes.

Parameters:

graph - - Graph to destroy

Returns:

::cudaSuccess, ::cudaErrorInvalidValue \note_graph_thread_safety \notefnerr \note_init_rt \note_callback

cudaGetExportTable

@Cast("cudaError_t")
public static int cudaGetExportTable(@Cast("const void**")
                                     PointerPointer ppExportTable,
                                     @Const
                                     cudaUUID_t pExportTableId)

\cond impl_private

cudaGetExportTable

@Cast("cudaError_t")
public static int cudaGetExportTable(@Cast("const void**") @ByPtrPtr
                                     Pointer ppExportTable,
                                     @Const
                                     cudaUUID_t pExportTableId)

make_cudaPitchedPtr

@ByVal
public static cudaPitchedPtr make_cudaPitchedPtr(Pointer d,
                                                 @Cast("size_t")
                                                 long p,
                                                 @Cast("size_t")
                                                 long xsz,
                                                 @Cast("size_t")
                                                 long ysz)

\brief Returns a cudaPitchedPtr based on input parameters Returns a ::cudaPitchedPtr based on the specified input parameters \p d, \p p, \p xsz, and \p ysz.

Parameters:: d - - Pointer to allocated memory; p - - Pitch of allocated memory in bytes; xsz - - Logical width of allocation in elements; ysz - - Logical height of allocation in elements
Returns:: ::cudaPitchedPtr specified by \p d, \p p, \p xsz, and \p ysz

make_cudaPos

@ByVal
public static cudaPos make_cudaPos(@Cast("size_t")
                                   long x,
                                   @Cast("size_t")
                                   long y,
                                   @Cast("size_t")
                                   long z)

\brief Returns a cudaPos based on input parameters Returns a ::cudaPos based on the specified input parameters \p x, \p y, and \p z.

Parameters:: x - - X position; y - - Y position; z - - Z position
Returns:: ::cudaPos specified by \p x, \p y, and \p z

make_cudaExtent

@ByVal
public static cudaExtent make_cudaExtent(@Cast("size_t")
                                         long w,
                                         @Cast("size_t")
                                         long h,
                                         @Cast("size_t")
                                         long d)

\brief Returns a cudaExtent based on input parameters Returns a ::cudaExtent based on the specified input parameters \p w, \p h, and \p d.

Parameters:: w - - Width in elements when referring to array memory, in bytes when referring to linear memory; h - - Height in elements; d - - Depth in elements
Returns:: ::cudaExtent specified by \p w, \p h, and \p d

make_char1
```
@ByVal
public static char1 make_char1(byte x)
```
* * *

make_uchar1

@ByVal
public static uchar1 make_uchar1(@Cast("unsigned char")
                                 byte x)

make_char2

@ByVal
public static char2 make_char2(byte x,
                               byte y)

make_uchar2

@ByVal
public static uchar2 make_uchar2(@Cast("unsigned char")
                                 byte x,
                                 @Cast("unsigned char")
                                 byte y)

make_char3

@ByVal
public static char3 make_char3(byte x,
                               byte y,
                               byte z)

make_uchar3

@ByVal
public static uchar3 make_uchar3(@Cast("unsigned char")
                                 byte x,
                                 @Cast("unsigned char")
                                 byte y,
                                 @Cast("unsigned char")
                                 byte z)

make_char4

@ByVal
public static char4 make_char4(byte x,
                               byte y,
                               byte z,
                               byte w)

make_uchar4

@ByVal
public static uchar4 make_uchar4(@Cast("unsigned char")
                                 byte x,
                                 @Cast("unsigned char")
                                 byte y,
                                 @Cast("unsigned char")
                                 byte z,
                                 @Cast("unsigned char")
                                 byte w)

make_short1

@ByVal
public static short1 make_short1(short x)

make_ushort1

@ByVal
public static ushort1 make_ushort1(@Cast("unsigned short")
                                   short x)

make_short2

@ByVal
public static short2 make_short2(short x,
                                 short y)

make_ushort2

@ByVal
public static ushort2 make_ushort2(@Cast("unsigned short")
                                   short x,
                                   @Cast("unsigned short")
                                   short y)

make_short3

@ByVal
public static short3 make_short3(short x,
                                 short y,
                                 short z)

make_ushort3

@ByVal
public static ushort3 make_ushort3(@Cast("unsigned short")
                                   short x,
                                   @Cast("unsigned short")
                                   short y,
                                   @Cast("unsigned short")
                                   short z)

make_short4

@ByVal
public static short4 make_short4(short x,
                                 short y,
                                 short z,
                                 short w)

make_ushort4

@ByVal
public static ushort4 make_ushort4(@Cast("unsigned short")
                                   short x,
                                   @Cast("unsigned short")
                                   short y,
                                   @Cast("unsigned short")
                                   short z,
                                   @Cast("unsigned short")
                                   short w)

make_int1

@ByVal
public static int1 make_int1(int x)

make_uint1

@ByVal
public static uint1 make_uint1(@Cast("unsigned int")
                               int x)

make_int2

@ByVal
public static int2 make_int2(int x,
                             int y)

make_uint2

@ByVal
public static uint2 make_uint2(@Cast("unsigned int")
                               int x,
                               @Cast("unsigned int")
                               int y)

make_int3

@ByVal
public static int3 make_int3(int x,
                             int y,
                             int z)

make_uint3

@ByVal
public static uint3 make_uint3(@Cast("unsigned int")
                               int x,
                               @Cast("unsigned int")
                               int y,
                               @Cast("unsigned int")
                               int z)

make_int4

@ByVal
public static int4 make_int4(int x,
                             int y,
                             int z,
                             int w)

make_uint4

@ByVal
public static uint4 make_uint4(@Cast("unsigned int")
                               int x,
                               @Cast("unsigned int")
                               int y,
                               @Cast("unsigned int")
                               int z,
                               @Cast("unsigned int")
                               int w)

make_long1

@ByVal
public static long1 make_long1(long x)

make_ulong1

@ByVal
public static ulong1 make_ulong1(@Cast("unsigned long int")
                                 long x)

make_long2

@ByVal
public static long2 make_long2(long x,
                               long y)

make_ulong2

@ByVal
public static ulong2 make_ulong2(@Cast("unsigned long int")
                                 long x,
                                 @Cast("unsigned long int")
                                 long y)

make_long3

@ByVal
public static long3 make_long3(long x,
                               long y,
                               long z)

make_ulong3

@ByVal
public static ulong3 make_ulong3(@Cast("unsigned long int")
                                 long x,
                                 @Cast("unsigned long int")
                                 long y,
                                 @Cast("unsigned long int")
                                 long z)

make_long4

@ByVal
public static long4 make_long4(long x,
                               long y,
                               long z,
                               long w)

make_ulong4

@ByVal
public static ulong4 make_ulong4(@Cast("unsigned long int")
                                 long x,
                                 @Cast("unsigned long int")
                                 long y,
                                 @Cast("unsigned long int")
                                 long z,
                                 @Cast("unsigned long int")
                                 long w)

make_float1

@ByVal
public static float1 make_float1(float x)

make_float2

@ByVal
public static float2 make_float2(float x,
                                 float y)

make_float3

@ByVal
public static float3 make_float3(float x,
                                 float y,
                                 float z)

make_float4

@ByVal
public static float4 make_float4(float x,
                                 float y,
                                 float z,
                                 float w)

make_longlong1

@ByVal
public static longlong1 make_longlong1(long x)

make_ulonglong1

@ByVal
public static ulonglong1 make_ulonglong1(@Cast("unsigned long long int")
                                         long x)

make_longlong2

@ByVal
public static longlong2 make_longlong2(long x,
                                       long y)

make_ulonglong2

@ByVal
public static ulonglong2 make_ulonglong2(@Cast("unsigned long long int")
                                         long x,
                                         @Cast("unsigned long long int")
                                         long y)

make_longlong3

@ByVal
public static longlong3 make_longlong3(long x,
                                       long y,
                                       long z)

make_ulonglong3

@ByVal
public static ulonglong3 make_ulonglong3(@Cast("unsigned long long int")
                                         long x,
                                         @Cast("unsigned long long int")
                                         long y,
                                         @Cast("unsigned long long int")
                                         long z)

make_longlong4

@ByVal
public static longlong4 make_longlong4(long x,
                                       long y,
                                       long z,
                                       long w)

make_ulonglong4

@ByVal
public static ulonglong4 make_ulonglong4(@Cast("unsigned long long int")
                                         long x,
                                         @Cast("unsigned long long int")
                                         long y,
                                         @Cast("unsigned long long int")
                                         long z,
                                         @Cast("unsigned long long int")
                                         long w)

make_double1

@ByVal
public static double1 make_double1(double x)

make_double2

@ByVal
public static double2 make_double2(double x,
                                   double y)

make_double3

@ByVal
public static double3 make_double3(double x,
                                   double y,
                                   double z)

make_double4

@ByVal
public static double4 make_double4(double x,
                                   double y,
                                   double z,
                                   double w)

cuCrealf

public static float cuCrealf(@ByVal @Cast("cuFloatComplex*")
                             float2 x)

cuCimagf

public static float cuCimagf(@ByVal @Cast("cuFloatComplex*")
                             float2 x)

make_cuFloatComplex

@ByVal
@Cast("cuFloatComplex*")
public static float2 make_cuFloatComplex(float r,
                                         float i)

cuConjf

@ByVal
@Cast("cuFloatComplex*")
public static float2 cuConjf(@ByVal @Cast("cuFloatComplex*")
                             float2 x)

cuCaddf

@ByVal
@Cast("cuFloatComplex*")
public static float2 cuCaddf(@ByVal @Cast("cuFloatComplex*")
                             float2 x,
                             @ByVal @Cast("cuFloatComplex*")
                             float2 y)

cuCsubf

@ByVal
@Cast("cuFloatComplex*")
public static float2 cuCsubf(@ByVal @Cast("cuFloatComplex*")
                             float2 x,
                             @ByVal @Cast("cuFloatComplex*")
                             float2 y)

cuCmulf

@ByVal
@Cast("cuFloatComplex*")
public static float2 cuCmulf(@ByVal @Cast("cuFloatComplex*")
                             float2 x,
                             @ByVal @Cast("cuFloatComplex*")
                             float2 y)

cuCdivf

@ByVal
@Cast("cuFloatComplex*")
public static float2 cuCdivf(@ByVal @Cast("cuFloatComplex*")
                             float2 x,
                             @ByVal @Cast("cuFloatComplex*")
                             float2 y)

cuCabsf

public static float cuCabsf(@ByVal @Cast("cuFloatComplex*")
                            float2 x)

cuCreal

public static double cuCreal(@ByVal @Cast("cuDoubleComplex*")
                             double2 x)

cuCimag

public static double cuCimag(@ByVal @Cast("cuDoubleComplex*")
                             double2 x)

make_cuDoubleComplex

@ByVal
@Cast("cuDoubleComplex*")
public static double2 make_cuDoubleComplex(double r,
                                           double i)

cuConj

@ByVal
@Cast("cuDoubleComplex*")
public static double2 cuConj(@ByVal @Cast("cuDoubleComplex*")
                             double2 x)

cuCadd

@ByVal
@Cast("cuDoubleComplex*")
public static double2 cuCadd(@ByVal @Cast("cuDoubleComplex*")
                             double2 x,
                             @ByVal @Cast("cuDoubleComplex*")
                             double2 y)

cuCsub

@ByVal
@Cast("cuDoubleComplex*")
public static double2 cuCsub(@ByVal @Cast("cuDoubleComplex*")
                             double2 x,
                             @ByVal @Cast("cuDoubleComplex*")
                             double2 y)

cuCmul

@ByVal
@Cast("cuDoubleComplex*")
public static double2 cuCmul(@ByVal @Cast("cuDoubleComplex*")
                             double2 x,
                             @ByVal @Cast("cuDoubleComplex*")
                             double2 y)

cuCdiv

@ByVal
@Cast("cuDoubleComplex*")
public static double2 cuCdiv(@ByVal @Cast("cuDoubleComplex*")
                             double2 x,
                             @ByVal @Cast("cuDoubleComplex*")
                             double2 y)

cuCabs

public static double cuCabs(@ByVal @Cast("cuDoubleComplex*")
                            double2 x)

make_cuComplex

@ByVal
@Cast("cuComplex*")
public static float2 make_cuComplex(float x,
                                    float y)

cuComplexFloatToDouble

@ByVal
@Cast("cuDoubleComplex*")
public static double2 cuComplexFloatToDouble(@ByVal @Cast("cuFloatComplex*")
                                             float2 c)

cuComplexDoubleToFloat

@ByVal
@Cast("cuFloatComplex*")
public static float2 cuComplexDoubleToFloat(@ByVal @Cast("cuDoubleComplex*")
                                            double2 c)

cuCfmaf

@ByVal
@Cast("cuComplex*")
public static float2 cuCfmaf(@ByVal @Cast("cuComplex*")
                             float2 x,
                             @ByVal @Cast("cuComplex*")
                             float2 y,
                             @ByVal @Cast("cuComplex*")
                             float2 d)

cuCfma

@ByVal
@Cast("cuDoubleComplex*")
public static double2 cuCfma(@ByVal @Cast("cuDoubleComplex*")
                             double2 x,
                             @ByVal @Cast("cuDoubleComplex*")
                             double2 y,
                             @ByVal @Cast("cuDoubleComplex*")
                             double2 d)

__float2half
```
@ByVal
public static __half __float2half(float a)
```
\ingroup CUDA_MATH__HALF_MISC \brief Converts float number to half precision in round-to-nearest-even mode and returns \p half with converted value. \details Converts float number \p a to half precision in round-to-nearest-even mode. \req

Parameters:

a - [in] - float. Is only being read.

Returns:

half \retval \p a converted to half.

__float2half_rn
```
@ByVal
public static __half __float2half_rn(float a)
```
\ingroup CUDA_MATH__HALF_MISC \brief Converts float number to half precision in round-to-nearest-even mode and returns \p half with converted value. \details Converts float number \p a to half precision in round-to-nearest-even mode. \req

Parameters:

a - [in] - float. Is only being read.

Returns:

half \retval \p a converted to half.

__float2half_rz
```
@ByVal
public static __half __float2half_rz(float a)
```
\ingroup CUDA_MATH__HALF_MISC \brief Converts float number to half precision in round-towards-zero mode and returns \p half with converted value. \details Converts float number \p a to half precision in round-towards-zero mode. \req

Parameters:

a - [in] - float. Is only being read.

Returns:

half \retval \p a converted to half.

__float2half_rd
```
@ByVal
public static __half __float2half_rd(float a)
```
\ingroup CUDA_MATH__HALF_MISC \brief Converts float number to half precision in round-down mode and returns \p half with converted value. \details Converts float number \p a to half precision in round-down mode. \req

Parameters:

a - [in] - float. Is only being read.

Returns:

half \retval \p a converted to half.

__float2half_ru
```
@ByVal
public static __half __float2half_ru(float a)
```
\ingroup CUDA_MATH__HALF_MISC \brief Converts float number to half precision in round-up mode and returns \p half with converted value. \details Converts float number \p a to half precision in round-up mode. \req

Parameters:

a - [in] - float. Is only being read.

Returns:

half \retval \p a converted to half.

__half2float
```
public static float __half2float(@Const @ByVal
                                 __half a)
```
\ingroup CUDA_MATH__HALF_MISC \brief Converts \p half number to float. \details Converts half number \p a to float. \req

Parameters:

a - [in] - float. Is only being read.

Returns:

float \retval \p a converted to float.

__float2half2_rn
```
@ByVal
public static __half2 __float2half2_rn(float a)
```
\ingroup CUDA_MATH__HALF_MISC \brief Converts input to half precision in round-to-nearest-even mode and populates both halves of \p half2 with converted value. \details Converts input \p a to half precision in round-to-nearest-even mode and populates both halves of \p half2 with converted value. \req

Parameters:

a - [in] - float. Is only being read.

Returns:

half2 \retval The \p half2 value with both halves equal to the converted half precision number.

__floats2half2_rn
```
@ByVal
public static __half2 __floats2half2_rn(float a,
                                        float b)
```
\ingroup CUDA_MATH__HALF_MISC \brief Converts both input floats to half precision in round-to-nearest-even mode and returns \p half2 with converted values. \details Converts both input floats to half precision in round-to-nearest-even mode and combines the results into one \p half2 number. Low 16 bits of the return value correspond to the input \p a, high 16 bits correspond to the input \p b. \req

Parameters:

a - [in] - float. Is only being read.

b - [in] - float. Is only being read.

Returns:

half2 \retval The \p half2 value with corresponding halves equal to the converted input floats.

__low2float
```
public static float __low2float(@Const @ByVal
                                __half2 a)
```
\ingroup CUDA_MATH__HALF_MISC \brief Converts low 16 bits of \p half2 to float and returns the result \details Converts low 16 bits of \p half2 input \p a to 32 bit floating point number and returns the result. \req

Parameters:

a - [in] - half2. Is only being read.

Returns:

float \retval The low 16 bits of \p a converted to float.

__high2float
```
public static float __high2float(@Const @ByVal
                                 __half2 a)
```
\ingroup CUDA_MATH__HALF_MISC \brief Converts high 16 bits of \p half2 to float and returns the result \details Converts high 16 bits of \p half2 input \p a to 32 bit floating point number and returns the result. \req

Parameters:

a - [in] - half2. Is only being read.

Returns:

float \retval The high 16 bits of \p a converted to float.

__internal_float2half

@Cast("unsigned short")
public static short __internal_float2half(float f,
                                          @Cast("unsigned int*") @ByRef
                                          IntPointer sign,
                                          @Cast("unsigned int*") @ByRef
                                          IntPointer remainder)

__internal_float2half

@Cast("unsigned short")
public static short __internal_float2half(float f,
                                          @Cast("unsigned int*") @ByRef
                                          IntBuffer sign,
                                          @Cast("unsigned int*") @ByRef
                                          IntBuffer remainder)

__internal_float2half

@Cast("unsigned short")
public static short __internal_float2half(float f,
                                          @Cast("unsigned int*") @ByRef
                                          int[] sign,
                                          @Cast("unsigned int*") @ByRef
                                          int[] remainder)

__internal_half2float

public static float __internal_half2float(@Cast("const unsigned short")
                                          short h)

Class cudart

Field Summary

Constructor Summary

Method Summary

Methods inherited from class org.bytedeco.cuda.presets.cudart

Methods inherited from class java.lang.Object

Field Detail

__CUDA_API_VERSION

CUDA_VERSION

CU_IPC_HANDLE_SIZE

CU_IPC_MEM_LAZY_ENABLE_PEER_ACCESS

CU_MEM_ATTACH_GLOBAL

CU_MEM_ATTACH_HOST

CU_MEM_ATTACH_SINGLE

CU_CTX_SCHED_AUTO

CU_CTX_SCHED_SPIN

CU_CTX_SCHED_YIELD

CU_CTX_SCHED_BLOCKING_SYNC

CU_CTX_BLOCKING_SYNC

CU_CTX_SCHED_MASK

CU_CTX_MAP_HOST

CU_CTX_LMEM_RESIZE_TO_MAX

CU_CTX_FLAGS_MASK

CU_STREAM_DEFAULT

CU_STREAM_NON_BLOCKING

CU_STREAM_LEGACY

CU_STREAM_PER_THREAD

CU_EVENT_DEFAULT

CU_EVENT_BLOCKING_SYNC

CU_EVENT_DISABLE_TIMING

CU_EVENT_INTERPROCESS

CU_STREAM_WAIT_VALUE_GEQ

CU_STREAM_WAIT_VALUE_EQ

CU_STREAM_WAIT_VALUE_AND

CU_STREAM_WAIT_VALUE_NOR

CU_STREAM_WAIT_VALUE_FLUSH

CU_STREAM_WRITE_VALUE_DEFAULT

CU_STREAM_WRITE_VALUE_NO_MEMORY_BARRIER

CU_STREAM_MEM_OP_WAIT_VALUE_32

CU_STREAM_MEM_OP_WRITE_VALUE_32

CU_STREAM_MEM_OP_WAIT_VALUE_64

CU_STREAM_MEM_OP_WRITE_VALUE_64

CU_STREAM_MEM_OP_FLUSH_REMOTE_WRITES

CU_OCCUPANCY_DEFAULT

CU_OCCUPANCY_DISABLE_CACHING_OVERRIDE

CU_AD_FORMAT_UNSIGNED_INT8

CU_AD_FORMAT_UNSIGNED_INT16

CU_AD_FORMAT_UNSIGNED_INT32

CU_AD_FORMAT_SIGNED_INT8

CU_AD_FORMAT_SIGNED_INT16

CU_AD_FORMAT_SIGNED_INT32

CU_AD_FORMAT_HALF

CU_AD_FORMAT_FLOAT

CU_TR_ADDRESS_MODE_WRAP

CU_TR_ADDRESS_MODE_CLAMP

CU_TR_ADDRESS_MODE_MIRROR

CU_TR_ADDRESS_MODE_BORDER

CU_TR_FILTER_MODE_POINT

CU_TR_FILTER_MODE_LINEAR

CU_DEVICE_ATTRIBUTE_MAX_THREADS_PER_BLOCK

CU_DEVICE_ATTRIBUTE_MAX_BLOCK_DIM_X

CU_DEVICE_ATTRIBUTE_MAX_BLOCK_DIM_Y

CU_DEVICE_ATTRIBUTE_MAX_BLOCK_DIM_Z

CU_DEVICE_ATTRIBUTE_MAX_GRID_DIM_X

CU_DEVICE_ATTRIBUTE_MAX_GRID_DIM_Y

CU_DEVICE_ATTRIBUTE_MAX_GRID_DIM_Z

CU_DEVICE_ATTRIBUTE_MAX_SHARED_MEMORY_PER_BLOCK

CU_DEVICE_ATTRIBUTE_SHARED_MEMORY_PER_BLOCK

CU_DEVICE_ATTRIBUTE_TOTAL_CONSTANT_MEMORY

CU_DEVICE_ATTRIBUTE_WARP_SIZE

CU_DEVICE_ATTRIBUTE_MAX_PITCH

CU_DEVICE_ATTRIBUTE_MAX_REGISTERS_PER_BLOCK

CU_DEVICE_ATTRIBUTE_REGISTERS_PER_BLOCK

CU_DEVICE_ATTRIBUTE_CLOCK_RATE

CU_DEVICE_ATTRIBUTE_TEXTURE_ALIGNMENT

CU_DEVICE_ATTRIBUTE_GPU_OVERLAP

CU_DEVICE_ATTRIBUTE_MULTIPROCESSOR_COUNT

CU_DEVICE_ATTRIBUTE_KERNEL_EXEC_TIMEOUT

CU_DEVICE_ATTRIBUTE_INTEGRATED

CU_DEVICE_ATTRIBUTE_CAN_MAP_HOST_MEMORY