JCudaDriver (jcuda 11.0.0 API)

java.lang.Object
- jcuda.driver.JCudaDriver

```
public class JCudaDriver
extends Object
```
Java bindings for the NVidia CUDA driver API.

Most comments are extracted from the CUDA online documentation

Field Summary

Fields
Modifier and Type	Field and Description
`static CUdevice`	`CU_DEVICE_CPU` Device that represents the CPU
`static CUdevice`	`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 int`	`CU_MEMHOSTALLOC_DEVICEMAP` If set, host memory is mapped into CUDA address space and JCudaDriver#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. belonging to a third-party PCIe device.
`static int`	`CU_MEMHOSTREGISTER_PORTABLE` If set, host memory is portable between CUDA contexts.
`static int`	`CU_MEMPEERREGISTER_DEVICEMAP` Deprecated. This value has been added in CUDA 4.0 RC, and removed in CUDA 4.0 RC2
`static int`	`CU_PARAM_TR_DEFAULT` For texture references loaded into the module, use default texunit from texture reference
`static int`	`CU_STREAM_CALLBACK_BLOCKING` Deprecated. This flag was only present in CUDA 5.0.25 (release candidate) and may be removed (or added again) in future releases
`static int`	`CU_STREAM_CALLBACK_NONBLOCKING` Deprecated. This flag was only present in CUDA 5.0.25 (release candidate) and may be removed (or added again) in future releases
`static CUstream`	`CU_STREAM_LEGACY` Stream handle that can be passed as a CUstream to use an implicit stream with legacy synchronization behavior.
`static CUstream`	`CU_STREAM_PER_THREAD` Stream handle that can be passed as a CUstream to use an implicit stream with per-thread synchronization behavior.
`static int`	`CU_TRSA_OVERRIDE_FORMAT` Override the texref format with a format inferred from the array
`static int`	`CU_TRSF_DISABLE_TRILINEAR_OPTIMIZATION` Disable any trilinear filtering optimizations.
`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_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_VERSION` The CUDA version

Method Summary

All Methods Static Methods Concrete Methods Deprecated Methods
Modifier and Type	Method and Description
`static int`	`align(int value, int alignment)` Deprecated. This method was intended for a simpler kernel parameter setup in earlier CUDA versions, and should not be required any more. It may be removed in future releases.
`static int`	`cuArray3DCreate(CUarray pHandle, CUDA_ARRAY3D_DESCRIPTOR pAllocateArray)` Creates a 3D CUDA array.
`static int`	`cuArray3DGetDescriptor(CUDA_ARRAY3D_DESCRIPTOR pArrayDescriptor, CUarray hArray)` Get a 3D CUDA array descriptor.
`static int`	`cuArrayCreate(CUarray pHandle, CUDA_ARRAY_DESCRIPTOR pAllocateArray)` Creates a 1D or 2D CUDA array.
`static int`	`cuArrayDestroy(CUarray hArray)` Destroys a CUDA array.
`static int`	`cuArrayGetDescriptor(CUDA_ARRAY_DESCRIPTOR pArrayDescriptor, CUarray hArray)` Get a 1D or 2D CUDA array descriptor.
`static int`	`cuCtxAttach(CUcontext pctx, int flags)` Deprecated. Deprecated in CUDA
`static int`	`cuCtxCreate(CUcontext pctx, int flags, CUdevice dev)` Create a CUDA context.
`static int`	`cuCtxDestroy(CUcontext ctx)` Destroy a CUDA context.
`static int`	`cuCtxDetach(CUcontext ctx)` Deprecated. Deprecated in CUDA
`static int`	`cuCtxDisablePeerAccess(CUcontext peerContext)` Disables direct access to memory allocations in a peer context and unregisters any registered allocations.
`static int`	`cuCtxEnablePeerAccess(CUcontext peerContext, int Flags)` Enables direct access to memory allocations in a peer context.
`static int`	`cuCtxGetApiVersion(CUcontext ctx, int[] version)` Gets the context's API version.
`static int`	`cuCtxGetCacheConfig(int[] pconfig)` Returns the preferred cache configuration for the current context.
`static int`	`cuCtxGetCurrent(CUcontext pctx)` Returns the CUDA context bound to the calling CPU thread.
`static int`	`cuCtxGetDevice(CUdevice device)` Returns the device ID for the current context.
`static int`	`cuCtxGetFlags(int[] flags)`
`static int`	`cuCtxGetLimit(long[] pvalue, int limit)` Returns resource limits.
`static int`	`cuCtxGetSharedMemConfig(int[] pConfig)` Returns the current shared memory configuration for the current context.
`static int`	`cuCtxGetStreamPriorityRange(int[] leastPriority, int[] greatestPriority)` Returns numerical values that correspond to the least and greatest stream priorities.
`static int`	`cuCtxPopCurrent(CUcontext pctx)` Pops the current CUDA context from the current CPU thread.
`static int`	`cuCtxPushCurrent(CUcontext ctx)` Pushes a context on the current CPU thread.
`static int`	`cuCtxResetPersistingL2Cache()` Resets all persisting lines in cache to normal status.
`static int`	`cuCtxSetCacheConfig(int config)` Sets the preferred cache configuration for the current context.
`static int`	`cuCtxSetCurrent(CUcontext ctx)` Binds the specified CUDA context to the calling CPU thread.
`static int`	`cuCtxSetLimit(int limit, long value)` Set resource limits.
`static int`	`cuCtxSetSharedMemConfig(int config)` Sets the shared memory configuration for the current context.
`static int`	`cuCtxSynchronize()` Block for a context's tasks to complete.
`static int`	`cuDeviceCanAccessPeer(int[] canAccessPeer, CUdevice dev, CUdevice peerDev)` Queries if a device may directly access a peer device's memory.
`static int`	`cuDeviceComputeCapability(int[] major, int[] minor, CUdevice dev)` Deprecated. Deprecated as of CUDA 5.0, replaced with `cuDeviceGetAttribute(int[], int, CUdevice)`
`static int`	`cuDeviceGet(CUdevice device, int ordinal)` Returns a handle to a compute device.
`static int`	`cuDeviceGetAttribute(int[] pi, int attrib, CUdevice dev)` Returns information about the device.
`static int`	`cuDeviceGetByPCIBusId(CUdevice dev, String pciBusId)` Returns a handle to a compute device.
`static int`	`cuDeviceGetCount(int[] count)` Returns the number of compute-capable devices.
`static int`	`cuDeviceGetLuid(byte[] luid, int[] deviceNodeMask, CUdevice dev)` Return an LUID and device node mask for the device.
`static int`	`cuDeviceGetLuidNative(byte[] luid, int[] deviceNodeMask, CUdevice dev)`
`static int`	`cuDeviceGetName(byte[] name, int len, CUdevice dev)` Returns an identifer string for the device.
`static int`	`cuDeviceGetP2PAttribute(int[] value, int attrib, CUdevice srcDevice, CUdevice dstDevice)` Queries attributes of the link between two devices.
`static int`	`cuDeviceGetPCIBusId(String[] pciBusId, int len, CUdevice dev)` Returns a PCI Bus Id string for the device.
`static int`	`cuDeviceGetProperties(CUdevprop prop, CUdevice dev)` Deprecated. Deprecated as of CUDA 5.0, replaced with `cuDeviceGetAttribute(int[], int, CUdevice)`
`static int`	`cuDeviceGetUuid(CUuuid uuid, CUdevice dev)` Return an UUID for the device.
`static int`	`cuDevicePrimaryCtxRelease(CUdevice dev)`
`static int`	`cuDevicePrimaryCtxRetain(CUcontext pctx, CUdevice dev)`
`static int`	`cuDevicePrimaryCtxSetFlags(CUdevice dev, int flags)`
`static int`	`cuDeviceTotalMem(long[] bytes, CUdevice dev)` Returns the total amount of memory on the device.
`static int`	`cuDriverGetVersion(int[] driverVersion)` Returns the latest CUDA version supported by driver.
`static int`	`cuEventCreate(CUevent phEvent, int Flags)` Creates an event.
`static int`	`cuEventDestroy(CUevent hEvent)` Destroys an event.
`static int`	`cuEventElapsedTime(float[] pMilliseconds, CUevent hStart, CUevent hEnd)` Computes the elapsed time between two events.
`static int`	`cuEventQuery(CUevent hEvent)` Queries an event's status.
`static int`	`cuEventRecord(CUevent hEvent, CUstream hStream)` Records an event.
`static int`	`cuEventSynchronize(CUevent hEvent)` Waits for an event to complete.
`static int`	`cuFuncGetAttribute(int[] pi, int attrib, CUfunction func)` Returns information about a function.
`static int`	`cuFuncGetModule(CUmodule hmod, CUfunction hfunc)` Returns a module handle Returns in *hmod the handle of the module that function hfunc is located in.
`static int`	`cuFuncSetAttribute(CUfunction hfunc, int attrib, int value)` Sets information about a function.
`static int`	`cuFuncSetBlockShape(CUfunction hfunc, int x, int y, int z)` Deprecated. Deprecated in CUDA
`static int`	`cuFuncSetCacheConfig(CUfunction hfunc, int config)` Sets the preferred cache configuration for a device function.
`static int`	`cuFuncSetSharedMemConfig(CUfunction hfunc, int config)` Sets the shared memory configuration for a device function.
`static int`	`cuFuncSetSharedSize(CUfunction hfunc, int bytes)` Deprecated. Deprecated in CUDA
`static int`	`cuGetErrorName(int error, String[] pStr)` Gets the string representation of an error code enum name Sets *pStr to the address of a NULL-terminated string representation of the name of the enum error code error.
`static int`	`cuGetErrorString(int error, String[] pStr)` Gets the string description of an error code Sets *pStr to the address of a NULL-terminated string description of the error code error.
`static int`	`cuGLCtxCreate(CUcontext pCtx, int Flags, CUdevice device)` Deprecated. Deprecated as of CUDA 5.0
`static int`	`cuGLGetDevices(int[] pCudaDeviceCount, CUdevice[] pCudaDevices, int cudaDeviceCount, int CUGLDeviceList_deviceList)` Gets the CUDA devices associated with the current OpenGL context.
`static int`	`cuGLInit()` Deprecated. Deprecated as of CUDA 3.0
`static int`	`cuGLMapBufferObject(CUdeviceptr dptr, long[] size, int bufferobj)` Deprecated. Deprecated as of CUDA 3.0
`static int`	`cuGLMapBufferObjectAsync(CUdeviceptr dptr, long[] size, int buffer, CUstream hStream)` Deprecated. Deprecated as of CUDA 3.0
`static int`	`cuGLRegisterBufferObject(int bufferobj)` Deprecated. Deprecated as of CUDA 3.0
`static int`	`cuGLSetBufferObjectMapFlags(int buffer, int Flags)` Deprecated. Deprecated as of CUDA 3.0
`static int`	`cuGLUnmapBufferObject(int bufferobj)` Deprecated. Deprecated as of CUDA 3.0
`static int`	`cuGLUnmapBufferObjectAsync(int buffer, CUstream hStream)` Deprecated. Deprecated as of CUDA 3.0
`static int`	`cuGLUnregisterBufferObject(int bufferobj)` Deprecated. Deprecated as of CUDA 3.0
`static int`	`cuGraphAddChildGraphNode(CUgraphNode phGraphNode, CUgraph hGraph, CUgraphNode[] dependencies, long numDependencies, CUgraph childGraph)` Creates a child graph node and adds it to a graph.
`static int`	`cuGraphAddDependencies(CUgraph hGraph, CUgraphNode[] from, CUgraphNode[] to, long numDependencies)` Adds dependency edges to a graph.
`static int`	`cuGraphAddEmptyNode(CUgraphNode phGraphNode, CUgraph hGraph, CUgraphNode[] dependencies, long numDependencies)` Creates an empty node and adds it to a graph.
`static int`	`cuGraphAddHostNode(CUgraphNode phGraphNode, CUgraph hGraph, CUgraphNode[] dependencies, long numDependencies, CUDA_HOST_NODE_PARAMS nodeParams)` Creates a host execution node and adds it to a graph.
`static int`	`cuGraphAddKernelNode(CUgraphNode phGraphNode, CUgraph hGraph, CUgraphNode[] dependencies, long numDependencies, CUDA_KERNEL_NODE_PARAMS nodeParams)` Creates a kernel execution node and adds it to a graph.
`static int`	`cuGraphAddMemcpyNode(CUgraphNode phGraphNode, CUgraph hGraph, CUgraphNode[] dependencies, long numDependencies, CUDA_MEMCPY3D copyParams, CUcontext ctx)` Creates a memcpy node and adds it to a graph.
`static int`	`cuGraphAddMemsetNode(CUgraphNode phGraphNode, CUgraph hGraph, CUgraphNode[] dependencies, long numDependencies, CUDA_MEMSET_NODE_PARAMS memsetParams, CUcontext ctx)` Creates a memset node and adds it to a graph.
`static int`	`cuGraphChildGraphNodeGetGraph(CUgraphNode hNode, CUgraph phGraph)` Gets a handle to the embedded graph of a child graph node.
`static int`	`cuGraphClone(CUgraph phGraphClone, CUgraph originalGraph)` Clones a graph.
`static int`	`cuGraphCreate(CUgraph phGraph, int flags)` Creates a graph.
`static int`	`cuGraphDestroy(CUgraph hGraph)` Destroys a graph.
`static int`	`cuGraphDestroyNode(CUgraphNode hNode)` Remove a node from the graph.
`static int`	`cuGraphExecDestroy(CUgraphExec hGraphExec)` Destroys an executable graph.
`static int`	`cuGraphExecHostNodeSetParams(CUgraphExec hGraphExec, CUgraphNode hNode, CUDA_HOST_NODE_PARAMS nodeParams)` Sets the parameters for a host node in the given graphExec.
`static int`	`cuGraphExecKernelNodeSetParams(CUgraphExec hGraphExec, CUgraphNode hNode, CUDA_KERNEL_NODE_PARAMS nodeParams)` Sets the parameters for a kernel node in the given graphExec.
`static int`	`cuGraphExecMemcpyNodeSetParams(CUgraphExec hGraphExec, CUgraphNode hNode, CUDA_MEMCPY3D copyParams, CUcontext ctx)` Sets the parameters for a memcpy node in the given graphExec.
`static int`	`cuGraphExecMemsetNodeSetParams(CUgraphExec hGraphExec, CUgraphNode hNode, CUDA_MEMSET_NODE_PARAMS memsetParams, CUcontext ctx)` Sets the parameters for a memset node in the given graphExec.
`static int`	`cuGraphExecUpdate(CUgraphExec hGraphExec, CUgraph hGraph, CUgraphNode hErrorNode_out, int[] updateResult_out)` Check whether an executable graph can be updated with a graph and perform the update if possible.
`static int`	`cuGraphGetEdges(CUgraph hGraph, CUgraphNode[] from, CUgraphNode[] to, long[] numEdges)` Returns a graph's dependency edges.
`static int`	`cuGraphGetNodes(CUgraph hGraph, CUgraphNode[] nodes, long[] numNodes)` Returns a graph's nodes.
`static int`	`cuGraphGetRootNodes(CUgraph hGraph, CUgraphNode[] rootNodes, long[] numRootNodes)` Returns a graph's root nodes.
`static int`	`cuGraphHostNodeGetParams(CUgraphNode hNode, CUDA_HOST_NODE_PARAMS nodeParams)` Returns a host node's parameters.
`static int`	`cuGraphHostNodeSetParams(CUgraphNode hNode, CUDA_HOST_NODE_PARAMS nodeParams)` Sets a host node's parameters.
`static int`	`cuGraphicsGLRegisterBuffer(CUgraphicsResource pCudaResource, int buffer, int Flags)` Registers an OpenGL buffer object.
`static int`	`cuGraphicsGLRegisterImage(CUgraphicsResource pCudaResource, int image, int target, int Flags)` Register an OpenGL texture or renderbuffer object.
`static int`	`cuGraphicsMapResources(int count, CUgraphicsResource[] resources, CUstream hStream)` Map graphics resources for access by CUDA.
`static int`	`cuGraphicsResourceGetMappedMipmappedArray(CUmipmappedArray pMipmappedArray, CUgraphicsResource resource)` Get a mipmapped array through which to access a mapped graphics resource.
`static int`	`cuGraphicsResourceGetMappedPointer(CUdeviceptr pDevPtr, long[] pSize, CUgraphicsResource resource)` Get a device pointer through which to access a mapped graphics resource.
`static int`	`cuGraphicsResourceSetMapFlags(CUgraphicsResource resource, int flags)` Set usage flags for mapping a graphics resource.
`static int`	`cuGraphicsSubResourceGetMappedArray(CUarray pArray, CUgraphicsResource resource, int arrayIndex, int mipLevel)` Get an array through which to access a subresource of a mapped graphics resource.
`static int`	`cuGraphicsUnmapResources(int count, CUgraphicsResource[] resources, CUstream hStream)` Unmap graphics resources.
`static int`	`cuGraphicsUnregisterResource(CUgraphicsResource resource)` Unregisters a graphics resource for access by CUDA.
`static int`	`cuGraphInstantiate(CUgraphExec phGraphExec, CUgraph hGraph, CUgraphNode phErrorNode, byte[] logBuffer, long bufferSize)` Creates an executable graph from a graph.
`static int`	`cuGraphKernelNodeCopyAttributes(CUgraphNode dst, CUgraphNode src)` Copies attributes from source node to destination node.
`static int`	`cuGraphKernelNodeGetAttribute(CUgraphNode hNode, int attr, CUkernelNodeAttrValue value_out)` Queries node attribute.
`static int`	`cuGraphKernelNodeGetParams(CUgraphNode hNode, CUDA_KERNEL_NODE_PARAMS nodeParams)` Returns a kernel node's parameters.
`static int`	`cuGraphKernelNodeSetAttribute(CUgraphNode hNode, int attr, CUkernelNodeAttrValue value)` Sets node attribute.
`static int`	`cuGraphKernelNodeSetParams(CUgraphNode hNode, CUDA_KERNEL_NODE_PARAMS nodeParams)` Sets a kernel node's parameters.
`static int`	`cuGraphLaunch(CUgraphExec hGraphExec, CUstream hStream)` Launches an executable graph in a stream.
`static int`	`cuGraphMemcpyNodeGetParams(CUgraphNode hNode, CUDA_MEMCPY3D nodeParams)` Returns a memcpy node's parameters.
`static int`	`cuGraphMemcpyNodeSetParams(CUgraphNode hNode, CUDA_MEMCPY3D nodeParams)` Sets a memcpy node's parameters.
`static int`	`cuGraphMemsetNodeGetParams(CUgraphNode hNode, CUDA_MEMSET_NODE_PARAMS nodeParams)` Returns a memset node's parameters.
`static int`	`cuGraphMemsetNodeSetParams(CUgraphNode hNode, CUDA_MEMSET_NODE_PARAMS nodeParams)` Sets a memset node's parameters.
`static int`	`cuGraphNodeFindInClone(CUgraphNode phNode, CUgraphNode hOriginalNode, CUgraph hClonedGraph)` Finds a cloned version of a node.
`static int`	`cuGraphNodeGetDependencies(CUgraphNode hNode, CUgraphNode[] dependencies, long[] numDependencies)` Returns a node's dependencies.
`static int`	`cuGraphNodeGetDependentNodes(CUgraphNode hNode, CUgraphNode[] dependentNodes, long[] numDependentNodes)` Returns a node's dependent nodes.
`static int`	`cuGraphNodeGetType(CUgraphNode hNode, int[] type)` Returns a node's type.
`static int`	`cuGraphRemoveDependencies(CUgraph hGraph, CUgraphNode[] from, CUgraphNode[] to, long numDependencies)` Removes dependency edges from a graph.
`static int`	`cuInit(int Flags)` Initialize the CUDA driver API.
`static int`	`cuIpcCloseMemHandle(CUdeviceptr dptr)` Close memory mapped with cuIpcOpenMemHandle.
`static int`	`cuIpcGetEventHandle(CUipcEventHandle pHandle, CUevent event)` Gets an interprocess handle for a previously allocated event.
`static int`	`cuIpcGetMemHandle(CUipcMemHandle pHandle, CUdeviceptr dptr)` Gets an interprocess memory handle for an existing device memory allocation.
`static int`	`cuIpcOpenEventHandle(CUevent phEvent, CUipcEventHandle handle)` Opens an interprocess event handle for use in the current process.
`static int`	`cuIpcOpenMemHandle(CUdeviceptr pdptr, CUipcMemHandle handle, int Flags)` CUresult cuIpcOpenMemHandle ( CUdeviceptr* pdptr, CUipcMemHandle handle, unsigned 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(CUfunction f)` Deprecated. Deprecated in CUDA
`static int`	`cuLaunchCooperativeKernel(CUfunction f, int gridDimX, int gridDimY, int gridDimZ, int blockDimX, int blockDimY, int blockDimZ, int sharedMemBytes, CUstream hStream, Pointer kernelParams)` Launches a CUDA function where thread blocks can cooperate and synchronize as they execute.
`static int`	`cuLaunchCooperativeKernelMultiDevice(CUDA_LAUNCH_PARAMS[] launchParamsList, int numDevices, int flags)` Launches CUDA functions on multiple devices where thread blocks can cooperate and synchronize as they execute.
`static int`	`cuLaunchGrid(CUfunction f, int grid_width, int grid_height)` Deprecated. Deprecated in CUDA
`static int`	`cuLaunchGridAsync(CUfunction f, int grid_width, int grid_height, CUstream hStream)` Deprecated. Deprecated in CUDA
`static int`	`cuLaunchHostFunc(CUstream hStream, CUhostFn fn, Object userData)` Enqueues a host function call in a stream.
`static int`	`cuLaunchKernel(CUfunction f, int gridDimX, int gridDimY, int gridDimZ, int blockDimX, int blockDimY, int blockDimZ, int sharedMemBytes, CUstream hStream, Pointer kernelParams, Pointer extra)` Launches a CUDA function.
`static int`	`cuLinkAddData(CUlinkState state, int type, Pointer data, long size, String name, JITOptions jitOptions)`
`static int`	`cuLinkAddFile(CUlinkState state, int type, String path, JITOptions jitOptions)`
`static int`	`cuLinkComplete(CUlinkState state, Pointer cubinOut, long[] sizeOut)`
`static int`	`cuLinkCreate(JITOptions jitOptions, CUlinkState stateOut)`
`static int`	`cuLinkDestroy(CUlinkState state)`
`static int`	`cuMemAddressFree(CUdeviceptr ptr, long size)` Free an address range reservation.
`static int`	`cuMemAddressReserve(CUdeviceptr ptr, long size, long alignment, CUdeviceptr addr, long flags)` Allocate an address range reservation.
`static int`	`cuMemAdvise(CUdeviceptr devPtr, long count, int advice, CUdevice device)` Advise about the usage of a given memory range Advise the Unified Memory subsystem about the usage pattern for the memory range starting at devPtr with a size of count bytes.
`static int`	`cuMemAlloc(CUdeviceptr dptr, long bytesize)` Allocates device memory.
`static int`	`cuMemAllocHost(Pointer pointer, long bytesize)` Allocates page-locked host memory.
`static int`	`cuMemAllocManaged(CUdeviceptr dptr, long bytesize, int flags)` CUresult cuMemAllocManaged ( CUdeviceptr* dptr, size_t bytesize, unsigned int flags ) Allocates memory that will be automatically managed by the Unified Memory system.
`static int`	`cuMemAllocPitch(CUdeviceptr dptr, long[] pPitch, long WidthInBytes, long Height, int ElementSizeBytes)` Allocates pitched device memory.
`static int`	`cuMemcpy(CUdeviceptr dst, CUdeviceptr src, long ByteCount)` Copies memory.
`static int`	`cuMemcpy2D(CUDA_MEMCPY2D pCopy)` Copies memory for 2D arrays.
`static int`	`cuMemcpy2DAsync(CUDA_MEMCPY2D pCopy, CUstream hStream)` Copies memory for 2D arrays.
`static int`	`cuMemcpy2DUnaligned(CUDA_MEMCPY2D pCopy)` Copies memory for 2D arrays.
`static int`	`cuMemcpy3D(CUDA_MEMCPY3D pCopy)` Copies memory for 3D arrays.
`static int`	`cuMemcpy3DAsync(CUDA_MEMCPY3D pCopy, CUstream hStream)` Copies memory for 3D arrays.
`static int`	`cuMemcpy3DPeer(CUDA_MEMCPY3D_PEER pCopy)` Copies memory between contexts.
`static int`	`cuMemcpy3DPeerAsync(CUDA_MEMCPY3D_PEER pCopy, CUstream hStream)` Copies memory between contexts asynchronously.
`static int`	`cuMemcpyAsync(CUdeviceptr dst, CUdeviceptr src, long ByteCount, CUstream hStream)` Copies memory asynchronously.
`static int`	`cuMemcpyAtoA(CUarray dstArray, long dstIndex, CUarray srcArray, long srcIndex, long ByteCount)` Copies memory from Array to Array.
`static int`	`cuMemcpyAtoD(CUdeviceptr dstDevice, CUarray hSrc, long SrcIndex, long ByteCount)` Copies memory from Array to Device.
`static int`	`cuMemcpyAtoH(Pointer dstHost, CUarray srcArray, long srcIndex, long ByteCount)` Copies memory from Array to Host.
`static int`	`cuMemcpyAtoHAsync(Pointer dstHost, CUarray srcArray, long srcIndex, long ByteCount, CUstream hStream)` Copies memory from Array to Host.
`static int`	`cuMemcpyDtoA(CUarray dstArray, long dstIndex, CUdeviceptr srcDevice, long ByteCount)` Copies memory from Device to Array.
`static int`	`cuMemcpyDtoD(CUdeviceptr dstDevice, CUdeviceptr srcDevice, long ByteCount)` Copies memory from Device to Device.
`static int`	`cuMemcpyDtoDAsync(CUdeviceptr dstDevice, CUdeviceptr srcDevice, long ByteCount, CUstream hStream)` Copies memory from Device to Device.
`static int`	`cuMemcpyDtoH(Pointer dstHost, CUdeviceptr srcDevice, long ByteCount)` Copies memory from Device to Host.
`static int`	`cuMemcpyDtoHAsync(Pointer dstHost, CUdeviceptr srcDevice, long ByteCount, CUstream hStream)` Copies memory from Device to Host.
`static int`	`cuMemcpyHtoA(CUarray dstArray, long dstIndex, Pointer pSrc, long ByteCount)` Copies memory from Host to Array.
`static int`	`cuMemcpyHtoAAsync(CUarray dstArray, long dstIndex, Pointer pSrc, long ByteCount, CUstream hStream)` Copies memory from Host to Array.
`static int`	`cuMemcpyHtoD(CUdeviceptr dstDevice, Pointer srcHost, long ByteCount)` Copies memory from Host to Device.
`static int`	`cuMemcpyHtoDAsync(CUdeviceptr dstDevice, Pointer srcHost, long ByteCount, CUstream hStream)` Copies memory from Host to Device.
`static int`	`cuMemcpyPeer(CUdeviceptr dstDevice, CUcontext dstContext, CUdeviceptr srcDevice, CUcontext srcContext, long ByteCount)` Copies device memory between two contexts.
`static int`	`cuMemcpyPeerAsync(CUdeviceptr dstDevice, CUcontext dstContext, CUdeviceptr srcDevice, CUcontext srcContext, long ByteCount, CUstream hStream)` Copies device memory between two contexts asynchronously.
`static int`	`cuMemCreate(CUmemGenericAllocationHandle handle, long size, CUmemAllocationProp prop, long flags)` Create a shareable memory handle representing a memory allocation of a given size described by the given properties.
`static int`	`cuMemExportToShareableHandle(Pointer shareableHandle, CUmemGenericAllocationHandle handle, int handleType, long flags)` Exports an allocation to a requested shareable handle type.
`static int`	`cuMemFree(CUdeviceptr dptr)` Frees device memory.
`static int`	`cuMemFreeHost(Pointer p)` Frees page-locked host memory.
`static int`	`cuMemGetAccess(long[] flags, CUmemLocation location, CUdeviceptr ptr)` Get the access \p flags set for the given \p location and \p ptr
`static int`	`cuMemGetAddressRange(CUdeviceptr pbase, long[] psize, CUdeviceptr dptr)` Get information on memory allocations.
`static int`	`cuMemGetAllocationGranularity(long[] granularity, CUmemAllocationProp prop, int option)` 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, CUmemGenericAllocationHandle handle)` Retrieve the contents of the property structure defining properties for this handle
`static int`	`cuMemGetInfo(long[] free, long[] total)` Gets free and total memory.
`static int`	`cuMemHostAlloc(Pointer pp, long bytes, int Flags)` Allocates page-locked host memory.
`static int`	`cuMemHostGetDevicePointer(CUdeviceptr ret, Pointer p, int Flags)` Passes back device pointer of mapped pinned memory.
`static int`	`cuMemHostGetFlags(int[] pFlags, Pointer p)` Passes back flags that were used for a pinned allocation.
`static int`	`cuMemHostRegister(Pointer p, long bytesize, int Flags)` Registers an existing host memory range for use by CUDA.
`static int`	`cuMemHostUnregister(Pointer p)` Unregisters a memory range that was registered with cuMemHostRegister.
`static int`	`cuMemImportFromShareableHandle(CUmemGenericAllocationHandle handle, Pointer osHandle, int shHandleType)` Imports an allocation from a requested shareable handle type.
`static int`	`cuMemMap(CUdeviceptr ptr, long size, long offset, CUmemGenericAllocationHandle handle, long flags)` Maps an allocation handle to a reserved virtual address range.
`static int`	`cuMemPrefetchAsync(CUdeviceptr devPtr, long count, CUdevice dstDevice, CUstream hStream)` Prefetches memory to the specified destination device Prefetches memory to the specified destination device. devPtr is the base device pointer of the memory to be prefetched and dstDevice is the destination device. count specifies the number of bytes to copy.
`static int`	`cuMemRangeGetAttribute(Pointer data, long dataSize, int attribute, CUdeviceptr devPtr, long count)` Query an attribute of a given memory range.
`static int`	`cuMemRangeGetAttributes(Pointer[] data, long[] dataSizes, int[] attributes, long numAttributes, CUdeviceptr devPtr, long count)` Query attributes of a given memory range.
`static int`	`cuMemRelease(CUmemGenericAllocationHandle handle)` Release a memory handle representing a memory allocation which was previously allocated through cuMemCreate.
`static int`	`cuMemRetainAllocationHandle(CUmemGenericAllocationHandle handle, Pointer addr)` Given an address addr, returns the allocation handle of the backing memory allocation.
`static int`	`cuMemSetAccess(CUdeviceptr ptr, long size, CUmemAccessDesc[] desc, long count)` Set the access flags for each location specified in \p desc for the given virtual address range.
`static int`	`cuMemsetD16(CUdeviceptr dstDevice, short us, long N)` Initializes device memory.
`static int`	`cuMemsetD16Async(CUdeviceptr dstDevice, short us, long N, CUstream hStream)` Sets device memory.
`static int`	`cuMemsetD2D16(CUdeviceptr dstDevice, long dstPitch, short us, long Width, long Height)` Initializes device memory.
`static int`	`cuMemsetD2D16Async(CUdeviceptr dstDevice, long dstPitch, short us, long Width, long Height, CUstream hStream)` Sets device memory.
`static int`	`cuMemsetD2D32(CUdeviceptr dstDevice, long dstPitch, int ui, long Width, long Height)` Initializes device memory.
`static int`	`cuMemsetD2D32Async(CUdeviceptr dstDevice, long dstPitch, int ui, long Width, long Height, CUstream hStream)` Sets device memory.
`static int`	`cuMemsetD2D8(CUdeviceptr dstDevice, long dstPitch, byte uc, long Width, long Height)` Initializes device memory.
`static int`	`cuMemsetD2D8Async(CUdeviceptr dstDevice, long dstPitch, byte uc, long Width, long Height, CUstream hStream)` Sets device memory.
`static int`	`cuMemsetD32(CUdeviceptr dstDevice, int ui, long N)` Initializes device memory.
`static int`	`cuMemsetD32Async(CUdeviceptr dstDevice, int ui, long N, CUstream hStream)` Sets device memory.
`static int`	`cuMemsetD8(CUdeviceptr dstDevice, byte uc, long N)` Initializes device memory.
`static int`	`cuMemsetD8Async(CUdeviceptr dstDevice, byte uc, long N, CUstream hStream)` Sets device memory.
`static int`	`cuMemUnmap(CUdeviceptr ptr, long size)` Unmap the backing memory of a given address range.
`static int`	`cuMipmappedArrayCreate(CUmipmappedArray pHandle, CUDA_ARRAY3D_DESCRIPTOR pMipmappedArrayDesc, int numMipmapLevels)` Creates a CUDA mipmapped array.
`static int`	`cuMipmappedArrayDestroy(CUmipmappedArray hMipmappedArray)` Destroys a CUDA mipmapped array.
`static int`	`cuMipmappedArrayGetLevel(CUarray pLevelArray, CUmipmappedArray hMipmappedArray, int level)` Gets a mipmap level of a CUDA mipmapped array.
`static int`	`cuModuleGetFunction(CUfunction hfunc, CUmodule hmod, String name)` Returns a function handle.
`static int`	`cuModuleGetGlobal(CUdeviceptr dptr, long[] bytes, CUmodule hmod, String name)` Returns a global pointer from a module.
`static int`	`cuModuleGetSurfRef(CUsurfref pSurfRef, CUmodule hmod, String name)` Returns a handle to a surface reference.
`static int`	`cuModuleGetTexRef(CUtexref pTexRef, CUmodule hmod, String name)` Returns a handle to a texture reference.
`static int`	`cuModuleLoad(CUmodule module, String fname)` Loads a compute module.
`static int`	`cuModuleLoadData(CUmodule module, byte[] image)` Load a module's data.
`static int`	`cuModuleLoadData(CUmodule module, String string)` A wrapper function for `cuModuleLoadData(CUmodule, byte[])` that converts the given string into a zero-terminated byte array.
`static int`	`cuModuleLoadDataEx(CUmodule phMod, Pointer p, int numOptions, int[] options, Pointer optionValues)` Load a module's data with options.
`static int`	`cuModuleLoadDataEx(CUmodule phMod, String string, int numOptions, int[] options, Pointer optionValues)` A wrapper function for `cuModuleLoadDataEx(CUmodule, Pointer, int, int[], Pointer)` which allows passing in the image data as a string.
`static int`	`cuModuleLoadDataJIT(CUmodule module, Pointer pointer, JITOptions jitOptions)` A wrapper function for `cuModuleLoadDataEx(CUmodule, Pointer, int, int[], Pointer)` which allows passing in the options for the JIT compiler, and obtaining the output of the JIT compiler via a `JITOptions` object.
`static int`	`cuModuleLoadFatBinary(CUmodule module, byte[] fatCubin)` Load a module's data.
`static int`	`cuModuleUnload(CUmodule hmod)` Unloads a module.
`static int`	`cuOccupancyAvailableDynamicSMemPerBlock(long[] dynamicSmemSize, CUfunction func, int numBlocks, int blockSize)` `\brief Returns dynamic shared memory available per block when launching \p numBlocks blocks on SM Returns in \p *dynamicSmemSize the maximum size of dynamic shared memory to allow \p numBlocks blocks per SM.`
`static int`	`cuOccupancyMaxActiveBlocksPerMultiprocessor(int[] numBlocks, CUfunction 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, CUfunction func, int blockSize, long dynamicSMemSize, int flags)` `\brief Suggest a launch configuration with reasonable occupancy An extended version of ::cuOccupancyMaxPotentialBlockSize.`
`static int`	`cuOccupancyMaxPotentialBlockSize(int[] minGridSize, int[] blockSize, CUfunction 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, CUfunction func, CUoccupancyB2DSize blockSizeToDynamicSMemSize, long dynamicSMemSize, int blockSizeLimit, int flags)`
`static int`	`cuParamSetf(CUfunction hfunc, int offset, float value)` Deprecated. Deprecated in CUDA
`static int`	`cuParamSeti(CUfunction hfunc, int offset, int value)` Deprecated. Deprecated in CUDA
`static int`	`cuParamSetSize(CUfunction hfunc, int numbytes)` Deprecated. Deprecated in CUDA
`static int`	`cuParamSetTexRef(CUfunction hfunc, int texunit, CUtexref hTexRef)` Deprecated. Deprecated in CUDA
`static int`	`cuParamSetv(CUfunction hfunc, int offset, Pointer ptr, int numbytes)` Deprecated. Deprecated in CUDA
`static int`	`cuPointerGetAttribute(Pointer data, int attribute, CUdeviceptr ptr)` Returns information about a pointer.
`static int`	`cuPointerGetAttributes(int numAttributes, int[] attributes, Pointer data, CUdeviceptr ptr)` Returns information about a pointer.
`static int`	`cuPointerSetAttribute(Pointer value, int attribute, CUdeviceptr ptr)` 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`	`cuProfilerInitialize(String configFile, String outputFile, int outputMode)` Deprecated. Deprecated as of CUDA 11.0
`static int`	`cuProfilerStart()` Enable profiling.
`static int`	`cuProfilerStop()` Disable profiling.
`static int`	`cuStreamAddCallback(CUstream hStream, CUstreamCallback callback, Object userData, int flags)` Add a callback to a compute stream.
`static int`	`cuStreamAttachMemAsync(CUstream hStream, CUdeviceptr dptr, long length, int flags)` Attach memory to a stream asynchronously.
`static int`	`cuStreamBatchMemOp(CUstream stream, int count, CUstreamBatchMemOpParams[] paramArray, int flags)` NOTE: This function is not yet supported in JCuda, and will throw an UnsupportedOperationException!
`static int`	`cuStreamBeginCapture(CUstream hStream, int mode)` Begins graph capture on a stream.
`static int`	`cuStreamCopyAttributes(CUstream dst, CUstream src)` Copies attributes from source stream to destination stream Copies attributes from source stream \p src to destination stream \p dst.
`static int`	`cuStreamCreate(CUstream phStream, int Flags)` Create a stream.
`static int`	`cuStreamCreateWithPriority(CUstream phStream, int flags, int priority)` Create a stream with the given priority Creates a stream with the specified priority and returns a handle in phStream.
`static int`	`cuStreamDestroy(CUstream hStream)` Destroys a stream.
`static int`	`cuStreamEndCapture(CUstream hStream, CUgraph phGraph)` Ends capture on a stream, returning the captured graph.
`static int`	`cuStreamGetAttribute(CUstream hStream, int attr, CUstreamAttrValue value_out)` Queries stream attribute.
`static int`	`cuStreamGetCaptureInfo(CUstream hStream, int[] captureStatus, long[] id)` 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 hStream, CUcontext pctx)` Query the context associated with a stream.
`static int`	`cuStreamGetFlags(CUstream hStream, int[] flags)` Query the flags of a given stream.
`static int`	`cuStreamGetPriority(CUstream hStream, int[] priority)` Query the priority of a given stream.
`static int`	`cuStreamIsCapturing(CUstream hStream, int[] captureStatus)` Returns a stream's capture status Return the capture status of \p hStream via \p captureStatus.
`static int`	`cuStreamQuery(CUstream hStream)` Determine status of a compute stream.
`static int`	`cuStreamSetAttribute(CUstream hStream, int attr, CUstreamAttrValue value)` Sets stream attribute.
`static int`	`cuStreamSynchronize(CUstream hStream)` Wait until a stream's tasks are completed.
`static int`	`cuStreamWaitEvent(CUstream hStream, CUevent hEvent, int Flags)` Make a compute stream wait on an event.
`static int`	`cuStreamWaitValue32(CUstream stream, CUdeviceptr addr, int value, int flags)` Wait on a memory location.
`static int`	`cuStreamWaitValue64(CUstream stream, CUdeviceptr addr, long value, int flags)` Wait on a memory location.
`static int`	`cuStreamWriteValue32(CUstream stream, CUdeviceptr addr, int value, int flags)` Write a value to memory.
`static int`	`cuStreamWriteValue64(CUstream stream, CUdeviceptr addr, long value, int flags)` Write a value to memory.
`static int`	`cuSurfObjectCreate(CUsurfObject pSurfObject, CUDA_RESOURCE_DESC pResDesc)` Creates a surface object.
`static int`	`cuSurfObjectDestroy(CUsurfObject surfObject)` Destroys a surface object.
`static int`	`cuSurfObjectGetResourceDesc(CUDA_RESOURCE_DESC pResDesc, CUsurfObject surfObject)` Returns a surface object's resource descriptor.
`static int`	`cuSurfRefGetArray(CUarray phArray, CUsurfref hSurfRef)` Deprecated. Deprecated as of CUDA 10.1
`static int`	`cuSurfRefSetArray(CUsurfref hSurfRef, CUarray hArray, int Flags)` Deprecated. Deprecated as of CUDA 10.1
`static int`	`cuTexObjectCreate(CUtexObject pTexObject, CUDA_RESOURCE_DESC pResDesc, CUDA_TEXTURE_DESC pTexDesc, CUDA_RESOURCE_VIEW_DESC pResViewDesc)` Creates a texture object.
`static int`	`cuTexObjectDestroy(CUtexObject texObject)` Destroys a texture object.
`static int`	`cuTexObjectGetResourceDesc(CUDA_RESOURCE_DESC pResDesc, CUtexObject texObject)` Returns a texture object's resource descriptor.
`static int`	`cuTexObjectGetResourceViewDesc(CUDA_RESOURCE_VIEW_DESC pResViewDesc, CUtexObject texObject)` Returns a texture object's resource view descriptor.
`static int`	`cuTexObjectGetTextureDesc(CUDA_TEXTURE_DESC pTexDesc, CUtexObject texObject)` Returns a texture object's texture descriptor.
`static int`	`cuTexRefCreate(CUtexref pTexRef)` Deprecated. Deprecated in CUDA
`static int`	`cuTexRefDestroy(CUtexref hTexRef)` Deprecated. Deprecated in CUDA
`static int`	`cuTexRefGetAddress(CUdeviceptr pdptr, CUtexref hTexRef)` Deprecated. Deprecated as of CUDA 10.1
`static int`	`cuTexRefGetAddressMode(int[] pam, CUtexref hTexRef, int dim)` Deprecated. Deprecated as of CUDA 10.1
`static int`	`cuTexRefGetArray(CUarray phArray, CUtexref hTexRef)` Deprecated. Deprecated as of CUDA 10.1
`static int`	`cuTexRefGetBorderColor(float[] pBorderColor, CUtexref hTexRef)` Deprecated. Deprecated as of CUDA 10.1
`static int`	`cuTexRefGetFilterMode(int[] pfm, CUtexref hTexRef)` Deprecated. Deprecated as of CUDA 10.1
`static int`	`cuTexRefGetFlags(int[] pFlags, CUtexref hTexRef)` Deprecated. Deprecated as of CUDA 10.1
`static int`	`cuTexRefGetFormat(int[] pFormat, int[] pNumChannels, CUtexref hTexRef)` Deprecated. Deprecated as of CUDA 10.1
`static int`	`cuTexRefGetMaxAnisotropy(int[] pmaxAniso, CUtexref hTexRef)` Deprecated. Deprecated as of CUDA 10.1
`static int`	`cuTexRefGetMipmapFilterMode(int[] pfm, CUtexref hTexRef)` Deprecated. Deprecated as of CUDA 10.1
`static int`	`cuTexRefGetMipmapLevelBias(float[] pbias, CUtexref hTexRef)` Deprecated. Deprecated as of CUDA 10.1
`static int`	`cuTexRefGetMipmapLevelClamp(float[] pminMipmapLevelClamp, float[] pmaxMipmapLevelClamp, CUtexref hTexRef)` Deprecated. Deprecated as of CUDA 10.1
`static int`	`cuTexRefGetMipmappedArray(CUmipmappedArray phMipmappedArray, CUtexref hTexRef)` Deprecated. Deprecated as of CUDA 10.1
`static int`	`cuTexRefSetAddress(long[] ByteOffset, CUtexref hTexRef, CUdeviceptr dptr, long bytes)` Deprecated. Deprecated as of CUDA 10.1
`static int`	`cuTexRefSetAddress2D(CUtexref hTexRef, CUDA_ARRAY_DESCRIPTOR desc, CUdeviceptr dptr, long PitchInBytes)` Deprecated. Deprecated as of CUDA 10.1
`static int`	`cuTexRefSetAddressMode(CUtexref hTexRef, int dim, int am)` Deprecated. Deprecated as of CUDA 10.1
`static int`	`cuTexRefSetArray(CUtexref hTexRef, CUarray hArray, int Flags)` Deprecated. Deprecated as of CUDA 10.1
`static int`	`cuTexRefSetBorderColor(CUtexref hTexRef, float[] pBorderColor)` Deprecated. Deprecated as of CUDA 10.1
`static int`	`cuTexRefSetFilterMode(CUtexref hTexRef, int fm)` Deprecated. Deprecated as of CUDA 10.1
`static int`	`cuTexRefSetFlags(CUtexref hTexRef, int Flags)` Deprecated. Deprecated as of CUDA 10.1
`static int`	`cuTexRefSetFormat(CUtexref hTexRef, int fmt, int NumPackedComponents)` Deprecated. Deprecated as of CUDA 10.1
`static int`	`cuTexRefSetMaxAnisotropy(CUtexref hTexRef, int maxAniso)` Deprecated. Deprecated as of CUDA 10.1
`static int`	`cuTexRefSetMipmapFilterMode(CUtexref hTexRef, int fm)` Deprecated. Deprecated as of CUDA 10.1
`static int`	`cuTexRefSetMipmapLevelBias(CUtexref hTexRef, float bias)` Deprecated. Deprecated as of CUDA 10.1
`static int`	`cuTexRefSetMipmapLevelClamp(CUtexref hTexRef, float minMipmapLevelClamp, float maxMipmapLevelClamp)` Deprecated. Deprecated as of CUDA 10.1
`static int`	`cuTexRefSetMipmappedArray(CUtexref hTexRef, CUmipmappedArray hMipmappedArray, int Flags)` Deprecated. Deprecated as of CUDA 10.1
`static int`	`cuThreadExchangeStreamCaptureMode(int[] mode)` Swaps the stream capture interaction mode for a thread.
`static void`	`setExceptionsEnabled(boolean enabled)` Enables or disables exceptions.
`static void`	`setLogLevel(LogLevel logLevel)` Set the specified log level for the JCuda driver library.

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

Field Detail
- CUDA_VERSION
```
public static final int CUDA_VERSION
```
  The CUDA version
  
  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(jcuda.Pointer, long, int)
  
  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 JCudaDriver#cuMemHostGetDevicePointer may be called on the host pointer. Flag for cuMemHostAlloc(jcuda.Pointer, long, int)
  
  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(jcuda.Pointer, long, int)
  
  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_MEMPEERREGISTER_DEVICEMAP
```
@Deprecated
public static final int CU_MEMPEERREGISTER_DEVICEMAP
```
  Deprecated. This value has been added in CUDA 4.0 RC, and removed in CUDA 4.0 RC2
  
  If set, peer memory is mapped into CUDA address space and ::cuMemPeerGetDevicePointer() may be called on the host pointer. Flag for ::cuMemPeerRegister()
  
  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
- 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
```
@Deprecated
public static final int CUDA_ARRAY3D_2DARRAY
```
  Deprecated. use CUDA_ARRAY3D_LAYERED
  
  If set, the CUDA array contains an array of 2D slices and the Depth member of CUDA_ARRAY3D_DESCRIPTOR specifies the number of slices, not the depth of a 3D array.
  
  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_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_TRSA_OVERRIDE_FORMAT
```
public static final int CU_TRSA_OVERRIDE_FORMAT
```
  Override the texref format with a format inferred from the array
  
  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]
  
  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)
  
  See Also:
  
  Constant Field Values
- CU_TRSF_SRGB
```
public static final int CU_TRSF_SRGB
```
  Perform sRGB->linear conversion during texture read. Flag for JCudaDriver#cuTexRefSetFlags()
  
  See Also:
  
  Constant Field Values
- CU_STREAM_CALLBACK_NONBLOCKING
```
@Deprecated
public static final int CU_STREAM_CALLBACK_NONBLOCKING
```
  Deprecated. This flag was only present in CUDA 5.0.25 (release candidate) and may be removed (or added again) in future releases
  
  Specifies a stream callback does not block the stream while executing. This is the default behavior. Flag for cuStreamAddCallback(CUstream, CUstreamCallback, Object, int)
  
  See Also:
  
  Constant Field Values
- CU_STREAM_CALLBACK_BLOCKING
```
@Deprecated
public static final int CU_STREAM_CALLBACK_BLOCKING
```
  Deprecated. This flag was only present in CUDA 5.0.25 (release candidate) and may be removed (or added again) in future releases
  
  If set, the stream callback blocks the stream until it is done executing. Flag for cuStreamAddCallback(CUstream, CUstreamCallback, Object, int)
  
  See Also:
  
  Constant Field Values
- CU_TRSF_DISABLE_TRILINEAR_OPTIMIZATION
```
public static final int CU_TRSF_DISABLE_TRILINEAR_OPTIMIZATION
```
  Disable any trilinear filtering optimizations. Flag for ::cuTexRefSetFlags() and ::cuTexObjectCreate()
  
  See Also:
  
  Constant Field Values
- CU_LAUNCH_PARAM_END
```
public static final Pointer CU_LAUNCH_PARAM_END
```
  End of array terminator for the \p extra parameter to ::cuLaunchKernel
- CU_LAUNCH_PARAM_BUFFER_POINTER
```
public static final 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
```
public static final 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
```
public static final CUdevice CU_DEVICE_CPU
```
  Device that represents the CPU
- CU_DEVICE_INVALID
```
public static final CUdevice CU_DEVICE_INVALID
```
  Device that represents an invalid device
- CU_STREAM_LEGACY
```
public static final CUstream CU_STREAM_LEGACY
```
  Stream handle that can be passed as a CUstream to use an implicit stream with legacy synchronization behavior.
- CU_STREAM_PER_THREAD
```
public static final CUstream CU_STREAM_PER_THREAD
```
  Stream handle that can be passed as a CUstream to use an implicit stream with per-thread synchronization behavior.

Method Detail

setLogLevel
```
public static void setLogLevel(LogLevel logLevel)
```
Set the specified log level for the JCuda driver library.

Currently supported log levels:
LOG_QUIET: Never print anything
LOG_ERROR: Print error messages
LOG_TRACE: Print a trace of all native function calls

Parameters:

logLevel - The log level to use.

setExceptionsEnabled
```
public static void setExceptionsEnabled(boolean enabled)
```
Enables or disables exceptions. By default, the methods of this class only return the CUresult error code from the underlying CUDA function. If exceptions are enabled, a CudaException with a detailed error message will be thrown if a method is about to return a result code that is not CUresult.CUDA_SUCCESS

Parameters:

enabled - Whether exceptions are enabled

align
```
@Deprecated
public static int align(int value,
                                     int alignment)
```
Deprecated. This method was intended for a simpler kernel parameter setup in earlier CUDA versions, and should not be required any more. It may be removed in future releases.

Returns the given (address) value, adjusted to have the given alignment. This function may be used to align the parameters for a kernel call according to their alignment requirements.

Parameters:

value - The address value

alignment - The desired alignment

Returns:

The aligned address value

cuModuleLoadDataJIT
```
public static int cuModuleLoadDataJIT(CUmodule module,
                                      Pointer pointer,
                                      JITOptions jitOptions)
```
A wrapper function for cuModuleLoadDataEx(CUmodule, Pointer, int, int[], Pointer) which allows passing in the options for the JIT compiler, and obtaining the output of the JIT compiler via a JITOptions object.

Note: This method should be considered as preliminary, and might change in future releases.

cuModuleLoadDataEx
```
public static int cuModuleLoadDataEx(CUmodule phMod,
                                     String string,
                                     int numOptions,
                                     int[] options,
                                     Pointer optionValues)
```
A wrapper function for cuModuleLoadDataEx(CUmodule, Pointer, int, int[], Pointer) which allows passing in the image data as a string.

Parameters:

module - Returned module

image - Module data to load

numOptions - Number of options

options - Options for JIT

optionValues - Option values for JIT

Returns:

The return code from cuModuleLoadDataEx

See Also:

cuModuleLoadDataEx(CUmodule, Pointer, int, int[], Pointer)

cuModuleLoadData
```
public static int cuModuleLoadData(CUmodule module,
                                   String string)
```
A wrapper function for cuModuleLoadData(CUmodule, byte[]) that converts the given string into a zero-terminated byte array.

Parameters:

module - The module

string - The data. May not be null.

Returns:

The return code from cuModuleLoadData

See Also:

cuModuleLoadData(CUmodule, byte[])

cuGetErrorString

public static int cuGetErrorString(int error,
                                   String[] pStr)

 Gets the string description of an error code

 Sets *pStr to the address of a NULL-terminated string description
 of the error code error.
 If the error code is not recognized, ::CUDA_ERROR_INVALID_VALUE
 will be returned and *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
See Also:: CUresult

cuGetErrorName

public static int cuGetErrorName(int error,
                                 String[] pStr)

 Gets the string representation of an error code enum name

 Sets *pStr to the address of a NULL-terminated string representation
 of the name of the enum error code error.
 If the error code is not recognized, ::CUDA_ERROR_INVALID_VALUE
 will be returned and *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
See Also:: CUresult

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

Note:
Note that this function may also return error codes from previous, asynchronous launches.
Parameters:

Flags - Initialization flag for CUDA.

Returns:

CUDA_SUCCESS, CUDA_ERROR_INVALID_VALUE, CUDA_ERROR_INVALID_DEVICE

cuDeviceGet
```
public static int cuDeviceGet(CUdevice device,
                              int ordinal)
```
Returns a handle to a compute device.
```
 CUresult cuDeviceGet (
      CUdevice* device,
      int  ordinal )
 
```
Returns a handle to a compute device. Returns in *device a device handle given an ordinal in the range [0, cuDeviceGetCount()-1].

Note:
Note that this function may also return error codes from previous, asynchronous launches.
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

See Also:

cuDeviceGetAttribute(int[], int, jcuda.driver.CUdevice), cuDeviceGetCount(int[]), cuDeviceGetName(byte[], int, jcuda.driver.CUdevice), cuDeviceTotalMem(long[], jcuda.driver.CUdevice)

cuDeviceGetCount
```
public static int cuDeviceGetCount(int[] count)
```
Returns the number of compute-capable devices.
```
 CUresult cuDeviceGetCount (
      int* count )
 
```
Returns the number of compute-capable devices. Returns in *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.

Note:
Note that this function may also return error codes from previous, asynchronous launches.
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

See Also:

cuDeviceGetAttribute(int[], int, jcuda.driver.CUdevice), cuDeviceGetName(byte[], int, jcuda.driver.CUdevice), cuDeviceGet(jcuda.driver.CUdevice, int), cuDeviceTotalMem(long[], jcuda.driver.CUdevice)

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

Note:
Note that this function may also return error codes from previous, asynchronous launches.
Parameters:

name - Returned identifier string for the device

len - Maximum length of string to store in 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

See Also:

cuDeviceGetAttribute(int[], int, jcuda.driver.CUdevice), cuDeviceGetCount(int[]), cuDeviceGet(jcuda.driver.CUdevice, int), cuDeviceTotalMem(long[], jcuda.driver.CUdevice)

cuDeviceGetUuid
```
public static int cuDeviceGetUuid(CUuuid uuid,
                                  CUdevice dev)
```
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

See Also:

JCudaDriver#cuDeviceGetCount JCudaDriver#cuDeviceGetName JCudaDriver#cuDeviceGet JCudaDriver#cuDeviceTotalMem JCudaDriver#cudaGetDeviceProperties

cuDeviceGetLuid
```
public static int cuDeviceGetLuid(byte[] luid,
                                  int[] deviceNodeMask,
                                  CUdevice dev)
```
Return an LUID and device node mask for the device. Return identifying information (\p luid and \p deviceNodeMask) to allow matching device with graphics APIs.

Parameters:

luid - - Returned LUID

deviceNodeMask - - Returned device node mask

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

See Also:

JCudaDriver#cuDeviceGetCount JCudaDriver#cuDeviceGetName JCudaDriver#cuDeviceGet JCudaDriver#cuDeviceTotalMem JCudaDriver#cudaGetDeviceProperties

cuDeviceGetLuidNative

public static int cuDeviceGetLuidNative(byte[] luid,
                                        int[] deviceNodeMask,
                                        CUdevice dev)

cuDeviceComputeCapability
```
@Deprecated
public static int cuDeviceComputeCapability(int[] major,
                                                         int[] minor,
                                                         CUdevice dev)
```
Deprecated. Deprecated as of CUDA 5.0, replaced with cuDeviceGetAttribute(int[], int, CUdevice)
Returns the compute capability of the device.
```
 CUresult cuDeviceComputeCapability (
      int* major,
      int* minor,
      CUdevice dev )
 
```
Returns the compute capability of the device. DeprecatedThis function was deprecated as of CUDA 5.0 and its functionality superceded by cuDeviceGetAttribute().

Returns in *major and *minor the major and minor revision numbers that define the compute capability of the device dev.

Note:
Note that this function may also return error codes from previous, asynchronous launches.
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

See Also:

cuDeviceGetAttribute(int[], int, jcuda.driver.CUdevice), cuDeviceGetCount(int[]), cuDeviceGetName(byte[], int, jcuda.driver.CUdevice), cuDeviceGet(jcuda.driver.CUdevice, int), cuDeviceTotalMem(long[], jcuda.driver.CUdevice)

cuDevicePrimaryCtxRetain

public static int cuDevicePrimaryCtxRetain(CUcontext pctx,
                                           CUdevice dev)

cuDevicePrimaryCtxRelease

public static int cuDevicePrimaryCtxRelease(CUdevice dev)

cuDevicePrimaryCtxSetFlags

public static int cuDevicePrimaryCtxSetFlags(CUdevice dev,
                                             int flags)

cuDeviceTotalMem
```
public static int cuDeviceTotalMem(long[] bytes,
                                   CUdevice dev)
```
Returns the total amount of memory on the device.
```
 CUresult cuDeviceTotalMem (
      size_t* bytes,
      CUdevice dev )
 
```
Returns the total amount of memory on the device. Returns in *bytes the total amount of memory available on the device dev in bytes.

Note:
Note that this function may also return error codes from previous, asynchronous launches.
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

See Also:

cuDeviceGetAttribute(int[], int, jcuda.driver.CUdevice), cuDeviceGetCount(int[]), cuDeviceGetName(byte[], int, jcuda.driver.CUdevice), cuDeviceGet(jcuda.driver.CUdevice, int)

cuDeviceGetProperties
```
@Deprecated
public static int cuDeviceGetProperties(CUdevprop prop,
                                                     CUdevice dev)
```
Deprecated. Deprecated as of CUDA 5.0, replaced with cuDeviceGetAttribute(int[], int, CUdevice)
Returns properties for a selected device.
```
 CUresult cuDeviceGetProperties (
      CUdevprop* prop,
      CUdevice dev )
 
```
Returns properties for a selected device. DeprecatedThis function was deprecated as of CUDA 5.0 and replaced by cuDeviceGetAttribute().

Returns in *prop the properties of device 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.
Note:
Note that this function may also return error codes from previous, asynchronous launches.
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

See Also:

cuDeviceGetAttribute(int[], int, jcuda.driver.CUdevice), cuDeviceGetCount(int[]), cuDeviceGetName(byte[], int, jcuda.driver.CUdevice), cuDeviceGet(jcuda.driver.CUdevice, int), cuDeviceTotalMem(long[], jcuda.driver.CUdevice)

cuDeviceGetAttribute
```
public static int cuDeviceGetAttribute(int[] pi,
                                       int attrib,
                                       CUdevice dev)
```
Returns information about the device.
```
 CUresult cuDeviceGetAttribute (
      int* pi,
      CUdevice_attribute attrib,
      CUdevice dev )
 
```
Returns information about the device. Returns in *pi the integer value of the attribute attrib on device 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; this amount is shared by all thread blocks simultaneously resident on a multiprocessor;
- 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; this number is shared by all thread blocks simultaneously resident on a multiprocessor;
- CU_DEVICE_ATTRIBUTE_CLOCK_RATE: 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_EXCLUSIVE: Compute-exclusive mode - Device can have only one CUDA context present on it at a 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
Note:
Note that this function may also return error codes from previous, asynchronous launches.
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

See Also:

cuDeviceGetCount(int[]), cuDeviceGetName(byte[], int, jcuda.driver.CUdevice), cuDeviceGet(jcuda.driver.CUdevice, int), cuDeviceTotalMem(long[], jcuda.driver.CUdevice)

cuDriverGetVersion
```
public static int cuDriverGetVersion(int[] driverVersion)
```
Returns the latest CUDA version supported by driver.
```
 CUresult cuDriverGetVersion (
      int* driverVersion )
 
```
Returns the CUDA driver version. Returns in *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 the driverVersion argument is NULL.

Note:
Note that this function may also return error codes from previous, asynchronous launches.
Parameters:

driverVersion - Returns the CUDA driver version

Returns:

CUDA_SUCCESS, CUDA_ERROR_INVALID_VALUE

cuCtxCreate
```
public static int cuCtxCreate(CUcontext pctx,
                              int flags,
                              CUdevice dev)
```
Create a CUDA context.
```
 CUresult cuCtxCreate (
      CUcontext* pctx,
      unsigned int  flags,
      CUdevice dev )
 
```
Create a CUDA context. Creates a new CUDA context and associates it with the calling thread. The flags parameter is described below. The context is created with a usage count of 1 and the caller of cuCtxCreate() must call cuCtxDestroy() or 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 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_AUTO: The default value if the flags parameter is zero, uses a heuristic based on the number of active CUDA contexts in the process C and the number of logical processors in the system P. If C > P, then CUDA will yield to other OS threads when waiting for the GPU, otherwise CUDA will not yield while waiting for results and actively spin on the processor.
- 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_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. Similarly, context creation will also fail with CUDA_ERROR_UNKNOWN if the compute mode for the device is set to CU_COMPUTEMODE_EXCLUSIVE and there is already an active context on the device. 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.

Note:
Note that this function may also return error codes from previous, asynchronous launches.
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

See Also:

cuCtxDestroy(jcuda.driver.CUcontext), cuCtxGetApiVersion(jcuda.driver.CUcontext, int[]), cuCtxGetCacheConfig(int[]), cuCtxGetDevice(jcuda.driver.CUdevice), cuCtxGetLimit(long[], int), cuCtxPopCurrent(jcuda.driver.CUcontext), cuCtxPushCurrent(jcuda.driver.CUcontext), cuCtxSetCacheConfig(int), cuCtxSetLimit(int, long), cuCtxSynchronize()

cuCtxDestroy
```
public static int cuCtxDestroy(CUcontext ctx)
```
Destroy a CUDA context.
```
 CUresult cuCtxDestroy (
      CUcontext ctx )
 
```
Destroy a CUDA context. Destroys the CUDA context specified by ctx. The context 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 ctx while cuCtxDestroy() is executing.

If ctx is current to the calling thread then ctx will also be popped from the current thread's context stack (as though cuCtxPopCurrent() were called). If ctx is current to other threads, then ctx will remain current to those threads, and attempting to access ctx from those threads will result in the error CUDA_ERROR_CONTEXT_IS_DESTROYED.

Note:
Note that this function may also return error codes from previous, asynchronous launches.
Parameters:

ctx - Context to destroy

Returns:

CUDA_SUCCESS, CUDA_ERROR_DEINITIALIZED, CUDA_ERROR_NOT_INITIALIZED, CUDA_ERROR_INVALID_CONTEXT, CUDA_ERROR_INVALID_VALUE

See Also:

cuCtxCreate(jcuda.driver.CUcontext, int, jcuda.driver.CUdevice), cuCtxGetApiVersion(jcuda.driver.CUcontext, int[]), cuCtxGetCacheConfig(int[]), cuCtxGetDevice(jcuda.driver.CUdevice), cuCtxGetLimit(long[], int), cuCtxPopCurrent(jcuda.driver.CUcontext), cuCtxPushCurrent(jcuda.driver.CUcontext), cuCtxSetCacheConfig(int), cuCtxSetLimit(int, long), cuCtxSynchronize()

cuCtxAttach
```
@Deprecated
public static int cuCtxAttach(CUcontext pctx,
                                           int flags)
```
Deprecated. Deprecated in CUDA
Increment a context's usage-count.
```
 CUresult cuCtxAttach (
      CUcontext* pctx,
      unsigned int  flags )
 
```
Increment a context's usage-count. DeprecatedNote that this function is deprecated and should not be used.

Increments the usage count of the context and passes back a context handle in *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 flags parameter must be 0.

Note:
Note that this function may also return error codes from previous, asynchronous launches.
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

See Also:

cuCtxCreate(jcuda.driver.CUcontext, int, jcuda.driver.CUdevice), cuCtxDestroy(jcuda.driver.CUcontext), cuCtxDetach(jcuda.driver.CUcontext), cuCtxGetApiVersion(jcuda.driver.CUcontext, int[]), cuCtxGetCacheConfig(int[]), cuCtxGetDevice(jcuda.driver.CUdevice), cuCtxGetLimit(long[], int), cuCtxPopCurrent(jcuda.driver.CUcontext), cuCtxPushCurrent(jcuda.driver.CUcontext), cuCtxSetCacheConfig(int), cuCtxSetLimit(int, long), cuCtxSynchronize()

cuCtxDetach
```
@Deprecated
public static int cuCtxDetach(CUcontext ctx)
```
Deprecated. Deprecated in CUDA
Decrement a context's usage-count.
```
 CUresult cuCtxDetach (
      CUcontext ctx )
 
```
Decrement a context's usage-count. DeprecatedNote that this function is deprecated and should not be used.

Decrements the usage count of the context 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.

Note:
Note that this function may also return error codes from previous, asynchronous launches.
Parameters:

ctx - Context to destroy

Returns:

CUDA_SUCCESS, CUDA_ERROR_DEINITIALIZED, CUDA_ERROR_NOT_INITIALIZED, CUDA_ERROR_INVALID_CONTEXT

See Also:

cuCtxCreate(jcuda.driver.CUcontext, int, jcuda.driver.CUdevice), cuCtxDestroy(jcuda.driver.CUcontext), cuCtxGetApiVersion(jcuda.driver.CUcontext, int[]), cuCtxGetCacheConfig(int[]), cuCtxGetDevice(jcuda.driver.CUdevice), cuCtxGetLimit(long[], int), cuCtxPopCurrent(jcuda.driver.CUcontext), cuCtxPushCurrent(jcuda.driver.CUcontext), cuCtxSetCacheConfig(int), cuCtxSetLimit(int, long), cuCtxSynchronize()

cuCtxPushCurrent
```
public static int cuCtxPushCurrent(CUcontext ctx)
```
Pushes a context on the current CPU thread.
```
 CUresult cuCtxPushCurrent (
      CUcontext ctx )
 
```
Pushes a context on the current CPU thread. Pushes the given context 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().

Note:
Note that this function may also return error codes from previous, asynchronous launches.
Parameters:

ctx - Context to push

Returns:

CUDA_SUCCESS, CUDA_ERROR_DEINITIALIZED, CUDA_ERROR_NOT_INITIALIZED, CUDA_ERROR_INVALID_CONTEXT, CUDA_ERROR_INVALID_VALUE

See Also:

cuCtxCreate(jcuda.driver.CUcontext, int, jcuda.driver.CUdevice), cuCtxDestroy(jcuda.driver.CUcontext), cuCtxGetApiVersion(jcuda.driver.CUcontext, int[]), cuCtxGetCacheConfig(int[]), cuCtxGetDevice(jcuda.driver.CUdevice), cuCtxGetLimit(long[], int), cuCtxPopCurrent(jcuda.driver.CUcontext), cuCtxSetCacheConfig(int), cuCtxSetLimit(int, long), cuCtxSynchronize()

cuCtxPopCurrent
```
public static int cuCtxPopCurrent(CUcontext pctx)
```
Pops the current CUDA context from the current CPU thread.
```
 CUresult cuCtxPopCurrent (
      CUcontext* pctx )
 
```
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 *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.

Note:
Note that this function may also return error codes from previous, asynchronous launches.
Parameters:

pctx - Returned new context handle

Returns:

CUDA_SUCCESS, CUDA_ERROR_DEINITIALIZED, CUDA_ERROR_NOT_INITIALIZED, CUDA_ERROR_INVALID_CONTEXT

See Also:

cuCtxCreate(jcuda.driver.CUcontext, int, jcuda.driver.CUdevice), cuCtxDestroy(jcuda.driver.CUcontext), cuCtxGetApiVersion(jcuda.driver.CUcontext, int[]), cuCtxGetCacheConfig(int[]), cuCtxGetDevice(jcuda.driver.CUdevice), cuCtxGetLimit(long[], int), cuCtxPushCurrent(jcuda.driver.CUcontext), cuCtxSetCacheConfig(int), cuCtxSetLimit(int, long), cuCtxSynchronize()

cuCtxSetCurrent
```
public static int cuCtxSetCurrent(CUcontext ctx)
```
Binds the specified CUDA context to the calling CPU thread.
```
 CUresult cuCtxSetCurrent (
      CUcontext ctx )
 
```
Binds the specified CUDA context to the calling CPU thread. Binds the specified CUDA context to the calling CPU thread. If 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 ctx. If 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).

Note:
Note that this function may also return error codes from previous, asynchronous launches.
Parameters:

ctx - Context to bind to the calling CPU thread

Returns:

CUDA_SUCCESS, CUDA_ERROR_DEINITIALIZED, CUDA_ERROR_NOT_INITIALIZED, CUDA_ERROR_INVALID_CONTEXT

See Also:

cuCtxGetCurrent(jcuda.driver.CUcontext), cuCtxCreate(jcuda.driver.CUcontext, int, jcuda.driver.CUdevice), cuCtxDestroy(jcuda.driver.CUcontext)

cuCtxGetCurrent
```
public static int cuCtxGetCurrent(CUcontext pctx)
```
Returns the CUDA context bound to the calling CPU thread.
```
 CUresult cuCtxGetCurrent (
      CUcontext* pctx )
 
```
Returns the CUDA context bound to the calling CPU thread. Returns in *pctx the CUDA context bound to the calling CPU thread. If no context is bound to the calling CPU thread then *pctx is set to NULL and CUDA_SUCCESS is returned.

Note:
Note that this function may also return error codes from previous, asynchronous launches.
Parameters:

pctx - Returned context handle

Returns:

CUDA_SUCCESS, CUDA_ERROR_DEINITIALIZED, CUDA_ERROR_NOT_INITIALIZED,

See Also:

cuCtxSetCurrent(jcuda.driver.CUcontext), cuCtxCreate(jcuda.driver.CUcontext, int, jcuda.driver.CUdevice), cuCtxDestroy(jcuda.driver.CUcontext)

cuCtxGetDevice
```
public static int cuCtxGetDevice(CUdevice device)
```
Returns the device ID for the current context.
```
 CUresult cuCtxGetDevice (
      CUdevice* device )
 
```
Returns the device ID for the current context. Returns in *device the ordinal of the current context's device.

Note:
Note that this function may also return error codes from previous, asynchronous launches.
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,

See Also:

cuCtxCreate(jcuda.driver.CUcontext, int, jcuda.driver.CUdevice), cuCtxDestroy(jcuda.driver.CUcontext), cuCtxGetApiVersion(jcuda.driver.CUcontext, int[]), cuCtxGetCacheConfig(int[]), cuCtxGetLimit(long[], int), cuCtxPopCurrent(jcuda.driver.CUcontext), cuCtxPushCurrent(jcuda.driver.CUcontext), cuCtxSetCacheConfig(int), cuCtxSetLimit(int, long), cuCtxSynchronize()

cuCtxGetFlags

public static int cuCtxGetFlags(int[] flags)

cuCtxSynchronize
```
public static int cuCtxSynchronize()
```
Block for a context's tasks to complete.
```
 CUresult cuCtxSynchronize (
      void )
 
```
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.

Note:
Note that this function may also return error codes from previous, asynchronous launches.
Returns:

CUDA_SUCCESS, CUDA_ERROR_DEINITIALIZED, CUDA_ERROR_NOT_INITIALIZED, CUDA_ERROR_INVALID_CONTEXT

See Also:

cuCtxCreate(jcuda.driver.CUcontext, int, jcuda.driver.CUdevice), cuCtxDestroy(jcuda.driver.CUcontext), cuCtxGetApiVersion(jcuda.driver.CUcontext, int[]), cuCtxGetCacheConfig(int[]), cuCtxGetDevice(jcuda.driver.CUdevice), cuCtxGetLimit(long[], int), cuCtxPopCurrent(jcuda.driver.CUcontext), cuCtxPushCurrent(jcuda.driver.CUcontext), cuCtxSetCacheConfig(int), cuCtxSetLimit(int, long)

cuModuleLoad
```
public static int cuModuleLoad(CUmodule module,
                               String fname)
```
Loads a compute module.
```
 CUresult cuModuleLoad (
      CUmodule* module,
      const char* fname )
 
```
Loads a compute module. Takes a filename fname and loads the corresponding module 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 cubin file as output by nvcc, or a PTX file either as output by nvcc or handwritten, or a fatbin file as output by nvcc from toolchain 4.0 or later.

Note:
Note that this function may also return error codes from previous, asynchronous launches.
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_NOT_FOUND, CUDA_ERROR_OUT_OF_MEMORY, CUDA_ERROR_FILE_NOT_FOUND, CUDA_ERROR_SHARED_OBJECT_SYMBOL_NOT_FOUND, CUDA_ERROR_SHARED_OBJECT_INIT_FAILED

See Also:

cuModuleGetFunction(jcuda.driver.CUfunction, jcuda.driver.CUmodule, java.lang.String), cuModuleGetGlobal(jcuda.driver.CUdeviceptr, long[], jcuda.driver.CUmodule, java.lang.String), cuModuleGetTexRef(jcuda.driver.CUtexref, jcuda.driver.CUmodule, java.lang.String), cuModuleLoadData(jcuda.driver.CUmodule, java.lang.String), cuModuleLoadDataEx(jcuda.driver.CUmodule, java.lang.String, int, int[], jcuda.Pointer), cuModuleLoadFatBinary(jcuda.driver.CUmodule, byte[]), cuModuleUnload(jcuda.driver.CUmodule)

cuModuleLoadData
```
public static int cuModuleLoadData(CUmodule module,
                                   byte[] image)
```
Load a module's data.
```
 CUresult cuModuleLoadData (
      CUmodule* module,
      const void* image )
 
```
Load a module's data. Takes a pointer image and loads the corresponding module module into the current context. The pointer may be obtained by mapping a cubin or PTX or fatbin file, passing a cubin or PTX or fatbin file as a NULL-terminated text string, or incorporating a cubin or fatbin object into the executable resources and using operating system calls such as Windows FindResource() to obtain the pointer.

Note:
Note that this function may also return error codes from previous, asynchronous launches.
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_OUT_OF_MEMORY, CUDA_ERROR_SHARED_OBJECT_SYMBOL_NOT_FOUND, CUDA_ERROR_SHARED_OBJECT_INIT_FAILED

See Also:

cuModuleGetFunction(jcuda.driver.CUfunction, jcuda.driver.CUmodule, java.lang.String), cuModuleGetGlobal(jcuda.driver.CUdeviceptr, long[], jcuda.driver.CUmodule, java.lang.String), cuModuleGetTexRef(jcuda.driver.CUtexref, jcuda.driver.CUmodule, java.lang.String), cuModuleLoad(jcuda.driver.CUmodule, java.lang.String), cuModuleLoadDataEx(jcuda.driver.CUmodule, java.lang.String, int, int[], jcuda.Pointer), cuModuleLoadFatBinary(jcuda.driver.CUmodule, byte[]), cuModuleUnload(jcuda.driver.CUmodule)

cuModuleLoadDataEx
```
public static int cuModuleLoadDataEx(CUmodule phMod,
                                     Pointer p,
                                     int numOptions,
                                     int[] options,
                                     Pointer optionValues)
```
Load a module's data with options.

Note: It is hardly possible to properly pass in the required option values for this method. Thus, the arguments here must be
numOptions=0
options=new int[0]
optionValues=Pointer.to(new int[0]))
For passing in real options, use cuModuleLoadDataJIT(CUmodule, Pointer, JITOptions) instead
```
 CUresult cuModuleLoadDataEx (
      CUmodule* module,
      const void* image,
      unsigned int  numOptions,
      CUjit_option* options,
      void** optionValues )
 
```
Load a module's data with options. Takes a pointer image and loads the corresponding module module into the current context. The pointer may be obtained by mapping a cubin or PTX or fatbin file, passing a cubin or PTX or fatbin file as a NULL-terminated text string, or incorporating a cubin or fatbin object into the executable resources and using operating system calls such as Windows FindResource() to obtain the pointer. Options are passed as an array via options and any corresponding parameters are passed in optionValues. The number of total options is supplied via numOptions. Any outputs will be returned via optionValues. Supported options are (types for the option values are specified in parentheses after the option name):
- CU_JIT_MAX_REGISTERS: (unsigned int) input specifies the maximum number of registers per thread;
- CU_JIT_THREADS_PER_BLOCK: (unsigned int) input specifies number of threads per block to target compilation for; output returns the number of threads the compiler actually targeted;
- CU_JIT_WALL_TIME: (float) output returns the float value of wall clock time, in milliseconds, spent compiling the PTX code;
- CU_JIT_INFO_LOG_BUFFER: (char*) input is a pointer to a buffer in which to print any informational log messages from PTX assembly (the buffer size is specified via option CU_JIT_INFO_LOG_BUFFER_SIZE_BYTES);
- CU_JIT_INFO_LOG_BUFFER_SIZE_BYTES: (unsigned int) input is the size in bytes of the buffer; output is the number of bytes filled with messages;
- CU_JIT_ERROR_LOG_BUFFER: (char*) input is a pointer to a buffer in which to print any error log messages from PTX assembly (the buffer size is specified via option CU_JIT_ERROR_LOG_BUFFER_SIZE_BYTES);
- CU_JIT_ERROR_LOG_BUFFER_SIZE_BYTES: (unsigned int) input is the size in bytes of the buffer; output is the number of bytes filled with messages;
- CU_JIT_OPTIMIZATION_LEVEL: (unsigned int) input is the level of optimization to apply to generated code (0 - 4), with 4 being the default and highest level;
- CU_JIT_TARGET_FROM_CUCONTEXT: (No option value) causes compilation target to be determined based on current attached context (default);
- CU_JIT_TARGET: (unsigned int for enumerated type CUjit_target_enum) input is the compilation target based on supplied CUjit_target_enum; possible values are:
  
  CU_TARGET_COMPUTE_10
  
  CU_TARGET_COMPUTE_11
  
  CU_TARGET_COMPUTE_12
  
  CU_TARGET_COMPUTE_13
  
  CU_TARGET_COMPUTE_20
- CU_JIT_FALLBACK_STRATEGY: (unsigned int for enumerated type CUjit_fallback_enum) chooses fallback strategy if matching cubin is not found; possible values are:
  
  CU_PREFER_PTX
  
  CU_PREFER_BINARY
Note:
Note that this function may also return error codes from previous, asynchronous launches.
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_OUT_OF_MEMORY, CUDA_ERROR_NO_BINARY_FOR_GPU, CUDA_ERROR_SHARED_OBJECT_SYMBOL_NOT_FOUND, CUDA_ERROR_SHARED_OBJECT_INIT_FAILED

See Also:

cuModuleGetFunction(jcuda.driver.CUfunction, jcuda.driver.CUmodule, java.lang.String), cuModuleGetGlobal(jcuda.driver.CUdeviceptr, long[], jcuda.driver.CUmodule, java.lang.String), cuModuleGetTexRef(jcuda.driver.CUtexref, jcuda.driver.CUmodule, java.lang.String), cuModuleLoad(jcuda.driver.CUmodule, java.lang.String), cuModuleLoadData(jcuda.driver.CUmodule, java.lang.String), cuModuleLoadFatBinary(jcuda.driver.CUmodule, byte[]), cuModuleUnload(jcuda.driver.CUmodule)

cuModuleLoadFatBinary
```
public static int cuModuleLoadFatBinary(CUmodule module,
                                        byte[] fatCubin)
```
Load a module's data.
```
 CUresult cuModuleLoadFatBinary (
      CUmodule* module,
      const void* fatCubin )
 
```
Load a module's data. Takes a pointer fatCubin and loads the corresponding module module into the current context. The pointer represents a fat binary object, which is a collection of different cubin and/or 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 nvcc. More information can be found in the nvcc document.

Note:
Note that this function may also return error codes from previous, asynchronous launches.
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_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

See Also:

cuModuleGetFunction(jcuda.driver.CUfunction, jcuda.driver.CUmodule, java.lang.String), cuModuleGetGlobal(jcuda.driver.CUdeviceptr, long[], jcuda.driver.CUmodule, java.lang.String), cuModuleGetTexRef(jcuda.driver.CUtexref, jcuda.driver.CUmodule, java.lang.String), cuModuleLoad(jcuda.driver.CUmodule, java.lang.String), cuModuleLoadData(jcuda.driver.CUmodule, java.lang.String), cuModuleLoadDataEx(jcuda.driver.CUmodule, java.lang.String, int, int[], jcuda.Pointer), cuModuleUnload(jcuda.driver.CUmodule)

cuModuleUnload
```
public static int cuModuleUnload(CUmodule hmod)
```
Unloads a module.
```
 CUresult cuModuleUnload (
      CUmodule hmod )
 
```
Unloads a module. Unloads a module hmod from the current context.

Note:
Note that this function may also return error codes from previous, asynchronous launches.
Parameters:

hmod - Module to unload

Returns:

CUDA_SUCCESS, CUDA_ERROR_DEINITIALIZED, CUDA_ERROR_NOT_INITIALIZED, CUDA_ERROR_INVALID_CONTEXT, CUDA_ERROR_INVALID_VALUE

See Also:

cuModuleGetFunction(jcuda.driver.CUfunction, jcuda.driver.CUmodule, java.lang.String), cuModuleGetGlobal(jcuda.driver.CUdeviceptr, long[], jcuda.driver.CUmodule, java.lang.String), cuModuleGetTexRef(jcuda.driver.CUtexref, jcuda.driver.CUmodule, java.lang.String), cuModuleLoad(jcuda.driver.CUmodule, java.lang.String), cuModuleLoadData(jcuda.driver.CUmodule, java.lang.String), cuModuleLoadDataEx(jcuda.driver.CUmodule, java.lang.String, int, int[], jcuda.Pointer), cuModuleLoadFatBinary(jcuda.driver.CUmodule, byte[])

cuModuleGetFunction
```
public static int cuModuleGetFunction(CUfunction hfunc,
                                      CUmodule hmod,
                                      String name)
```
Returns a function handle.
```
 CUresult cuModuleGetFunction (
      CUfunction* hfunc,
      CUmodule hmod,
      const char* name )
 
```
Returns a function handle. Returns in *hfunc the handle of the function of name name located in module hmod. If no function of that name exists, cuModuleGetFunction() returns CUDA_ERROR_NOT_FOUND.

Note:
Note that this function may also return error codes from previous, asynchronous launches.
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

See Also:

cuModuleGetGlobal(jcuda.driver.CUdeviceptr, long[], jcuda.driver.CUmodule, java.lang.String), cuModuleGetTexRef(jcuda.driver.CUtexref, jcuda.driver.CUmodule, java.lang.String), cuModuleLoad(jcuda.driver.CUmodule, java.lang.String), cuModuleLoadData(jcuda.driver.CUmodule, java.lang.String), cuModuleLoadDataEx(jcuda.driver.CUmodule, java.lang.String, int, int[], jcuda.Pointer), cuModuleLoadFatBinary(jcuda.driver.CUmodule, byte[]), cuModuleUnload(jcuda.driver.CUmodule)

cuModuleGetGlobal
```
public static int cuModuleGetGlobal(CUdeviceptr dptr,
                                    long[] bytes,
                                    CUmodule hmod,
                                    String name)
```
Returns a global pointer from a module.
```
 CUresult cuModuleGetGlobal (
      CUdeviceptr* dptr,
      size_t* bytes,
      CUmodule hmod,
      const char* name )
 
```
Returns a global pointer from a module. Returns in *dptr and *bytes the base pointer and size of the global of name name located in module hmod. If no variable of that name exists, cuModuleGetGlobal() returns CUDA_ERROR_NOT_FOUND. Both parameters dptr and bytes are optional. If one of them is NULL, it is ignored.

Note:
Note that this function may also return error codes from previous, asynchronous launches.
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

See Also:

cuModuleGetFunction(jcuda.driver.CUfunction, jcuda.driver.CUmodule, java.lang.String), cuModuleGetTexRef(jcuda.driver.CUtexref, jcuda.driver.CUmodule, java.lang.String), cuModuleLoad(jcuda.driver.CUmodule, java.lang.String), cuModuleLoadData(jcuda.driver.CUmodule, java.lang.String), cuModuleLoadDataEx(jcuda.driver.CUmodule, java.lang.String, int, int[], jcuda.Pointer), cuModuleLoadFatBinary(jcuda.driver.CUmodule, byte[]), cuModuleUnload(jcuda.driver.CUmodule)

cuModuleGetTexRef
```
public static int cuModuleGetTexRef(CUtexref pTexRef,
                                    CUmodule hmod,
                                    String name)
```
Returns a handle to a texture reference.
```
 CUresult cuModuleGetTexRef (
      CUtexref* pTexRef,
      CUmodule hmod,
      const char* name )
 
```
Returns a handle to a texture reference. Returns in *pTexRef the handle of the texture reference of name name in the module 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.

Note:
Note that this function may also return error codes from previous, asynchronous launches.
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

See Also:

cuModuleGetFunction(jcuda.driver.CUfunction, jcuda.driver.CUmodule, java.lang.String), cuModuleGetGlobal(jcuda.driver.CUdeviceptr, long[], jcuda.driver.CUmodule, java.lang.String), cuModuleGetSurfRef(jcuda.driver.CUsurfref, jcuda.driver.CUmodule, java.lang.String), cuModuleLoad(jcuda.driver.CUmodule, java.lang.String), cuModuleLoadData(jcuda.driver.CUmodule, java.lang.String), cuModuleLoadDataEx(jcuda.driver.CUmodule, java.lang.String, int, int[], jcuda.Pointer), cuModuleLoadFatBinary(jcuda.driver.CUmodule, byte[]), cuModuleUnload(jcuda.driver.CUmodule)

cuModuleGetSurfRef
```
public static int cuModuleGetSurfRef(CUsurfref pSurfRef,
                                     CUmodule hmod,
                                     String name)
```
Returns a handle to a surface reference.
```
 CUresult cuModuleGetSurfRef (
      CUsurfref* pSurfRef,
      CUmodule hmod,
      const char* name )
 
```
Returns a handle to a surface reference. Returns in *pSurfRef the handle of the surface reference of name name in the module hmod. If no surface reference of that name exists, cuModuleGetSurfRef() returns CUDA_ERROR_NOT_FOUND.

Note:
Note that this function may also return error codes from previous, asynchronous launches.
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

See Also:

cuModuleGetFunction(jcuda.driver.CUfunction, jcuda.driver.CUmodule, java.lang.String), cuModuleGetGlobal(jcuda.driver.CUdeviceptr, long[], jcuda.driver.CUmodule, java.lang.String), cuModuleGetTexRef(jcuda.driver.CUtexref, jcuda.driver.CUmodule, java.lang.String), cuModuleLoad(jcuda.driver.CUmodule, java.lang.String), cuModuleLoadData(jcuda.driver.CUmodule, java.lang.String), cuModuleLoadDataEx(jcuda.driver.CUmodule, java.lang.String, int, int[], jcuda.Pointer), cuModuleLoadFatBinary(jcuda.driver.CUmodule, byte[]), cuModuleUnload(jcuda.driver.CUmodule)

cuLinkCreate

public static int cuLinkCreate(JITOptions jitOptions,
                               CUlinkState stateOut)

cuLinkAddData

public static int cuLinkAddData(CUlinkState state,
                                int type,
                                Pointer data,
                                long size,
                                String name,
                                JITOptions jitOptions)

cuLinkAddFile

public static int cuLinkAddFile(CUlinkState state,
                                int type,
                                String path,
                                JITOptions jitOptions)

cuLinkComplete

public static int cuLinkComplete(CUlinkState state,
                                 Pointer cubinOut,
                                 long[] sizeOut)

cuLinkDestroy

public static int cuLinkDestroy(CUlinkState state)

cuMemGetInfo
```
public static int cuMemGetInfo(long[] free,
                               long[] total)
```
Gets free and total memory.
```
 CUresult cuMemGetInfo (
      size_t* free,
      size_t* total )
 
```
Gets free and total memory. Returns in *free and *total respectively, the free and total amount of memory available for allocation by the CUDA context, in bytes.

Note:
Note that this function may also return error codes from previous, asynchronous launches.
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

See Also:

cuArray3DCreate(jcuda.driver.CUarray, jcuda.driver.CUDA_ARRAY3D_DESCRIPTOR), cuArray3DGetDescriptor(jcuda.driver.CUDA_ARRAY3D_DESCRIPTOR, jcuda.driver.CUarray), cuArrayCreate(jcuda.driver.CUarray, jcuda.driver.CUDA_ARRAY_DESCRIPTOR), cuArrayDestroy(jcuda.driver.CUarray), cuArrayGetDescriptor(jcuda.driver.CUDA_ARRAY_DESCRIPTOR, jcuda.driver.CUarray), cuMemAlloc(jcuda.driver.CUdeviceptr, long), cuMemAllocHost(jcuda.Pointer, long), cuMemAllocPitch(jcuda.driver.CUdeviceptr, long[], long, long, int), cuMemcpy2D(jcuda.driver.CUDA_MEMCPY2D), cuMemcpy2DAsync(jcuda.driver.CUDA_MEMCPY2D, jcuda.driver.CUstream), cuMemcpy2DUnaligned(jcuda.driver.CUDA_MEMCPY2D), cuMemcpy3D(jcuda.driver.CUDA_MEMCPY3D), cuMemcpy3DAsync(jcuda.driver.CUDA_MEMCPY3D, jcuda.driver.CUstream), cuMemcpyAtoA(jcuda.driver.CUarray, long, jcuda.driver.CUarray, long, long), cuMemcpyAtoD(jcuda.driver.CUdeviceptr, jcuda.driver.CUarray, long, long), cuMemcpyAtoH(jcuda.Pointer, jcuda.driver.CUarray, long, long), cuMemcpyAtoHAsync(jcuda.Pointer, jcuda.driver.CUarray, long, long, jcuda.driver.CUstream), cuMemcpyDtoA(jcuda.driver.CUarray, long, jcuda.driver.CUdeviceptr, long), cuMemcpyDtoD(jcuda.driver.CUdeviceptr, jcuda.driver.CUdeviceptr, long), cuMemcpyDtoDAsync(jcuda.driver.CUdeviceptr, jcuda.driver.CUdeviceptr, long, jcuda.driver.CUstream), cuMemcpyDtoH(jcuda.Pointer, jcuda.driver.CUdeviceptr, long), cuMemcpyDtoHAsync(jcuda.Pointer, jcuda.driver.CUdeviceptr, long, jcuda.driver.CUstream), cuMemcpyHtoA(jcuda.driver.CUarray, long, jcuda.Pointer, long), cuMemcpyHtoAAsync(jcuda.driver.CUarray, long, jcuda.Pointer, long, jcuda.driver.CUstream), cuMemcpyHtoD(jcuda.driver.CUdeviceptr, jcuda.Pointer, long), cuMemcpyHtoDAsync(jcuda.driver.CUdeviceptr, jcuda.Pointer, long, jcuda.driver.CUstream), cuMemFree(jcuda.driver.CUdeviceptr), cuMemFreeHost(jcuda.Pointer), cuMemGetAddressRange(jcuda.driver.CUdeviceptr, long[], jcuda.driver.CUdeviceptr), cuMemHostAlloc(jcuda.Pointer, long, int), cuMemHostGetDevicePointer(jcuda.driver.CUdeviceptr, jcuda.Pointer, int), cuMemsetD2D8(jcuda.driver.CUdeviceptr, long, byte, long, long), cuMemsetD2D16(jcuda.driver.CUdeviceptr, long, short, long, long), cuMemsetD2D32(jcuda.driver.CUdeviceptr, long, int, long, long), cuMemsetD8(jcuda.driver.CUdeviceptr, byte, long), cuMemsetD16(jcuda.driver.CUdeviceptr, short, long), cuMemsetD32(jcuda.driver.CUdeviceptr, int, long)

cuMemHostAlloc
```
public static int cuMemHostAlloc(Pointer pp,
                                 long bytes,
                                 int Flags)
```
Allocates page-locked host memory.
```
 CUresult cuMemHostAlloc (
      void** pp,
      size_t bytesize,
      unsigned int  Flags )
 
```
Allocates page-locked host memory. Allocates 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 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(). This feature is available only on GPUs with compute capability greater than or equal to 1.1.
- 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.
- 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 *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 Unified Addressing for additional details.

Note:
Note that this function may also return error codes from previous, asynchronous launches.
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, CUDA_ERROR_HOST_MEMORY_ALREADY_REGISTERED, CUDA_ERROR_NOT_PERMITTED, CUDA_ERROR_NOT_SUPPORTED

See Also:

cuArray3DCreate(jcuda.driver.CUarray, jcuda.driver.CUDA_ARRAY3D_DESCRIPTOR), cuArray3DGetDescriptor(jcuda.driver.CUDA_ARRAY3D_DESCRIPTOR, jcuda.driver.CUarray), cuArrayCreate(jcuda.driver.CUarray, jcuda.driver.CUDA_ARRAY_DESCRIPTOR), cuArrayDestroy(jcuda.driver.CUarray), cuArrayGetDescriptor(jcuda.driver.CUDA_ARRAY_DESCRIPTOR, jcuda.driver.CUarray), cuMemAlloc(jcuda.driver.CUdeviceptr, long), cuMemAllocHost(jcuda.Pointer, long), cuMemAllocPitch(jcuda.driver.CUdeviceptr, long[], long, long, int), cuMemcpy2D(jcuda.driver.CUDA_MEMCPY2D), cuMemcpy2DAsync(jcuda.driver.CUDA_MEMCPY2D, jcuda.driver.CUstream), cuMemcpy2DUnaligned(jcuda.driver.CUDA_MEMCPY2D), cuMemcpy3D(jcuda.driver.CUDA_MEMCPY3D), cuMemcpy3DAsync(jcuda.driver.CUDA_MEMCPY3D, jcuda.driver.CUstream), cuMemcpyAtoA(jcuda.driver.CUarray, long, jcuda.driver.CUarray, long, long), cuMemcpyAtoD(jcuda.driver.CUdeviceptr, jcuda.driver.CUarray, long, long), cuMemcpyAtoH(jcuda.Pointer, jcuda.driver.CUarray, long, long), cuMemcpyAtoHAsync(jcuda.Pointer, jcuda.driver.CUarray, long, long, jcuda.driver.CUstream), cuMemcpyDtoA(jcuda.driver.CUarray, long, jcuda.driver.CUdeviceptr, long), cuMemcpyDtoD(jcuda.driver.CUdeviceptr, jcuda.driver.CUdeviceptr, long), cuMemcpyDtoDAsync(jcuda.driver.CUdeviceptr, jcuda.driver.CUdeviceptr, long, jcuda.driver.CUstream), cuMemcpyDtoH(jcuda.Pointer, jcuda.driver.CUdeviceptr, long), cuMemcpyDtoHAsync(jcuda.Pointer, jcuda.driver.CUdeviceptr, long, jcuda.driver.CUstream), cuMemcpyHtoA(jcuda.driver.CUarray, long, jcuda.Pointer, long), cuMemcpyHtoAAsync(jcuda.driver.CUarray, long, jcuda.Pointer, long, jcuda.driver.CUstream), cuMemcpyHtoD(jcuda.driver.CUdeviceptr, jcuda.Pointer, long), cuMemcpyHtoDAsync(jcuda.driver.CUdeviceptr, jcuda.Pointer, long, jcuda.driver.CUstream), cuMemFree(jcuda.driver.CUdeviceptr), cuMemFreeHost(jcuda.Pointer), cuMemGetAddressRange(jcuda.driver.CUdeviceptr, long[], jcuda.driver.CUdeviceptr), cuMemGetInfo(long[], long[]), cuMemHostGetDevicePointer(jcuda.driver.CUdeviceptr, jcuda.Pointer, int), cuMemsetD2D8(jcuda.driver.CUdeviceptr, long, byte, long, long), cuMemsetD2D16(jcuda.driver.CUdeviceptr, long, short, long, long), cuMemsetD2D32(jcuda.driver.CUdeviceptr, long, int, long, long), cuMemsetD8(jcuda.driver.CUdeviceptr, byte, long), cuMemsetD16(jcuda.driver.CUdeviceptr, short, long), cuMemsetD32(jcuda.driver.CUdeviceptr, int, long)

cuMemHostGetDevicePointer
```
public static int cuMemHostGetDevicePointer(CUdeviceptr ret,
                                            Pointer p,
                                            int Flags)
```
Passes back device pointer of mapped pinned memory.
```
 CUresult cuMemHostGetDevicePointer (
      CUdeviceptr* pdptr,
      void* p,
      unsigned int  Flags )
 
```
Passes back device pointer of mapped pinned memory. Passes back the device pointer pdptr corresponding to the mapped, pinned host buffer 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.

Flags provides for future releases. For now, it must be set to 0.

Note:
Note that this function may also return error codes from previous, asynchronous launches.
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

See Also:

cuArray3DCreate(jcuda.driver.CUarray, jcuda.driver.CUDA_ARRAY3D_DESCRIPTOR), cuArray3DGetDescriptor(jcuda.driver.CUDA_ARRAY3D_DESCRIPTOR, jcuda.driver.CUarray), cuArrayCreate(jcuda.driver.CUarray, jcuda.driver.CUDA_ARRAY_DESCRIPTOR), cuArrayDestroy(jcuda.driver.CUarray), cuArrayGetDescriptor(jcuda.driver.CUDA_ARRAY_DESCRIPTOR, jcuda.driver.CUarray), cuMemAlloc(jcuda.driver.CUdeviceptr, long), cuMemAllocHost(jcuda.Pointer, long), cuMemAllocPitch(jcuda.driver.CUdeviceptr, long[], long, long, int), cuMemcpy2D(jcuda.driver.CUDA_MEMCPY2D), cuMemcpy2DAsync(jcuda.driver.CUDA_MEMCPY2D, jcuda.driver.CUstream), cuMemcpy2DUnaligned(jcuda.driver.CUDA_MEMCPY2D), cuMemcpy3D(jcuda.driver.CUDA_MEMCPY3D), cuMemcpy3DAsync(jcuda.driver.CUDA_MEMCPY3D, jcuda.driver.CUstream), cuMemcpyAtoA(jcuda.driver.CUarray, long, jcuda.driver.CUarray, long, long), cuMemcpyAtoD(jcuda.driver.CUdeviceptr, jcuda.driver.CUarray, long, long), cuMemcpyAtoH(jcuda.Pointer, jcuda.driver.CUarray, long, long), cuMemcpyAtoHAsync(jcuda.Pointer, jcuda.driver.CUarray, long, long, jcuda.driver.CUstream), cuMemcpyDtoA(jcuda.driver.CUarray, long, jcuda.driver.CUdeviceptr, long), cuMemcpyDtoD(jcuda.driver.CUdeviceptr, jcuda.driver.CUdeviceptr, long), cuMemcpyDtoDAsync(jcuda.driver.CUdeviceptr, jcuda.driver.CUdeviceptr, long, jcuda.driver.CUstream), cuMemcpyDtoH(jcuda.Pointer, jcuda.driver.CUdeviceptr, long), cuMemcpyDtoHAsync(jcuda.Pointer, jcuda.driver.CUdeviceptr, long, jcuda.driver.CUstream), cuMemcpyHtoA(jcuda.driver.CUarray, long, jcuda.Pointer, long), cuMemcpyHtoAAsync(jcuda.driver.CUarray, long, jcuda.Pointer, long, jcuda.driver.CUstream), cuMemcpyHtoD(jcuda.driver.CUdeviceptr, jcuda.Pointer, long), cuMemcpyHtoDAsync(jcuda.driver.CUdeviceptr, jcuda.Pointer, long, jcuda.driver.CUstream), cuMemFree(jcuda.driver.CUdeviceptr), cuMemFreeHost(jcuda.Pointer), cuMemGetAddressRange(jcuda.driver.CUdeviceptr, long[], jcuda.driver.CUdeviceptr), cuMemGetInfo(long[], long[]), cuMemHostAlloc(jcuda.Pointer, long, int), cuMemsetD2D8(jcuda.driver.CUdeviceptr, long, byte, long, long), cuMemsetD2D16(jcuda.driver.CUdeviceptr, long, short, long, long), cuMemsetD2D32(jcuda.driver.CUdeviceptr, long, int, long, long), cuMemsetD8(jcuda.driver.CUdeviceptr, byte, long), cuMemsetD16(jcuda.driver.CUdeviceptr, short, long), cuMemsetD32(jcuda.driver.CUdeviceptr, int, long)

cuMemHostGetFlags
```
public static int cuMemHostGetFlags(int[] pFlags,
                                    Pointer p)
```
Passes back flags that were used for a pinned allocation.
```
 CUresult cuMemHostGetFlags (
      unsigned int* pFlags,
      void* p )
 
```
Passes back flags that were used for a pinned allocation. Passes back the flags pFlags that were specified when allocating the pinned host buffer p allocated by cuMemHostAlloc.

cuMemHostGetFlags() will fail if the pointer does not reside in an allocation performed by cuMemAllocHost() or cuMemHostAlloc().

Note:
Note that this function may also return error codes from previous, asynchronous launches.
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

See Also:

cuMemAllocHost(jcuda.Pointer, long), cuMemHostAlloc(jcuda.Pointer, long, int)

cuDeviceGetByPCIBusId
```
public static int cuDeviceGetByPCIBusId(CUdevice dev,
                                        String pciBusId)
```
Returns a handle to a compute device.
```
 CUresult cuDeviceGetByPCIBusId (
      CUdevice* dev,
      char* pciBusId )
 
```
Returns a handle to a compute device. Returns in *device a device handle given a PCI bus ID string.

Note:
Note that this function may also return error codes from previous, asynchronous launches.
Parameters:

dev - Returned device handle

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

Returns:

CUDA_SUCCESS, CUDA_ERROR_DEINITIALIZED, CUDA_ERROR_NOT_INITIALIZED, CUDA_ERROR_INVALID_VALUE, CUDA_ERROR_INVALID_DEVICE

See Also:

cuDeviceGet(jcuda.driver.CUdevice, int), cuDeviceGetAttribute(int[], int, jcuda.driver.CUdevice), cuDeviceGetPCIBusId(java.lang.String[], int, jcuda.driver.CUdevice)

cuMemAllocManaged
```
public static int cuMemAllocManaged(CUdeviceptr dptr,
                                    long bytesize,
                                    int flags)
```
```
 CUresult cuMemAllocManaged (
      CUdeviceptr* dptr,
      size_t bytesize,
      unsigned int  flags )
 
```
Allocates memory that will be automatically managed by the Unified Memory system.

Description

Allocates bytesize bytes of managed memory on the device and returns in *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 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.

flags specifies the default stream association for this allocation. 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 is created with initial visibility restricted to host access only; an explicit call to cuStreamAttachMemAsync will be required to enable access on the device.

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.

On a multi-GPU system with peer-to-peer support, where multiple GPUs support managed memory, the physical storage 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 management system does not migrate memory between GPUs.

On a multi-GPU system where multiple GPUs support managed memory, but not all pairs of such GPUs have peer-to-peer support between them, the physical storage is created in 'zero-copy' or system 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.

Note:
Note that this function may also return error codes from previous, asynchronous launches.
Parameters:

dptr - The device pointer

bytesize - The size in bytes

flags - The flags

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

See Also:

cuArray3DCreate(jcuda.driver.CUarray, jcuda.driver.CUDA_ARRAY3D_DESCRIPTOR), cuArray3DGetDescriptor(jcuda.driver.CUDA_ARRAY3D_DESCRIPTOR, jcuda.driver.CUarray), cuArrayCreate(jcuda.driver.CUarray, jcuda.driver.CUDA_ARRAY_DESCRIPTOR), cuArrayDestroy(jcuda.driver.CUarray), cuArrayGetDescriptor(jcuda.driver.CUDA_ARRAY_DESCRIPTOR, jcuda.driver.CUarray), cuMemAllocHost(jcuda.Pointer, long), cuMemAllocPitch(jcuda.driver.CUdeviceptr, long[], long, long, int), cuMemcpy2D(jcuda.driver.CUDA_MEMCPY2D), cuMemcpy2DAsync(jcuda.driver.CUDA_MEMCPY2D, jcuda.driver.CUstream), cuMemcpy2DUnaligned(jcuda.driver.CUDA_MEMCPY2D), cuMemcpy3D(jcuda.driver.CUDA_MEMCPY3D), cuMemcpy3DAsync(jcuda.driver.CUDA_MEMCPY3D, jcuda.driver.CUstream), cuMemcpyAtoA(jcuda.driver.CUarray, long, jcuda.driver.CUarray, long, long), cuMemcpyAtoD(jcuda.driver.CUdeviceptr, jcuda.driver.CUarray, long, long), cuMemcpyAtoH(jcuda.Pointer, jcuda.driver.CUarray, long, long), cuMemcpyAtoHAsync(jcuda.Pointer, jcuda.driver.CUarray, long, long, jcuda.driver.CUstream), cuMemcpyDtoA(jcuda.driver.CUarray, long, jcuda.driver.CUdeviceptr, long), cuMemcpyDtoD(jcuda.driver.CUdeviceptr, jcuda.driver.CUdeviceptr, long), cuMemcpyDtoDAsync(jcuda.driver.CUdeviceptr, jcuda.driver.CUdeviceptr, long, jcuda.driver.CUstream), cuMemcpyDtoH(jcuda.Pointer, jcuda.driver.CUdeviceptr, long), cuMemcpyDtoHAsync(jcuda.Pointer, jcuda.driver.CUdeviceptr, long, jcuda.driver.CUstream), cuMemcpyHtoA(jcuda.driver.CUarray, long, jcuda.Pointer, long), cuMemcpyHtoAAsync(jcuda.driver.CUarray, long, jcuda.Pointer, long, jcuda.driver.CUstream), cuMemcpyHtoD(jcuda.driver.CUdeviceptr, jcuda.Pointer, long), cuMemcpyHtoDAsync(jcuda.driver.CUdeviceptr, jcuda.Pointer, long, jcuda.driver.CUstream), cuMemFree(jcuda.driver.CUdeviceptr), cuMemFreeHost(jcuda.Pointer), cuMemGetAddressRange(jcuda.driver.CUdeviceptr, long[], jcuda.driver.CUdeviceptr), cuMemGetInfo(long[], long[]), cuMemHostAlloc(jcuda.Pointer, long, int), cuMemHostGetDevicePointer(jcuda.driver.CUdeviceptr, jcuda.Pointer, int), cuMemsetD2D8(jcuda.driver.CUdeviceptr, long, byte, long, long), cuMemsetD2D16(jcuda.driver.CUdeviceptr, long, short, long, long), cuMemsetD2D32(jcuda.driver.CUdeviceptr, long, int, long, long), cuMemsetD8(jcuda.driver.CUdeviceptr, byte, long), cuMemsetD16(jcuda.driver.CUdeviceptr, short, long), cuMemsetD32(jcuda.driver.CUdeviceptr, int, long), cuDeviceGetAttribute(int[], int, jcuda.driver.CUdevice), cuStreamAttachMemAsync(jcuda.driver.CUstream, jcuda.driver.CUdeviceptr, long, int)

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

Note:
Note that this function may also return error codes from previous, asynchronous launches.
Parameters:

pciBusId - Returned identifier string for the device in the following format [domain]:[bus]:[device].[function] where domain, bus, device, and 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 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

See Also:

cuDeviceGet(jcuda.driver.CUdevice, int), cuDeviceGetAttribute(int[], int, jcuda.driver.CUdevice), cuDeviceGetByPCIBusId(jcuda.driver.CUdevice, java.lang.String)

cuIpcGetEventHandle
```
public static int cuIpcGetEventHandle(CUipcEventHandle pHandle,
                                      CUevent event)
```
Gets an interprocess handle for a previously allocated event.
```
 CUresult cuIpcGetEventHandle (
      CUipcEventHandle* pHandle,
      CUevent event )
 
```
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 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 operating systems.
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

See Also:

cuEventCreate(jcuda.driver.CUevent, int), cuEventDestroy(jcuda.driver.CUevent), cuEventSynchronize(jcuda.driver.CUevent), cuEventQuery(jcuda.driver.CUevent), cuStreamWaitEvent(jcuda.driver.CUstream, jcuda.driver.CUevent, int), cuIpcOpenEventHandle(jcuda.driver.CUevent, jcuda.driver.CUipcEventHandle), cuIpcGetMemHandle(jcuda.driver.CUipcMemHandle, jcuda.driver.CUdeviceptr), cuIpcOpenMemHandle(jcuda.driver.CUdeviceptr, jcuda.driver.CUipcMemHandle, int), cuIpcCloseMemHandle(jcuda.driver.CUdeviceptr)

cuIpcOpenEventHandle
```
public static int cuIpcOpenEventHandle(CUevent phEvent,
                                       CUipcEventHandle handle)
```
Opens an interprocess event handle for use in the current process.
```
 CUresult cuIpcOpenEventHandle (
      CUevent* phEvent,
      CUipcEventHandle handle )
 
```
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 operating systems.
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

See Also:

cuEventCreate(jcuda.driver.CUevent, int), cuEventDestroy(jcuda.driver.CUevent), cuEventSynchronize(jcuda.driver.CUevent), cuEventQuery(jcuda.driver.CUevent), cuStreamWaitEvent(jcuda.driver.CUstream, jcuda.driver.CUevent, int), cuIpcGetEventHandle(jcuda.driver.CUipcEventHandle, jcuda.driver.CUevent), cuIpcGetMemHandle(jcuda.driver.CUipcMemHandle, jcuda.driver.CUdeviceptr), cuIpcOpenMemHandle(jcuda.driver.CUdeviceptr, jcuda.driver.CUipcMemHandle, int), cuIpcCloseMemHandle(jcuda.driver.CUdeviceptr)

cuIpcGetMemHandle
```
public static int cuIpcGetMemHandle(CUipcMemHandle pHandle,
                                    CUdeviceptr dptr)
```
Gets an interprocess memory handle for an existing device memory allocation.
```
 CUresult cuIpcGetMemHandle (
      CUipcMemHandle* pHandle,
      CUdeviceptr 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 operating systems.
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,

See Also:

cuMemAlloc(jcuda.driver.CUdeviceptr, long), cuMemFree(jcuda.driver.CUdeviceptr), cuIpcGetEventHandle(jcuda.driver.CUipcEventHandle, jcuda.driver.CUevent), cuIpcOpenEventHandle(jcuda.driver.CUevent, jcuda.driver.CUipcEventHandle), cuIpcOpenMemHandle(jcuda.driver.CUdeviceptr, jcuda.driver.CUipcMemHandle, int), cuIpcCloseMemHandle(jcuda.driver.CUdeviceptr)

cuIpcOpenMemHandle
```
public static int cuIpcOpenMemHandle(CUdeviceptr pdptr,
                                     CUipcMemHandle handle,
                                     int Flags)
```
```
 CUresult cuIpcOpenMemHandle (
      CUdeviceptr* pdptr,
      CUipcMemHandle handle,
      unsigned 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.

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 operating systems.
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

See Also:

cuMemAlloc(jcuda.driver.CUdeviceptr, long), cuMemFree(jcuda.driver.CUdeviceptr), cuIpcGetEventHandle(jcuda.driver.CUipcEventHandle, jcuda.driver.CUevent), cuIpcOpenEventHandle(jcuda.driver.CUevent, jcuda.driver.CUipcEventHandle), cuIpcGetMemHandle(jcuda.driver.CUipcMemHandle, jcuda.driver.CUdeviceptr), cuIpcCloseMemHandle(jcuda.driver.CUdeviceptr), cuCtxEnablePeerAccess(jcuda.driver.CUcontext, int), cuDeviceCanAccessPeer(int[], jcuda.driver.CUdevice, jcuda.driver.CUdevice)

cuIpcCloseMemHandle
```
public static int cuIpcCloseMemHandle(CUdeviceptr dptr)
```
Close memory mapped with cuIpcOpenMemHandle.
```
 CUresult cuIpcCloseMemHandle (
      CUdeviceptr dptr )
 
```
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 operating systems.
Parameters:

dptr - Device pointer returned by cuIpcOpenMemHandle

Returns:

CUDA_SUCCESS, CUDA_ERROR_INVALID_CONTEXT, CUDA_ERROR_MAP_FAILED, CUDA_ERROR_INVALID_HANDLE,

See Also:

cuMemAlloc(jcuda.driver.CUdeviceptr, long), cuMemFree(jcuda.driver.CUdeviceptr), cuIpcGetEventHandle(jcuda.driver.CUipcEventHandle, jcuda.driver.CUevent), cuIpcOpenEventHandle(jcuda.driver.CUevent, jcuda.driver.CUipcEventHandle), cuIpcGetMemHandle(jcuda.driver.CUipcMemHandle, jcuda.driver.CUdeviceptr), cuIpcOpenMemHandle(jcuda.driver.CUdeviceptr, jcuda.driver.CUipcMemHandle, int)

cuMemHostRegister
```
public static int cuMemHostRegister(Pointer p,
                                    long bytesize,
                                    int Flags)
```
Registers an existing host memory range for use by CUDA.
```
 CUresult cuMemHostRegister (
      void* p,
      size_t bytesize,
      unsigned int  Flags )
 
```
Registers an existing host memory range for use by CUDA. Page-locks the memory range specified by p and bytesize and maps it for the device(s) as specified by 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 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(). This feature is available only on GPUs with compute capability greater than or equal to 1.1.
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.

The memory page-locked by this function must be unregistered with cuMemHostUnregister().

Note:
Note that this function may also return error codes from previous, asynchronous launches.
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

See Also:

cuMemHostUnregister(jcuda.Pointer), cuMemHostGetFlags(int[], jcuda.Pointer), cuMemHostGetDevicePointer(jcuda.driver.CUdeviceptr, jcuda.Pointer, int)

cuMemHostUnregister
```
public static int cuMemHostUnregister(Pointer p)
```
Unregisters a memory range that was registered with cuMemHostRegister.
```
 CUresult cuMemHostUnregister (
      void* p )
 
```
Unregisters a memory range that was registered with cuMemHostRegister. Unmaps the memory range whose base address is specified by p, and makes it pageable again.

The base address must be the same one specified to cuMemHostRegister().

Note:
Note that this function may also return error codes from previous, asynchronous launches.
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,

See Also:

cuMemHostRegister(jcuda.Pointer, long, int)

cuMemcpy
```
public static int cuMemcpy(CUdeviceptr dst,
                           CUdeviceptr src,
                           long ByteCount)
```
Copies memory.
```
 CUresult cuMemcpy (
      CUdeviceptr dst,
      CUdeviceptr src,
      size_t ByteCount )
 
```
Copies memory. Copies data between two pointers. dst and src are base pointers of the destination and source, respectively. 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. Note that this function is synchronous.

Note:
Note that this function may also return error codes from previous, asynchronous launches.
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

See Also:

cuArray3DCreate(jcuda.driver.CUarray, jcuda.driver.CUDA_ARRAY3D_DESCRIPTOR), cuArray3DGetDescriptor(jcuda.driver.CUDA_ARRAY3D_DESCRIPTOR, jcuda.driver.CUarray), cuArrayCreate(jcuda.driver.CUarray, jcuda.driver.CUDA_ARRAY_DESCRIPTOR), cuArrayDestroy(jcuda.driver.CUarray), cuArrayGetDescriptor(jcuda.driver.CUDA_ARRAY_DESCRIPTOR, jcuda.driver.CUarray), cuMemAlloc(jcuda.driver.CUdeviceptr, long), cuMemAllocHost(jcuda.Pointer, long), cuMemAllocPitch(jcuda.driver.CUdeviceptr, long[], long, long, int), cuMemcpy2D(jcuda.driver.CUDA_MEMCPY2D), cuMemcpy2DAsync(jcuda.driver.CUDA_MEMCPY2D, jcuda.driver.CUstream), cuMemcpy2DUnaligned(jcuda.driver.CUDA_MEMCPY2D), cuMemcpy3D(jcuda.driver.CUDA_MEMCPY3D), cuMemcpy3DAsync(jcuda.driver.CUDA_MEMCPY3D, jcuda.driver.CUstream), cuMemcpyAtoA(jcuda.driver.CUarray, long, jcuda.driver.CUarray, long, long), cuMemcpyAtoD(jcuda.driver.CUdeviceptr, jcuda.driver.CUarray, long, long), cuMemcpyAtoH(jcuda.Pointer, jcuda.driver.CUarray, long, long), cuMemcpyAtoHAsync(jcuda.Pointer, jcuda.driver.CUarray, long, long, jcuda.driver.CUstream), cuMemcpyDtoA(jcuda.driver.CUarray, long, jcuda.driver.CUdeviceptr, long), cuMemcpyDtoH(jcuda.Pointer, jcuda.driver.CUdeviceptr, long), cuMemcpyDtoHAsync(jcuda.Pointer, jcuda.driver.CUdeviceptr, long, jcuda.driver.CUstream), cuMemcpyHtoA(jcuda.driver.CUarray, long, jcuda.Pointer, long), cuMemcpyHtoAAsync(jcuda.driver.CUarray, long, jcuda.Pointer, long, jcuda.driver.CUstream), cuMemcpyHtoD(jcuda.driver.CUdeviceptr, jcuda.Pointer, long), cuMemcpyHtoDAsync(jcuda.driver.CUdeviceptr, jcuda.Pointer, long, jcuda.driver.CUstream), cuMemFree(jcuda.driver.CUdeviceptr), cuMemFreeHost(jcuda.Pointer), cuMemGetAddressRange(jcuda.driver.CUdeviceptr, long[], jcuda.driver.CUdeviceptr), cuMemGetInfo(long[], long[]), cuMemHostAlloc(jcuda.Pointer, long, int), cuMemHostGetDevicePointer(jcuda.driver.CUdeviceptr, jcuda.Pointer, int), cuMemsetD2D8(jcuda.driver.CUdeviceptr, long, byte, long, long), cuMemsetD2D16(jcuda.driver.CUdeviceptr, long, short, long, long), cuMemsetD2D32(jcuda.driver.CUdeviceptr, long, int, long, long), cuMemsetD8(jcuda.driver.CUdeviceptr, byte, long), cuMemsetD16(jcuda.driver.CUdeviceptr, short, long), cuMemsetD32(jcuda.driver.CUdeviceptr, int, long)

cuMemcpyPeer
```
public static int cuMemcpyPeer(CUdeviceptr dstDevice,
                               CUcontext dstContext,
                               CUdeviceptr srcDevice,
                               CUcontext srcContext,
                               long ByteCount)
```
Copies device memory between two contexts.
```
 CUresult cuMemcpyPeer (
      CUdeviceptr dstDevice,
      CUcontext dstContext,
      CUdeviceptr srcDevice,
      CUcontext srcContext,
      size_t ByteCount )
 
```
Copies device memory between two contexts. Copies from device memory in one context to device memory in another context. dstDevice is the base device pointer of the destination memory and dstContext is the destination context. srcDevice is the base device pointer of the source memory and srcContext is the source pointer. ByteCount 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 context, srcContext, and dstContext (use cuMemcpyPeerAsync to avoid this synchronization).

Note:
Note that this function may also return error codes from previous, asynchronous launches.
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

See Also:

cuMemcpyDtoD(jcuda.driver.CUdeviceptr, jcuda.driver.CUdeviceptr, long), cuMemcpy3DPeer(jcuda.driver.CUDA_MEMCPY3D_PEER), cuMemcpyDtoDAsync(jcuda.driver.CUdeviceptr, jcuda.driver.CUdeviceptr, long, jcuda.driver.CUstream), cuMemcpyPeerAsync(jcuda.driver.CUdeviceptr, jcuda.driver.CUcontext, jcuda.driver.CUdeviceptr, jcuda.driver.CUcontext, long, jcuda.driver.CUstream), cuMemcpy3DPeerAsync(jcuda.driver.CUDA_MEMCPY3D_PEER, jcuda.driver.CUstream)

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

Note:
Note that this function may also return error codes from previous, asynchronous launches.
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

See Also:

cuArray3DCreate(jcuda.driver.CUarray, jcuda.driver.CUDA_ARRAY3D_DESCRIPTOR), cuArray3DGetDescriptor(jcuda.driver.CUDA_ARRAY3D_DESCRIPTOR, jcuda.driver.CUarray), cuArrayCreate(jcuda.driver.CUarray, jcuda.driver.CUDA_ARRAY_DESCRIPTOR), cuArrayDestroy(jcuda.driver.CUarray), cuArrayGetDescriptor(jcuda.driver.CUDA_ARRAY_DESCRIPTOR, jcuda.driver.CUarray), cuMemAllocHost(jcuda.Pointer, long), cuMemAllocPitch(jcuda.driver.CUdeviceptr, long[], long, long, int), cuMemcpy2D(jcuda.driver.CUDA_MEMCPY2D), cuMemcpy2DAsync(jcuda.driver.CUDA_MEMCPY2D, jcuda.driver.CUstream), cuMemcpy2DUnaligned(jcuda.driver.CUDA_MEMCPY2D), cuMemcpy3D(jcuda.driver.CUDA_MEMCPY3D), cuMemcpy3DAsync(jcuda.driver.CUDA_MEMCPY3D, jcuda.driver.CUstream), cuMemcpyAtoA(jcuda.driver.CUarray, long, jcuda.driver.CUarray, long, long), cuMemcpyAtoD(jcuda.driver.CUdeviceptr, jcuda.driver.CUarray, long, long), cuMemcpyAtoH(jcuda.Pointer, jcuda.driver.CUarray, long, long), cuMemcpyAtoHAsync(jcuda.Pointer, jcuda.driver.CUarray, long, long, jcuda.driver.CUstream), cuMemcpyDtoA(jcuda.driver.CUarray, long, jcuda.driver.CUdeviceptr, long), cuMemcpyDtoD(jcuda.driver.CUdeviceptr, jcuda.driver.CUdeviceptr, long), cuMemcpyDtoDAsync(jcuda.driver.CUdeviceptr, jcuda.driver.CUdeviceptr, long, jcuda.driver.CUstream), cuMemcpyDtoH(jcuda.Pointer, jcuda.driver.CUdeviceptr, long), cuMemcpyDtoHAsync(jcuda.Pointer, jcuda.driver.CUdeviceptr, long, jcuda.driver.CUstream), cuMemcpyHtoA(jcuda.driver.CUarray, long, jcuda.Pointer, long), cuMemcpyHtoAAsync(jcuda.driver.CUarray, long, jcuda.Pointer, long, jcuda.driver.CUstream), cuMemcpyHtoD(jcuda.driver.CUdeviceptr, jcuda.Pointer, long), cuMemcpyHtoDAsync(jcuda.driver.CUdeviceptr, jcuda.Pointer, long, jcuda.driver.CUstream), cuMemFree(jcuda.driver.CUdeviceptr), cuMemFreeHost(jcuda.Pointer), cuMemGetAddressRange(jcuda.driver.CUdeviceptr, long[], jcuda.driver.CUdeviceptr), cuMemGetInfo(long[], long[]), cuMemHostAlloc(jcuda.Pointer, long, int), cuMemHostGetDevicePointer(jcuda.driver.CUdeviceptr, jcuda.Pointer, int), cuMemsetD2D8(jcuda.driver.CUdeviceptr, long, byte, long, long), cuMemsetD2D16(jcuda.driver.CUdeviceptr, long, short, long, long), cuMemsetD2D32(jcuda.driver.CUdeviceptr, long, int, long, long), cuMemsetD8(jcuda.driver.CUdeviceptr, byte, long), cuMemsetD16(jcuda.driver.CUdeviceptr, short, long), cuMemsetD32(jcuda.driver.CUdeviceptr, int, long)

cuMemAllocPitch
```
public static int cuMemAllocPitch(CUdeviceptr dptr,
                                  long[] pPitch,
                                  long WidthInBytes,
                                  long Height,
                                  int ElementSizeBytes)
```
Allocates pitched device memory.
```
 CUresult cuMemAllocPitch (
      CUdeviceptr* dptr,
      size_t* pPitch,
      size_t WidthInBytes,
      size_t Height,
      unsigned int  ElementSizeBytes )
 
```
Allocates pitched device memory. Allocates at least WidthInBytes * Height bytes of linear memory on the device and returns in *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. ElementSizeBytes specifies the size of the largest reads and writes that will be performed on the memory range. ElementSizeBytes may be 4, 8 or 16 (since coalesced memory transactions are not possible on other data sizes). If 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 *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 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().

Note:
Note that this function may also return error codes from previous, asynchronous launches.
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

See Also:

cuArray3DCreate(jcuda.driver.CUarray, jcuda.driver.CUDA_ARRAY3D_DESCRIPTOR), cuArray3DGetDescriptor(jcuda.driver.CUDA_ARRAY3D_DESCRIPTOR, jcuda.driver.CUarray), cuArrayCreate(jcuda.driver.CUarray, jcuda.driver.CUDA_ARRAY_DESCRIPTOR), cuArrayDestroy(jcuda.driver.CUarray), cuArrayGetDescriptor(jcuda.driver.CUDA_ARRAY_DESCRIPTOR, jcuda.driver.CUarray), cuMemAlloc(jcuda.driver.CUdeviceptr, long), cuMemAllocHost(jcuda.Pointer, long), cuMemcpy2D(jcuda.driver.CUDA_MEMCPY2D), cuMemcpy2DAsync(jcuda.driver.CUDA_MEMCPY2D, jcuda.driver.CUstream), cuMemcpy2DUnaligned(jcuda.driver.CUDA_MEMCPY2D), cuMemcpy3D(jcuda.driver.CUDA_MEMCPY3D), cuMemcpy3DAsync(jcuda.driver.CUDA_MEMCPY3D, jcuda.driver.CUstream), cuMemcpyAtoA(jcuda.driver.CUarray, long, jcuda.driver.CUarray, long, long), cuMemcpyAtoD(jcuda.driver.CUdeviceptr, jcuda.driver.CUarray, long, long), cuMemcpyAtoH(jcuda.Pointer, jcuda.driver.CUarray, long, long), cuMemcpyAtoHAsync(jcuda.Pointer, jcuda.driver.CUarray, long, long, jcuda.driver.CUstream), cuMemcpyDtoA(jcuda.driver.CUarray, long, jcuda.driver.CUdeviceptr, long), cuMemcpyDtoD(jcuda.driver.CUdeviceptr, jcuda.driver.CUdeviceptr, long), cuMemcpyDtoDAsync(jcuda.driver.CUdeviceptr, jcuda.driver.CUdeviceptr, long, jcuda.driver.CUstream), cuMemcpyDtoH(jcuda.Pointer, jcuda.driver.CUdeviceptr, long), cuMemcpyDtoHAsync(jcuda.Pointer, jcuda.driver.CUdeviceptr, long, jcuda.driver.CUstream), cuMemcpyHtoA(jcuda.driver.CUarray, long, jcuda.Pointer, long), cuMemcpyHtoAAsync(jcuda.driver.CUarray, long, jcuda.Pointer, long, jcuda.driver.CUstream), cuMemcpyHtoD(jcuda.driver.CUdeviceptr, jcuda.Pointer, long), cuMemcpyHtoDAsync(jcuda.driver.CUdeviceptr, jcuda.Pointer, long, jcuda.driver.CUstream), cuMemFree(jcuda.driver.CUdeviceptr), cuMemFreeHost(jcuda.Pointer), cuMemGetAddressRange(jcuda.driver.CUdeviceptr, long[], jcuda.driver.CUdeviceptr), cuMemGetInfo(long[], long[]), cuMemHostAlloc(jcuda.Pointer, long, int), cuMemHostGetDevicePointer(jcuda.driver.CUdeviceptr, jcuda.Pointer, int), cuMemsetD2D8(jcuda.driver.CUdeviceptr, long, byte, long, long), cuMemsetD2D16(jcuda.driver.CUdeviceptr, long, short, long, long), cuMemsetD2D32(jcuda.driver.CUdeviceptr, long, int, long, long), cuMemsetD8(jcuda.driver.CUdeviceptr, byte, long), cuMemsetD16(jcuda.driver.CUdeviceptr, short, long), cuMemsetD32(jcuda.driver.CUdeviceptr, int, long)

cuMemFree
```
public static int cuMemFree(CUdeviceptr dptr)
```
Frees device memory.
```
 CUresult cuMemFree (
      CUdeviceptr dptr )
 
```
Frees device memory. Frees the memory space pointed to by dptr, which must have been returned by a previous call to cuMemAlloc() or cuMemAllocPitch().

Note:
Note that this function may also return error codes from previous, asynchronous launches.
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

See Also:

cuArray3DCreate(jcuda.driver.CUarray, jcuda.driver.CUDA_ARRAY3D_DESCRIPTOR), cuArray3DGetDescriptor(jcuda.driver.CUDA_ARRAY3D_DESCRIPTOR, jcuda.driver.CUarray), cuArrayCreate(jcuda.driver.CUarray, jcuda.driver.CUDA_ARRAY_DESCRIPTOR), cuArrayDestroy(jcuda.driver.CUarray), cuArrayGetDescriptor(jcuda.driver.CUDA_ARRAY_DESCRIPTOR, jcuda.driver.CUarray), cuMemAlloc(jcuda.driver.CUdeviceptr, long), cuMemAllocHost(jcuda.Pointer, long), cuMemAllocPitch(jcuda.driver.CUdeviceptr, long[], long, long, int), cuMemcpy2D(jcuda.driver.CUDA_MEMCPY2D), cuMemcpy2DAsync(jcuda.driver.CUDA_MEMCPY2D, jcuda.driver.CUstream), cuMemcpy2DUnaligned(jcuda.driver.CUDA_MEMCPY2D), cuMemcpy3D(jcuda.driver.CUDA_MEMCPY3D), cuMemcpy3DAsync(jcuda.driver.CUDA_MEMCPY3D, jcuda.driver.CUstream), cuMemcpyAtoA(jcuda.driver.CUarray, long, jcuda.driver.CUarray, long, long), cuMemcpyAtoD(jcuda.driver.CUdeviceptr, jcuda.driver.CUarray, long, long), cuMemcpyAtoH(jcuda.Pointer, jcuda.driver.CUarray, long, long), cuMemcpyAtoHAsync(jcuda.Pointer, jcuda.driver.CUarray, long, long, jcuda.driver.CUstream), cuMemcpyDtoA(jcuda.driver.CUarray, long, jcuda.driver.CUdeviceptr, long), cuMemcpyDtoD(jcuda.driver.CUdeviceptr, jcuda.driver.CUdeviceptr, long), cuMemcpyDtoDAsync(jcuda.driver.CUdeviceptr, jcuda.driver.CUdeviceptr, long, jcuda.driver.CUstream), cuMemcpyDtoH(jcuda.Pointer, jcuda.driver.CUdeviceptr, long), cuMemcpyDtoHAsync(jcuda.Pointer, jcuda.driver.CUdeviceptr, long, jcuda.driver.CUstream), cuMemcpyHtoA(jcuda.driver.CUarray, long, jcuda.Pointer, long), cuMemcpyHtoAAsync(jcuda.driver.CUarray, long, jcuda.Pointer, long, jcuda.driver.CUstream), cuMemcpyHtoD(jcuda.driver.CUdeviceptr, jcuda.Pointer, long), cuMemcpyHtoDAsync(jcuda.driver.CUdeviceptr, jcuda.Pointer, long, jcuda.driver.CUstream), cuMemFreeHost(jcuda.Pointer), cuMemGetAddressRange(jcuda.driver.CUdeviceptr, long[], jcuda.driver.CUdeviceptr), cuMemGetInfo(long[], long[]), cuMemHostAlloc(jcuda.Pointer, long, int), cuMemHostGetDevicePointer(jcuda.driver.CUdeviceptr, jcuda.Pointer, int), cuMemsetD2D8(jcuda.driver.CUdeviceptr, long, byte, long, long), cuMemsetD2D16(jcuda.driver.CUdeviceptr, long, short, long, long), cuMemsetD2D32(jcuda.driver.CUdeviceptr, long, int, long, long), cuMemsetD8(jcuda.driver.CUdeviceptr, byte, long), cuMemsetD16(jcuda.driver.CUdeviceptr, short, long), cuMemsetD32(jcuda.driver.CUdeviceptr, int, long)

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

Note:
Note that this function may also return error codes from previous, asynchronous launches.
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_INVALID_VALUE

See Also:

cuArray3DCreate(jcuda.driver.CUarray, jcuda.driver.CUDA_ARRAY3D_DESCRIPTOR), cuArray3DGetDescriptor(jcuda.driver.CUDA_ARRAY3D_DESCRIPTOR, jcuda.driver.CUarray), cuArrayCreate(jcuda.driver.CUarray, jcuda.driver.CUDA_ARRAY_DESCRIPTOR), cuArrayDestroy(jcuda.driver.CUarray), cuArrayGetDescriptor(jcuda.driver.CUDA_ARRAY_DESCRIPTOR, jcuda.driver.CUarray), cuMemAlloc(jcuda.driver.CUdeviceptr, long), cuMemAllocHost(jcuda.Pointer, long), cuMemAllocPitch(jcuda.driver.CUdeviceptr, long[], long, long, int), cuMemcpy2D(jcuda.driver.CUDA_MEMCPY2D), cuMemcpy2DAsync(jcuda.driver.CUDA_MEMCPY2D, jcuda.driver.CUstream), cuMemcpy2DUnaligned(jcuda.driver.CUDA_MEMCPY2D), cuMemcpy3D(jcuda.driver.CUDA_MEMCPY3D), cuMemcpy3DAsync(jcuda.driver.CUDA_MEMCPY3D, jcuda.driver.CUstream), cuMemcpyAtoA(jcuda.driver.CUarray, long, jcuda.driver.CUarray, long, long), cuMemcpyAtoD(jcuda.driver.CUdeviceptr, jcuda.driver.CUarray, long, long), cuMemcpyAtoH(jcuda.Pointer, jcuda.driver.CUarray, long, long), cuMemcpyAtoHAsync(jcuda.Pointer, jcuda.driver.CUarray, long, long, jcuda.driver.CUstream), cuMemcpyDtoA(jcuda.driver.CUarray, long, jcuda.driver.CUdeviceptr, long), cuMemcpyDtoD(jcuda.driver.CUdeviceptr, jcuda.driver.CUdeviceptr, long), cuMemcpyDtoDAsync(jcuda.driver.CUdeviceptr, jcuda.driver.CUdeviceptr, long, jcuda.driver.CUstream), cuMemcpyDtoH(jcuda.Pointer, jcuda.driver.CUdeviceptr, long), cuMemcpyDtoHAsync(jcuda.Pointer, jcuda.driver.CUdeviceptr, long, jcuda.driver.CUstream), cuMemcpyHtoA(jcuda.driver.CUarray, long, jcuda.Pointer, long), cuMemcpyHtoAAsync(jcuda.driver.CUarray, long, jcuda.Pointer, long, jcuda.driver.CUstream), cuMemcpyHtoD(jcuda.driver.CUdeviceptr, jcuda.Pointer, long), cuMemcpyHtoDAsync(jcuda.driver.CUdeviceptr, jcuda.Pointer, long, jcuda.driver.CUstream), cuMemFree(jcuda.driver.CUdeviceptr), cuMemFreeHost(jcuda.Pointer), cuMemGetInfo(long[], long[]), cuMemHostAlloc(jcuda.Pointer, long, int), cuMemHostGetDevicePointer(jcuda.driver.CUdeviceptr, jcuda.Pointer, int), cuMemsetD2D8(jcuda.driver.CUdeviceptr, long, byte, long, long), cuMemsetD2D16(jcuda.driver.CUdeviceptr, long, short, long, long), cuMemsetD2D32(jcuda.driver.CUdeviceptr, long, int, long, long), cuMemsetD8(jcuda.driver.CUdeviceptr, byte, long), cuMemsetD16(jcuda.driver.CUdeviceptr, short, long), cuMemsetD32(jcuda.driver.CUdeviceptr, int, long)

cuMemAllocHost
```
public static int cuMemAllocHost(Pointer pointer,
                                 long bytesize)
```
Allocates page-locked host memory.
```
 CUresult cuMemAllocHost (
      void** pp,
      size_t bytesize )
 
```
Allocates page-locked host memory. Allocates 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 *pp. See Unified Addressing for additional details.

Note:
Note that this function may also return error codes from previous, asynchronous launches.
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

See Also:

cuArray3DCreate(jcuda.driver.CUarray, jcuda.driver.CUDA_ARRAY3D_DESCRIPTOR), cuArray3DGetDescriptor(jcuda.driver.CUDA_ARRAY3D_DESCRIPTOR, jcuda.driver.CUarray), cuArrayCreate(jcuda.driver.CUarray, jcuda.driver.CUDA_ARRAY_DESCRIPTOR), cuArrayDestroy(jcuda.driver.CUarray), cuArrayGetDescriptor(jcuda.driver.CUDA_ARRAY_DESCRIPTOR, jcuda.driver.CUarray), cuMemAlloc(jcuda.driver.CUdeviceptr, long), cuMemAllocPitch(jcuda.driver.CUdeviceptr, long[], long, long, int), cuMemcpy2D(jcuda.driver.CUDA_MEMCPY2D), cuMemcpy2DAsync(jcuda.driver.CUDA_MEMCPY2D, jcuda.driver.CUstream), cuMemcpy2DUnaligned(jcuda.driver.CUDA_MEMCPY2D), cuMemcpy3D(jcuda.driver.CUDA_MEMCPY3D), cuMemcpy3DAsync(jcuda.driver.CUDA_MEMCPY3D, jcuda.driver.CUstream), cuMemcpyAtoA(jcuda.driver.CUarray, long, jcuda.driver.CUarray, long, long), cuMemcpyAtoD(jcuda.driver.CUdeviceptr, jcuda.driver.CUarray, long, long), cuMemcpyAtoH(jcuda.Pointer, jcuda.driver.CUarray, long, long), cuMemcpyAtoHAsync(jcuda.Pointer, jcuda.driver.CUarray, long, long, jcuda.driver.CUstream), cuMemcpyDtoA(jcuda.driver.CUarray, long, jcuda.driver.CUdeviceptr, long), cuMemcpyDtoD(jcuda.driver.CUdeviceptr, jcuda.driver.CUdeviceptr, long), cuMemcpyDtoDAsync(jcuda.driver.CUdeviceptr, jcuda.driver.CUdeviceptr, long, jcuda.driver.CUstream), cuMemcpyDtoH(jcuda.Pointer, jcuda.driver.CUdeviceptr, long), cuMemcpyDtoHAsync(jcuda.Pointer, jcuda.driver.CUdeviceptr, long, jcuda.driver.CUstream), cuMemcpyHtoA(jcuda.driver.CUarray, long, jcuda.Pointer, long), cuMemcpyHtoAAsync(jcuda.driver.CUarray, long, jcuda.Pointer, long, jcuda.driver.CUstream), cuMemcpyHtoD(jcuda.driver.CUdeviceptr, jcuda.Pointer, long), cuMemcpyHtoDAsync(jcuda.driver.CUdeviceptr, jcuda.Pointer, long, jcuda.driver.CUstream), cuMemFree(jcuda.driver.CUdeviceptr), cuMemFreeHost(jcuda.Pointer), cuMemGetAddressRange(jcuda.driver.CUdeviceptr, long[], jcuda.driver.CUdeviceptr), cuMemGetInfo(long[], long[]), cuMemHostAlloc(jcuda.Pointer, long, int), cuMemHostGetDevicePointer(jcuda.driver.CUdeviceptr, jcuda.Pointer, int), cuMemsetD2D8(jcuda.driver.CUdeviceptr, long, byte, long, long), cuMemsetD2D16(jcuda.driver.CUdeviceptr, long, short, long, long), cuMemsetD2D32(jcuda.driver.CUdeviceptr, long, int, long, long), cuMemsetD8(jcuda.driver.CUdeviceptr, byte, long), cuMemsetD16(jcuda.driver.CUdeviceptr, short, long), cuMemsetD32(jcuda.driver.CUdeviceptr, int, long)

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

Note:
Note that this function may also return error codes from previous, asynchronous launches.
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

See Also:

cuArray3DCreate(jcuda.driver.CUarray, jcuda.driver.CUDA_ARRAY3D_DESCRIPTOR), cuArray3DGetDescriptor(jcuda.driver.CUDA_ARRAY3D_DESCRIPTOR, jcuda.driver.CUarray), cuArrayCreate(jcuda.driver.CUarray, jcuda.driver.CUDA_ARRAY_DESCRIPTOR), cuArrayDestroy(jcuda.driver.CUarray), cuArrayGetDescriptor(jcuda.driver.CUDA_ARRAY_DESCRIPTOR, jcuda.driver.CUarray), cuMemAlloc(jcuda.driver.CUdeviceptr, long), cuMemAllocHost(jcuda.Pointer, long), cuMemAllocPitch(jcuda.driver.CUdeviceptr, long[], long, long, int), cuMemcpy2D(jcuda.driver.CUDA_MEMCPY2D), cuMemcpy2DAsync(jcuda.driver.CUDA_MEMCPY2D, jcuda.driver.CUstream), cuMemcpy2DUnaligned(jcuda.driver.CUDA_MEMCPY2D), cuMemcpy3D(jcuda.driver.CUDA_MEMCPY3D), cuMemcpy3DAsync(jcuda.driver.CUDA_MEMCPY3D, jcuda.driver.CUstream), cuMemcpyAtoA(jcuda.driver.CUarray, long, jcuda.driver.CUarray, long, long), cuMemcpyAtoD(jcuda.driver.CUdeviceptr, jcuda.driver.CUarray, long, long), cuMemcpyAtoH(jcuda.Pointer, jcuda.driver.CUarray, long, long), cuMemcpyAtoHAsync(jcuda.Pointer, jcuda.driver.CUarray, long, long, jcuda.driver.CUstream), cuMemcpyDtoA(jcuda.driver.CUarray, long, jcuda.driver.CUdeviceptr, long), cuMemcpyDtoD(jcuda.driver.CUdeviceptr, jcuda.driver.CUdeviceptr, long), cuMemcpyDtoDAsync(jcuda.driver.CUdeviceptr, jcuda.driver.CUdeviceptr, long, jcuda.driver.CUstream), cuMemcpyDtoH(jcuda.Pointer, jcuda.driver.CUdeviceptr, long), cuMemcpyDtoHAsync(jcuda.Pointer, jcuda.driver.CUdeviceptr, long, jcuda.driver.CUstream), cuMemcpyHtoA(jcuda.driver.CUarray, long, jcuda.Pointer, long), cuMemcpyHtoAAsync(jcuda.driver.CUarray, long, jcuda.Pointer, long, jcuda.driver.CUstream), cuMemcpyHtoD(jcuda.driver.CUdeviceptr, jcuda.Pointer, long), cuMemcpyHtoDAsync(jcuda.driver.CUdeviceptr, jcuda.Pointer, long, jcuda.driver.CUstream), cuMemFree(jcuda.driver.CUdeviceptr), cuMemGetAddressRange(jcuda.driver.CUdeviceptr, long[], jcuda.driver.CUdeviceptr), cuMemGetInfo(long[], long[]), cuMemHostAlloc(jcuda.Pointer, long, int), cuMemHostGetDevicePointer(jcuda.driver.CUdeviceptr, jcuda.Pointer, int), cuMemsetD2D8(jcuda.driver.CUdeviceptr, long, byte, long, long), cuMemsetD2D16(jcuda.driver.CUdeviceptr, long, short, long, long), cuMemsetD2D32(jcuda.driver.CUdeviceptr, long, int, long, long), cuMemsetD8(jcuda.driver.CUdeviceptr, byte, long), cuMemsetD16(jcuda.driver.CUdeviceptr, short, long), cuMemsetD32(jcuda.driver.CUdeviceptr, int, long)

cuMemcpyHtoD
```
public static int cuMemcpyHtoD(CUdeviceptr dstDevice,
                               Pointer srcHost,
                               long ByteCount)
```
Copies memory from Host to Device.
```
 CUresult cuMemcpyHtoD (
      CUdeviceptr dstDevice,
      const void* srcHost,
      size_t ByteCount )
 
```
Copies memory from Host to Device. Copies from host memory to device memory. dstDevice and srcHost are the base addresses of the destination and source, respectively. ByteCount specifies the number of bytes to copy. Note that this function is synchronous.

Note:
Note that this function may also return error codes from previous, asynchronous launches.
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

See Also:

cuArray3DCreate(jcuda.driver.CUarray, jcuda.driver.CUDA_ARRAY3D_DESCRIPTOR), cuArray3DGetDescriptor(jcuda.driver.CUDA_ARRAY3D_DESCRIPTOR, jcuda.driver.CUarray), cuArrayCreate(jcuda.driver.CUarray, jcuda.driver.CUDA_ARRAY_DESCRIPTOR), cuArrayDestroy(jcuda.driver.CUarray), cuArrayGetDescriptor(jcuda.driver.CUDA_ARRAY_DESCRIPTOR, jcuda.driver.CUarray), cuMemAlloc(jcuda.driver.CUdeviceptr, long), cuMemAllocHost(jcuda.Pointer, long), cuMemAllocPitch(jcuda.driver.CUdeviceptr, long[], long, long, int), cuMemcpy2D(jcuda.driver.CUDA_MEMCPY2D), cuMemcpy2DAsync(jcuda.driver.CUDA_MEMCPY2D, jcuda.driver.CUstream), cuMemcpy2DUnaligned(jcuda.driver.CUDA_MEMCPY2D), cuMemcpy3D(jcuda.driver.CUDA_MEMCPY3D), cuMemcpy3DAsync(jcuda.driver.CUDA_MEMCPY3D, jcuda.driver.CUstream), cuMemcpyAtoA(jcuda.driver.CUarray, long, jcuda.driver.CUarray, long, long), cuMemcpyAtoD(jcuda.driver.CUdeviceptr, jcuda.driver.CUarray, long, long), cuMemcpyAtoH(jcuda.Pointer, jcuda.driver.CUarray, long, long), cuMemcpyAtoHAsync(jcuda.Pointer, jcuda.driver.CUarray, long, long, jcuda.driver.CUstream), cuMemcpyDtoA(jcuda.driver.CUarray, long, jcuda.driver.CUdeviceptr, long), cuMemcpyDtoD(jcuda.driver.CUdeviceptr, jcuda.driver.CUdeviceptr, long), cuMemcpyDtoDAsync(jcuda.driver.CUdeviceptr, jcuda.driver.CUdeviceptr, long, jcuda.driver.CUstream), cuMemcpyDtoH(jcuda.Pointer, jcuda.driver.CUdeviceptr, long), cuMemcpyDtoHAsync(jcuda.Pointer, jcuda.driver.CUdeviceptr, long, jcuda.driver.CUstream), cuMemcpyHtoA(jcuda.driver.CUarray, long, jcuda.Pointer, long), cuMemcpyHtoAAsync(jcuda.driver.CUarray, long, jcuda.Pointer, long, jcuda.driver.CUstream), cuMemcpyHtoDAsync(jcuda.driver.CUdeviceptr, jcuda.Pointer, long, jcuda.driver.CUstream), cuMemFree(jcuda.driver.CUdeviceptr), cuMemFreeHost(jcuda.Pointer), cuMemGetAddressRange(jcuda.driver.CUdeviceptr, long[], jcuda.driver.CUdeviceptr), cuMemGetInfo(long[], long[]), cuMemHostAlloc(jcuda.Pointer, long, int), cuMemHostGetDevicePointer(jcuda.driver.CUdeviceptr, jcuda.Pointer, int), cuMemsetD2D8(jcuda.driver.CUdeviceptr, long, byte, long, long), cuMemsetD2D16(jcuda.driver.CUdeviceptr, long, short, long, long), cuMemsetD2D32(jcuda.driver.CUdeviceptr, long, int, long, long), cuMemsetD8(jcuda.driver.CUdeviceptr, byte, long), cuMemsetD16(jcuda.driver.CUdeviceptr, short, long), cuMemsetD32(jcuda.driver.CUdeviceptr, int, long)

cuMemcpyDtoH
```
public static int cuMemcpyDtoH(Pointer dstHost,
                               CUdeviceptr srcDevice,
                               long ByteCount)
```
Copies memory from Device to Host.
```
 CUresult cuMemcpyDtoH (
      void* dstHost,
      CUdeviceptr srcDevice,
      size_t ByteCount )
 
```
Copies memory from Device to Host. Copies from device to host memory. dstHost and srcDevice specify the base pointers of the destination and source, respectively. ByteCount specifies the number of bytes to copy. Note that this function is synchronous.

Note:
Note that this function may also return error codes from previous, asynchronous launches.
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

See Also:

cuArray3DCreate(jcuda.driver.CUarray, jcuda.driver.CUDA_ARRAY3D_DESCRIPTOR), cuArray3DGetDescriptor(jcuda.driver.CUDA_ARRAY3D_DESCRIPTOR, jcuda.driver.CUarray), cuArrayCreate(jcuda.driver.CUarray, jcuda.driver.CUDA_ARRAY_DESCRIPTOR), cuArrayDestroy(jcuda.driver.CUarray), cuArrayGetDescriptor(jcuda.driver.CUDA_ARRAY_DESCRIPTOR, jcuda.driver.CUarray), cuMemAlloc(jcuda.driver.CUdeviceptr, long), cuMemAllocHost(jcuda.Pointer, long), cuMemAllocPitch(jcuda.driver.CUdeviceptr, long[], long, long, int), cuMemcpy2D(jcuda.driver.CUDA_MEMCPY2D), cuMemcpy2DAsync(jcuda.driver.CUDA_MEMCPY2D, jcuda.driver.CUstream), cuMemcpy2DUnaligned(jcuda.driver.CUDA_MEMCPY2D), cuMemcpy3D(jcuda.driver.CUDA_MEMCPY3D), cuMemcpy3DAsync(jcuda.driver.CUDA_MEMCPY3D, jcuda.driver.CUstream), cuMemcpyAtoA(jcuda.driver.CUarray, long, jcuda.driver.CUarray, long, long), cuMemcpyAtoD(jcuda.driver.CUdeviceptr, jcuda.driver.CUarray, long, long), cuMemcpyAtoH(jcuda.Pointer, jcuda.driver.CUarray, long, long), cuMemcpyAtoHAsync(jcuda.Pointer, jcuda.driver.CUarray, long, long, jcuda.driver.CUstream), cuMemcpyDtoA(jcuda.driver.CUarray, long, jcuda.driver.CUdeviceptr, long), cuMemcpyDtoD(jcuda.driver.CUdeviceptr, jcuda.driver.CUdeviceptr, long), cuMemcpyDtoDAsync(jcuda.driver.CUdeviceptr, jcuda.driver.CUdeviceptr, long, jcuda.driver.CUstream), cuMemcpyDtoHAsync(jcuda.Pointer, jcuda.driver.CUdeviceptr, long, jcuda.driver.CUstream), cuMemcpyHtoA(jcuda.driver.CUarray, long, jcuda.Pointer, long), cuMemcpyHtoAAsync(jcuda.driver.CUarray, long, jcuda.Pointer, long, jcuda.driver.CUstream), cuMemcpyHtoD(jcuda.driver.CUdeviceptr, jcuda.Pointer, long), cuMemcpyHtoDAsync(jcuda.driver.CUdeviceptr, jcuda.Pointer, long, jcuda.driver.CUstream), cuMemFree(jcuda.driver.CUdeviceptr), cuMemFreeHost(jcuda.Pointer), cuMemGetAddressRange(jcuda.driver.CUdeviceptr, long[], jcuda.driver.CUdeviceptr), cuMemGetInfo(long[], long[]), cuMemHostAlloc(jcuda.Pointer, long, int), cuMemHostGetDevicePointer(jcuda.driver.CUdeviceptr, jcuda.Pointer, int), cuMemsetD2D8(jcuda.driver.CUdeviceptr, long, byte, long, long), cuMemsetD2D16(jcuda.driver.CUdeviceptr, long, short, long, long), cuMemsetD2D32(jcuda.driver.CUdeviceptr, long, int, long, long), cuMemsetD8(jcuda.driver.CUdeviceptr, byte, long), cuMemsetD16(jcuda.driver.CUdeviceptr, short, long), cuMemsetD32(jcuda.driver.CUdeviceptr, int, long)

cuMemcpyDtoD
```
public static int cuMemcpyDtoD(CUdeviceptr dstDevice,
                               CUdeviceptr srcDevice,
                               long ByteCount)
```
Copies memory from Device to Device.
```
 CUresult cuMemcpyDtoD (
      CUdeviceptr dstDevice,
      CUdeviceptr srcDevice,
      size_t ByteCount )
 
```
Copies memory from Device to Device. Copies from device memory to device memory. dstDevice and srcDevice are the base pointers of the destination and source, respectively. ByteCount specifies the number of bytes to copy. Note that this function is asynchronous.

Note:
Note that this function may also return error codes from previous, asynchronous launches.
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

See Also:

cuArray3DCreate(jcuda.driver.CUarray, jcuda.driver.CUDA_ARRAY3D_DESCRIPTOR), cuArray3DGetDescriptor(jcuda.driver.CUDA_ARRAY3D_DESCRIPTOR, jcuda.driver.CUarray), cuArrayCreate(jcuda.driver.CUarray, jcuda.driver.CUDA_ARRAY_DESCRIPTOR), cuArrayDestroy(jcuda.driver.CUarray), cuArrayGetDescriptor(jcuda.driver.CUDA_ARRAY_DESCRIPTOR, jcuda.driver.CUarray), cuMemAlloc(jcuda.driver.CUdeviceptr, long), cuMemAllocHost(jcuda.Pointer, long), cuMemAllocPitch(jcuda.driver.CUdeviceptr, long[], long, long, int), cuMemcpy2D(jcuda.driver.CUDA_MEMCPY2D), cuMemcpy2DAsync(jcuda.driver.CUDA_MEMCPY2D, jcuda.driver.CUstream), cuMemcpy2DUnaligned(jcuda.driver.CUDA_MEMCPY2D), cuMemcpy3D(jcuda.driver.CUDA_MEMCPY3D), cuMemcpy3DAsync(jcuda.driver.CUDA_MEMCPY3D, jcuda.driver.CUstream), cuMemcpyAtoA(jcuda.driver.CUarray, long, jcuda.driver.CUarray, long, long), cuMemcpyAtoD(jcuda.driver.CUdeviceptr, jcuda.driver.CUarray, long, long), cuMemcpyAtoH(jcuda.Pointer, jcuda.driver.CUarray, long, long), cuMemcpyAtoHAsync(jcuda.Pointer, jcuda.driver.CUarray, long, long, jcuda.driver.CUstream), cuMemcpyDtoA(jcuda.driver.CUarray, long, jcuda.driver.CUdeviceptr, long), cuMemcpyDtoH(jcuda.Pointer, jcuda.driver.CUdeviceptr, long), cuMemcpyDtoHAsync(jcuda.Pointer, jcuda.driver.CUdeviceptr, long, jcuda.driver.CUstream), cuMemcpyHtoA(jcuda.driver.CUarray, long, jcuda.Pointer, long), cuMemcpyHtoAAsync(jcuda.driver.CUarray, long, jcuda.Pointer, long, jcuda.driver.CUstream), cuMemcpyHtoD(jcuda.driver.CUdeviceptr, jcuda.Pointer, long), cuMemcpyHtoDAsync(jcuda.driver.CUdeviceptr, jcuda.Pointer, long, jcuda.driver.CUstream), cuMemFree(jcuda.driver.CUdeviceptr), cuMemFreeHost(jcuda.Pointer), cuMemGetAddressRange(jcuda.driver.CUdeviceptr, long[], jcuda.driver.CUdeviceptr), cuMemGetInfo(long[], long[]), cuMemHostAlloc(jcuda.Pointer, long, int), cuMemHostGetDevicePointer(jcuda.driver.CUdeviceptr, jcuda.Pointer, int), cuMemsetD2D8(jcuda.driver.CUdeviceptr, long, byte, long, long), cuMemsetD2D16(jcuda.driver.CUdeviceptr, long, short, long, long), cuMemsetD2D32(jcuda.driver.CUdeviceptr, long, int, long, long), cuMemsetD8(jcuda.driver.CUdeviceptr, byte, long), cuMemsetD16(jcuda.driver.CUdeviceptr, short, long), cuMemsetD32(jcuda.driver.CUdeviceptr, int, long)

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

Note:
Note that this function may also return error codes from previous, asynchronous launches.
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

See Also:

cuArray3DCreate(jcuda.driver.CUarray, jcuda.driver.CUDA_ARRAY3D_DESCRIPTOR), cuArray3DGetDescriptor(jcuda.driver.CUDA_ARRAY3D_DESCRIPTOR, jcuda.driver.CUarray), cuArrayCreate(jcuda.driver.CUarray, jcuda.driver.CUDA_ARRAY_DESCRIPTOR), cuArrayDestroy(jcuda.driver.CUarray), cuArrayGetDescriptor(jcuda.driver.CUDA_ARRAY_DESCRIPTOR, jcuda.driver.CUarray), cuMemAlloc(jcuda.driver.CUdeviceptr, long), cuMemAllocHost(jcuda.Pointer, long), cuMemAllocPitch(jcuda.driver.CUdeviceptr, long[], long, long, int), cuMemcpy2D(jcuda.driver.CUDA_MEMCPY2D), cuMemcpy2DAsync(jcuda.driver.CUDA_MEMCPY2D, jcuda.driver.CUstream), cuMemcpy2DUnaligned(jcuda.driver.CUDA_MEMCPY2D), cuMemcpy3D(jcuda.driver.CUDA_MEMCPY3D), cuMemcpy3DAsync(jcuda.driver.CUDA_MEMCPY3D, jcuda.driver.CUstream), cuMemcpyAtoA(jcuda.driver.CUarray, long, jcuda.driver.CUarray, long, long), cuMemcpyAtoD(jcuda.driver.CUdeviceptr, jcuda.driver.CUarray, long, long), cuMemcpyAtoH(jcuda.Pointer, jcuda.driver.CUarray, long, long), cuMemcpyAtoHAsync(jcuda.Pointer, jcuda.driver.CUarray, long, long, jcuda.driver.CUstream), cuMemcpyDtoD(jcuda.driver.CUdeviceptr, jcuda.driver.CUdeviceptr, long), cuMemcpyDtoDAsync(jcuda.driver.CUdeviceptr, jcuda.driver.CUdeviceptr, long, jcuda.driver.CUstream), cuMemcpyDtoH(jcuda.Pointer, jcuda.driver.CUdeviceptr, long), cuMemcpyDtoHAsync(jcuda.Pointer, jcuda.driver.CUdeviceptr, long, jcuda.driver.CUstream), cuMemcpyHtoA(jcuda.driver.CUarray, long, jcuda.Pointer, long), cuMemcpyHtoAAsync(jcuda.driver.CUarray, long, jcuda.Pointer, long, jcuda.driver.CUstream), cuMemcpyHtoD(jcuda.driver.CUdeviceptr, jcuda.Pointer, long), cuMemcpyHtoDAsync(jcuda.driver.CUdeviceptr, jcuda.Pointer, long, jcuda.driver.CUstream), cuMemFree(jcuda.driver.CUdeviceptr), cuMemFreeHost(jcuda.Pointer), cuMemGetAddressRange(jcuda.driver.CUdeviceptr, long[], jcuda.driver.CUdeviceptr), cuMemGetInfo(long[], long[]), cuMemHostAlloc(jcuda.Pointer, long, int), cuMemHostGetDevicePointer(jcuda.driver.CUdeviceptr, jcuda.Pointer, int), cuMemsetD2D8(jcuda.driver.CUdeviceptr, long, byte, long, long), cuMemsetD2D16(jcuda.driver.CUdeviceptr, long, short, long, long), cuMemsetD2D32(jcuda.driver.CUdeviceptr, long, int, long, long), cuMemsetD8(jcuda.driver.CUdeviceptr, byte, long), cuMemsetD16(jcuda.driver.CUdeviceptr, short, long), cuMemsetD32(jcuda.driver.CUdeviceptr, int, long)

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

Note:
Note that this function may also return error codes from previous, asynchronous launches.
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

See Also:

cuArray3DCreate(jcuda.driver.CUarray, jcuda.driver.CUDA_ARRAY3D_DESCRIPTOR), cuArray3DGetDescriptor(jcuda.driver.CUDA_ARRAY3D_DESCRIPTOR, jcuda.driver.CUarray), cuArrayCreate(jcuda.driver.CUarray, jcuda.driver.CUDA_ARRAY_DESCRIPTOR), cuArrayDestroy(jcuda.driver.CUarray), cuArrayGetDescriptor(jcuda.driver.CUDA_ARRAY_DESCRIPTOR, jcuda.driver.CUarray), cuMemAlloc(jcuda.driver.CUdeviceptr, long), cuMemAllocHost(jcuda.Pointer, long), cuMemAllocPitch(jcuda.driver.CUdeviceptr, long[], long, long, int), cuMemcpy2D(jcuda.driver.CUDA_MEMCPY2D), cuMemcpy2DAsync(jcuda.driver.CUDA_MEMCPY2D, jcuda.driver.CUstream), cuMemcpy2DUnaligned(jcuda.driver.CUDA_MEMCPY2D), cuMemcpy3D(jcuda.driver.CUDA_MEMCPY3D), cuMemcpy3DAsync(jcuda.driver.CUDA_MEMCPY3D, jcuda.driver.CUstream), cuMemcpyAtoA(jcuda.driver.CUarray, long, jcuda.driver.CUarray, long, long), cuMemcpyAtoH(jcuda.Pointer, jcuda.driver.CUarray, long, long), cuMemcpyAtoHAsync(jcuda.Pointer, jcuda.driver.CUarray, long, long, jcuda.driver.CUstream), cuMemcpyDtoA(jcuda.driver.CUarray, long, jcuda.driver.CUdeviceptr, long), cuMemcpyDtoD(jcuda.driver.CUdeviceptr, jcuda.driver.CUdeviceptr, long), cuMemcpyDtoDAsync(jcuda.driver.CUdeviceptr, jcuda.driver.CUdeviceptr, long, jcuda.driver.CUstream), cuMemcpyDtoH(jcuda.Pointer, jcuda.driver.CUdeviceptr, long), cuMemcpyDtoHAsync(jcuda.Pointer, jcuda.driver.CUdeviceptr, long, jcuda.driver.CUstream), cuMemcpyHtoA(jcuda.driver.CUarray, long, jcuda.Pointer, long), cuMemcpyHtoAAsync(jcuda.driver.CUarray, long, jcuda.Pointer, long, jcuda.driver.CUstream), cuMemcpyHtoD(jcuda.driver.CUdeviceptr, jcuda.Pointer, long), cuMemcpyHtoDAsync(jcuda.driver.CUdeviceptr, jcuda.Pointer, long, jcuda.driver.CUstream), cuMemFree(jcuda.driver.CUdeviceptr), cuMemFreeHost(jcuda.Pointer), cuMemGetAddressRange(jcuda.driver.CUdeviceptr, long[], jcuda.driver.CUdeviceptr), cuMemGetInfo(long[], long[]), cuMemHostAlloc(jcuda.Pointer, long, int), cuMemHostGetDevicePointer(jcuda.driver.CUdeviceptr, jcuda.Pointer, int), cuMemsetD2D8(jcuda.driver.CUdeviceptr, long, byte, long, long), cuMemsetD2D16(jcuda.driver.CUdeviceptr, long, short, long, long), cuMemsetD2D32(jcuda.driver.CUdeviceptr, long, int, long, long), cuMemsetD8(jcuda.driver.CUdeviceptr, byte, long), cuMemsetD16(jcuda.driver.CUdeviceptr, short, long), cuMemsetD32(jcuda.driver.CUdeviceptr, int, long)

cuMemcpyHtoA
```
public static int cuMemcpyHtoA(CUarray dstArray,
                               long dstIndex,
                               Pointer pSrc,
                               long ByteCount)
```
Copies memory from Host to Array.
```
 CUresult cuMemcpyHtoA (
      CUarray dstArray,
      size_t dstOffset,
      const void* srcHost,
      size_t ByteCount )
 
```
Copies memory from Host to Array. Copies from host memory to a 1D CUDA array. dstArray and dstOffset specify the CUDA array handle and starting offset in bytes of the destination data. pSrc specifies the base address of the source. ByteCount specifies the number of bytes to copy.

Note:
Note that this function may also return error codes from previous, asynchronous launches.
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

See Also:

cuArray3DCreate(jcuda.driver.CUarray, jcuda.driver.CUDA_ARRAY3D_DESCRIPTOR), cuArray3DGetDescriptor(jcuda.driver.CUDA_ARRAY3D_DESCRIPTOR, jcuda.driver.CUarray), cuArrayCreate(jcuda.driver.CUarray, jcuda.driver.CUDA_ARRAY_DESCRIPTOR), cuArrayDestroy(jcuda.driver.CUarray), cuArrayGetDescriptor(jcuda.driver.CUDA_ARRAY_DESCRIPTOR, jcuda.driver.CUarray), cuMemAlloc(jcuda.driver.CUdeviceptr, long), cuMemAllocHost(jcuda.Pointer, long), cuMemAllocPitch(jcuda.driver.CUdeviceptr, long[], long, long, int), cuMemcpy2D(jcuda.driver.CUDA_MEMCPY2D), cuMemcpy2DAsync(jcuda.driver.CUDA_MEMCPY2D, jcuda.driver.CUstream), cuMemcpy2DUnaligned(jcuda.driver.CUDA_MEMCPY2D), cuMemcpy3D(jcuda.driver.CUDA_MEMCPY3D), cuMemcpy3DAsync(jcuda.driver.CUDA_MEMCPY3D, jcuda.driver.CUstream), cuMemcpyAtoA(jcuda.driver.CUarray, long, jcuda.driver.CUarray, long, long), cuMemcpyAtoD(jcuda.driver.CUdeviceptr, jcuda.driver.CUarray, long, long), cuMemcpyAtoH(jcuda.Pointer, jcuda.driver.CUarray, long, long), cuMemcpyAtoHAsync(jcuda.Pointer, jcuda.driver.CUarray, long, long, jcuda.driver.CUstream), cuMemcpyDtoA(jcuda.driver.CUarray, long, jcuda.driver.CUdeviceptr, long), cuMemcpyDtoD(jcuda.driver.CUdeviceptr, jcuda.driver.CUdeviceptr, long), cuMemcpyDtoDAsync(jcuda.driver.CUdeviceptr, jcuda.driver.CUdeviceptr, long, jcuda.driver.CUstream), cuMemcpyDtoH(jcuda.Pointer, jcuda.driver.CUdeviceptr, long), cuMemcpyDtoHAsync(jcuda.Pointer, jcuda.driver.CUdeviceptr, long, jcuda.driver.CUstream), cuMemcpyHtoAAsync(jcuda.driver.CUarray, long, jcuda.Pointer, long, jcuda.driver.CUstream), cuMemcpyHtoD(jcuda.driver.CUdeviceptr, jcuda.Pointer, long), cuMemcpyHtoDAsync(jcuda.driver.CUdeviceptr, jcuda.Pointer, long, jcuda.driver.CUstream), cuMemFree(jcuda.driver.CUdeviceptr), cuMemFreeHost(jcuda.Pointer), cuMemGetAddressRange(jcuda.driver.CUdeviceptr, long[], jcuda.driver.CUdeviceptr), cuMemGetInfo(long[], long[]), cuMemHostAlloc(jcuda.Pointer, long, int), cuMemHostGetDevicePointer(jcuda.driver.CUdeviceptr, jcuda.Pointer, int), cuMemsetD2D8(jcuda.driver.CUdeviceptr, long, byte, long, long), cuMemsetD2D16(jcuda.driver.CUdeviceptr, long, short, long, long), cuMemsetD2D32(jcuda.driver.CUdeviceptr, long, int, long, long), cuMemsetD8(jcuda.driver.CUdeviceptr, byte, long), cuMemsetD16(jcuda.driver.CUdeviceptr, short, long), cuMemsetD32(jcuda.driver.CUdeviceptr, int, long)

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

Note:
Note that this function may also return error codes from previous, asynchronous launches.
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

See Also:

cuArray3DCreate(jcuda.driver.CUarray, jcuda.driver.CUDA_ARRAY3D_DESCRIPTOR), cuArray3DGetDescriptor(jcuda.driver.CUDA_ARRAY3D_DESCRIPTOR, jcuda.driver.CUarray), cuArrayCreate(jcuda.driver.CUarray, jcuda.driver.CUDA_ARRAY_DESCRIPTOR), cuArrayDestroy(jcuda.driver.CUarray), cuArrayGetDescriptor(jcuda.driver.CUDA_ARRAY_DESCRIPTOR, jcuda.driver.CUarray), cuMemAlloc(jcuda.driver.CUdeviceptr, long), cuMemAllocHost(jcuda.Pointer, long), cuMemAllocPitch(jcuda.driver.CUdeviceptr, long[], long, long, int), cuMemcpy2D(jcuda.driver.CUDA_MEMCPY2D), cuMemcpy2DAsync(jcuda.driver.CUDA_MEMCPY2D, jcuda.driver.CUstream), cuMemcpy2DUnaligned(jcuda.driver.CUDA_MEMCPY2D), cuMemcpy3D(jcuda.driver.CUDA_MEMCPY3D), cuMemcpy3DAsync(jcuda.driver.CUDA_MEMCPY3D, jcuda.driver.CUstream), cuMemcpyAtoA(jcuda.driver.CUarray, long, jcuda.driver.CUarray, long, long), cuMemcpyAtoD(jcuda.driver.CUdeviceptr, jcuda.driver.CUarray, long, long), cuMemcpyAtoHAsync(jcuda.Pointer, jcuda.driver.CUarray, long, long, jcuda.driver.CUstream), cuMemcpyDtoA(jcuda.driver.CUarray, long, jcuda.driver.CUdeviceptr, long), cuMemcpyDtoD(jcuda.driver.CUdeviceptr, jcuda.driver.CUdeviceptr, long), cuMemcpyDtoDAsync(jcuda.driver.CUdeviceptr, jcuda.driver.CUdeviceptr, long, jcuda.driver.CUstream), cuMemcpyDtoH(jcuda.Pointer, jcuda.driver.CUdeviceptr, long), cuMemcpyDtoHAsync(jcuda.Pointer, jcuda.driver.CUdeviceptr, long, jcuda.driver.CUstream), cuMemcpyHtoA(jcuda.driver.CUarray, long, jcuda.Pointer, long), cuMemcpyHtoAAsync(jcuda.driver.CUarray, long, jcuda.Pointer, long, jcuda.driver.CUstream), cuMemcpyHtoD(jcuda.driver.CUdeviceptr, jcuda.Pointer, long), cuMemcpyHtoDAsync(jcuda.driver.CUdeviceptr, jcuda.Pointer, long, jcuda.driver.CUstream), cuMemFree(jcuda.driver.CUdeviceptr), cuMemFreeHost(jcuda.Pointer), cuMemGetAddressRange(jcuda.driver.CUdeviceptr, long[], jcuda.driver.CUdeviceptr), cuMemGetInfo(long[], long[]), cuMemHostAlloc(jcuda.Pointer, long, int), cuMemHostGetDevicePointer(jcuda.driver.CUdeviceptr, jcuda.Pointer, int), cuMemsetD2D8(jcuda.driver.CUdeviceptr, long, byte, long, long), cuMemsetD2D16(jcuda.driver.CUdeviceptr, long, short, long, long), cuMemsetD2D32(jcuda.driver.CUdeviceptr, long, int, long, long), cuMemsetD8(jcuda.driver.CUdeviceptr, byte, long), cuMemsetD16(jcuda.driver.CUdeviceptr, short, long), cuMemsetD32(jcuda.driver.CUdeviceptr, int, long)

cuMemcpyAtoA
```
public static int cuMemcpyAtoA(CUarray dstArray,
                               long dstIndex,
                               CUarray srcArray,
                               long srcIndex,
                               long ByteCount)
```
Copies memory from Array to Array.
```
 CUresult cuMemcpyAtoA (
      CUarray dstArray,
      size_t dstOffset,
      CUarray srcArray,
      size_t srcOffset,
      size_t ByteCount )
 
```
Copies memory from Array to Array. Copies from one 1D CUDA array to another. dstArray and srcArray specify the handles of the destination and source CUDA arrays for the copy, respectively. dstOffset and srcOffset specify the destination and source offsets in bytes into the CUDA arrays. 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.

Note:
Note that this function may also return error codes from previous, asynchronous launches.
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

See Also:

cuArray3DCreate(jcuda.driver.CUarray, jcuda.driver.CUDA_ARRAY3D_DESCRIPTOR), cuArray3DGetDescriptor(jcuda.driver.CUDA_ARRAY3D_DESCRIPTOR, jcuda.driver.CUarray), cuArrayCreate(jcuda.driver.CUarray, jcuda.driver.CUDA_ARRAY_DESCRIPTOR), cuArrayDestroy(jcuda.driver.CUarray), cuArrayGetDescriptor(jcuda.driver.CUDA_ARRAY_DESCRIPTOR, jcuda.driver.CUarray), cuMemAlloc(jcuda.driver.CUdeviceptr, long), cuMemAllocHost(jcuda.Pointer, long), cuMemAllocPitch(jcuda.driver.CUdeviceptr, long[], long, long, int), cuMemcpy2D(jcuda.driver.CUDA_MEMCPY2D), cuMemcpy2DAsync(jcuda.driver.CUDA_MEMCPY2D, jcuda.driver.CUstream), cuMemcpy2DUnaligned(jcuda.driver.CUDA_MEMCPY2D), cuMemcpy3D(jcuda.driver.CUDA_MEMCPY3D), cuMemcpy3DAsync(jcuda.driver.CUDA_MEMCPY3D, jcuda.driver.CUstream), cuMemcpyAtoD(jcuda.driver.CUdeviceptr, jcuda.driver.CUarray, long, long), cuMemcpyAtoH(jcuda.Pointer, jcuda.driver.CUarray, long, long), cuMemcpyAtoHAsync(jcuda.Pointer, jcuda.driver.CUarray, long, long, jcuda.driver.CUstream), cuMemcpyDtoA(jcuda.driver.CUarray, long, jcuda.driver.CUdeviceptr, long), cuMemcpyDtoD(jcuda.driver.CUdeviceptr, jcuda.driver.CUdeviceptr, long), cuMemcpyDtoDAsync(jcuda.driver.CUdeviceptr, jcuda.driver.CUdeviceptr, long, jcuda.driver.CUstream), cuMemcpyDtoH(jcuda.Pointer, jcuda.driver.CUdeviceptr, long), cuMemcpyDtoHAsync(jcuda.Pointer, jcuda.driver.CUdeviceptr, long, jcuda.driver.CUstream), cuMemcpyHtoA(jcuda.driver.CUarray, long, jcuda.Pointer, long), cuMemcpyHtoAAsync(jcuda.driver.CUarray, long, jcuda.Pointer, long, jcuda.driver.CUstream), cuMemcpyHtoD(jcuda.driver.CUdeviceptr, jcuda.Pointer, long), cuMemcpyHtoDAsync(jcuda.driver.CUdeviceptr, jcuda.Pointer, long, jcuda.driver.CUstream), cuMemFree(jcuda.driver.CUdeviceptr), cuMemFreeHost(jcuda.Pointer), cuMemGetAddressRange(jcuda.driver.CUdeviceptr, long[], jcuda.driver.CUdeviceptr), cuMemGetInfo(long[], long[]), cuMemHostAlloc(jcuda.Pointer, long, int), cuMemHostGetDevicePointer(jcuda.driver.CUdeviceptr, jcuda.Pointer, int), cuMemsetD2D8(jcuda.driver.CUdeviceptr, long, byte, long, long), cuMemsetD2D16(jcuda.driver.CUdeviceptr, long, short, long, long), cuMemsetD2D32(jcuda.driver.CUdeviceptr, long, int, long, long), cuMemsetD8(jcuda.driver.CUdeviceptr, byte, long), cuMemsetD16(jcuda.driver.CUdeviceptr, short, long), cuMemsetD32(jcuda.driver.CUdeviceptr, int, long)

cuMemcpy2D
```
public static int cuMemcpy2D(CUDA_MEMCPY2D pCopy)
```
Copies memory for 2D arrays.
```
 CUresult cuMemcpy2D (
      const CUDA_MEMCPY2D* pCopy )
 
```
Copies memory for 2D arrays. Perform a 2D memory copy according to the parameters specified in 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;
```
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.

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.

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.

If srcMemoryType is CU_MEMORYTYPE_ARRAY, srcArray specifies the handle of the source data. srcHost, srcDevice and srcPitch are ignored.

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.

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.

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.

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.
For host pointers, the starting address is
```
  void* Start = (void*)((char*)srcHost+srcY*srcPitch +
 srcXInBytes);
```
For device pointers, the starting address is
```
  CUdeviceptr Start =
 srcDevice+srcY*srcPitch+srcXInBytes;
```
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.
For host pointers, the base address is
```
  void* dstStart = (void*)((char*)dstHost+dstY*dstPitch +
 dstXInBytes);
```
For device pointers, the starting address is
```
  CUdeviceptr dstStart =
 dstDevice+dstY*dstPitch+dstXInBytes;
```
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.
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.

Note:
Note that this function may also return error codes from previous, asynchronous launches.
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

See Also:

cuArray3DCreate(jcuda.driver.CUarray, jcuda.driver.CUDA_ARRAY3D_DESCRIPTOR), cuArray3DGetDescriptor(jcuda.driver.CUDA_ARRAY3D_DESCRIPTOR, jcuda.driver.CUarray), cuArrayCreate(jcuda.driver.CUarray, jcuda.driver.CUDA_ARRAY_DESCRIPTOR), cuArrayDestroy(jcuda.driver.CUarray), cuArrayGetDescriptor(jcuda.driver.CUDA_ARRAY_DESCRIPTOR, jcuda.driver.CUarray), cuMemAlloc(jcuda.driver.CUdeviceptr, long), cuMemAllocHost(jcuda.Pointer, long), cuMemAllocPitch(jcuda.driver.CUdeviceptr, long[], long, long, int), cuMemcpy2DAsync(jcuda.driver.CUDA_MEMCPY2D, jcuda.driver.CUstream), cuMemcpy2DUnaligned(jcuda.driver.CUDA_MEMCPY2D), cuMemcpy3D(jcuda.driver.CUDA_MEMCPY3D), cuMemcpy3DAsync(jcuda.driver.CUDA_MEMCPY3D, jcuda.driver.CUstream), cuMemcpyAtoA(jcuda.driver.CUarray, long, jcuda.driver.CUarray, long, long), cuMemcpyAtoD(jcuda.driver.CUdeviceptr, jcuda.driver.CUarray, long, long), cuMemcpyAtoH(jcuda.Pointer, jcuda.driver.CUarray, long, long), cuMemcpyAtoHAsync(jcuda.Pointer, jcuda.driver.CUarray, long, long, jcuda.driver.CUstream), cuMemcpyDtoA(jcuda.driver.CUarray, long, jcuda.driver.CUdeviceptr, long), cuMemcpyDtoD(jcuda.driver.CUdeviceptr, jcuda.driver.CUdeviceptr, long), cuMemcpyDtoDAsync(jcuda.driver.CUdeviceptr, jcuda.driver.CUdeviceptr, long, jcuda.driver.CUstream), cuMemcpyDtoH(jcuda.Pointer, jcuda.driver.CUdeviceptr, long), cuMemcpyDtoHAsync(jcuda.Pointer, jcuda.driver.CUdeviceptr, long, jcuda.driver.CUstream), cuMemcpyHtoA(jcuda.driver.CUarray, long, jcuda.Pointer, long), cuMemcpyHtoAAsync(jcuda.driver.CUarray, long, jcuda.Pointer, long, jcuda.driver.CUstream), cuMemcpyHtoD(jcuda.driver.CUdeviceptr, jcuda.Pointer, long), cuMemcpyHtoDAsync(jcuda.driver.CUdeviceptr, jcuda.Pointer, long, jcuda.driver.CUstream), cuMemFree(jcuda.driver.CUdeviceptr), cuMemFreeHost(jcuda.Pointer), cuMemGetAddressRange(jcuda.driver.CUdeviceptr, long[], jcuda.driver.CUdeviceptr), cuMemGetInfo(long[], long[]), cuMemHostAlloc(jcuda.Pointer, long, int), cuMemHostGetDevicePointer(jcuda.driver.CUdeviceptr, jcuda.Pointer, int), cuMemsetD2D8(jcuda.driver.CUdeviceptr, long, byte, long, long), cuMemsetD2D16(jcuda.driver.CUdeviceptr, long, short, long, long), cuMemsetD2D32(jcuda.driver.CUdeviceptr, long, int, long, long), cuMemsetD8(jcuda.driver.CUdeviceptr, byte, long), cuMemsetD16(jcuda.driver.CUdeviceptr, short, long), cuMemsetD32(jcuda.driver.CUdeviceptr, int, long)

cuMemcpy2DUnaligned
```
public static int cuMemcpy2DUnaligned(CUDA_MEMCPY2D pCopy)
```
Copies memory for 2D arrays.
```
 CUresult cuMemcpy2DUnaligned (
      const CUDA_MEMCPY2D* pCopy )
 
```
Copies memory for 2D arrays. Perform a 2D memory copy according to the parameters specified in 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;
```
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.

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.

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.

If srcMemoryType is CU_MEMORYTYPE_ARRAY, srcArray specifies the handle of the source data. srcHost, srcDevice and srcPitch are ignored.

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.

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.

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.

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.
For host pointers, the starting address is
```
  void* Start = (void*)((char*)srcHost+srcY*srcPitch +
 srcXInBytes);
```
For device pointers, the starting address is
```
  CUdeviceptr Start =
 srcDevice+srcY*srcPitch+srcXInBytes;
```
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.
For host pointers, the base address is
```
  void* dstStart = (void*)((char*)dstHost+dstY*dstPitch +
 dstXInBytes);
```
For device pointers, the starting address is
```
  CUdeviceptr dstStart =
 dstDevice+dstY*dstPitch+dstXInBytes;
```
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.
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.

Note:
Note that this function may also return error codes from previous, asynchronous launches.
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

See Also:

cuArray3DCreate(jcuda.driver.CUarray, jcuda.driver.CUDA_ARRAY3D_DESCRIPTOR), cuArray3DGetDescriptor(jcuda.driver.CUDA_ARRAY3D_DESCRIPTOR, jcuda.driver.CUarray), cuArrayCreate(jcuda.driver.CUarray, jcuda.driver.CUDA_ARRAY_DESCRIPTOR), cuArrayDestroy(jcuda.driver.CUarray), cuArrayGetDescriptor(jcuda.driver.CUDA_ARRAY_DESCRIPTOR, jcuda.driver.CUarray), cuMemAlloc(jcuda.driver.CUdeviceptr, long), cuMemAllocHost(jcuda.Pointer, long), cuMemAllocPitch(jcuda.driver.CUdeviceptr, long[], long, long, int), cuMemcpy2D(jcuda.driver.CUDA_MEMCPY2D), cuMemcpy2DAsync(jcuda.driver.CUDA_MEMCPY2D, jcuda.driver.CUstream), cuMemcpy3D(jcuda.driver.CUDA_MEMCPY3D), cuMemcpy3DAsync(jcuda.driver.CUDA_MEMCPY3D, jcuda.driver.CUstream), cuMemcpyAtoA(jcuda.driver.CUarray, long, jcuda.driver.CUarray, long, long), cuMemcpyAtoD(jcuda.driver.CUdeviceptr, jcuda.driver.CUarray, long, long), cuMemcpyAtoH(jcuda.Pointer, jcuda.driver.CUarray, long, long), cuMemcpyAtoHAsync(jcuda.Pointer, jcuda.driver.CUarray, long, long, jcuda.driver.CUstream), cuMemcpyDtoA(jcuda.driver.CUarray, long, jcuda.driver.CUdeviceptr, long), cuMemcpyDtoD(jcuda.driver.CUdeviceptr, jcuda.driver.CUdeviceptr, long), cuMemcpyDtoDAsync(jcuda.driver.CUdeviceptr, jcuda.driver.CUdeviceptr, long, jcuda.driver.CUstream), cuMemcpyDtoH(jcuda.Pointer, jcuda.driver.CUdeviceptr, long), cuMemcpyDtoHAsync(jcuda.Pointer, jcuda.driver.CUdeviceptr, long, jcuda.driver.CUstream), cuMemcpyHtoA(jcuda.driver.CUarray, long, jcuda.Pointer, long), cuMemcpyHtoAAsync(jcuda.driver.CUarray, long, jcuda.Pointer, long, jcuda.driver.CUstream), cuMemcpyHtoD(jcuda.driver.CUdeviceptr, jcuda.Pointer, long), cuMemcpyHtoDAsync(jcuda.driver.CUdeviceptr, jcuda.Pointer, long, jcuda.driver.CUstream), cuMemFree(jcuda.driver.CUdeviceptr), cuMemFreeHost(jcuda.Pointer), cuMemGetAddressRange(jcuda.driver.CUdeviceptr, long[], jcuda.driver.CUdeviceptr), cuMemGetInfo(long[], long[]), cuMemHostAlloc(jcuda.Pointer, long, int), cuMemHostGetDevicePointer(jcuda.driver.CUdeviceptr, jcuda.Pointer, int), cuMemsetD2D8(jcuda.driver.CUdeviceptr, long, byte, long, long), cuMemsetD2D16(jcuda.driver.CUdeviceptr, long, short, long, long), cuMemsetD2D32(jcuda.driver.CUdeviceptr, long, int, long, long), cuMemsetD8(jcuda.driver.CUdeviceptr, byte, long), cuMemsetD16(jcuda.driver.CUdeviceptr, short, long), cuMemsetD32(jcuda.driver.CUdeviceptr, int, long)

cuMemcpy3D
```
public static int cuMemcpy3D(CUDA_MEMCPY3D pCopy)
```
Copies memory for 3D arrays.
```
 CUresult cuMemcpy3D (
      const CUDA_MEMCPY3D* pCopy )
 
```
Copies memory for 3D arrays. Perform a 3D memory copy according to the parameters specified in 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;
```
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.

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.

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.

If srcMemoryType is CU_MEMORYTYPE_ARRAY, srcArray specifies the handle of the source data. srcHost, srcDevice, srcPitch and srcHeight are ignored.

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.

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.

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.

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.
For host pointers, the starting address is
```
  void* Start = (void*)((char*)srcHost+(srcZ*srcHeight+srcY)*srcPitch
 + srcXInBytes);
```
For device pointers, the starting address is
```
  CUdeviceptr Start =
 srcDevice+(srcZ*srcHeight+srcY)*srcPitch+srcXInBytes;
```
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.
For host pointers, the base address is
```
  void* dstStart = (void*)((char*)dstHost+(dstZ*dstHeight+dstY)*dstPitch
 + dstXInBytes);
```
For device pointers, the starting address is
```
  CUdeviceptr dstStart =
 dstDevice+(dstZ*dstHeight+dstY)*dstPitch+dstXInBytes;
```
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.
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.

Note:
Note that this function may also return error codes from previous, asynchronous launches.
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

See Also:

cuArray3DCreate(jcuda.driver.CUarray, jcuda.driver.CUDA_ARRAY3D_DESCRIPTOR), cuArray3DGetDescriptor(jcuda.driver.CUDA_ARRAY3D_DESCRIPTOR, jcuda.driver.CUarray), cuArrayCreate(jcuda.driver.CUarray, jcuda.driver.CUDA_ARRAY_DESCRIPTOR), cuArrayDestroy(jcuda.driver.CUarray), cuArrayGetDescriptor(jcuda.driver.CUDA_ARRAY_DESCRIPTOR, jcuda.driver.CUarray), cuMemAlloc(jcuda.driver.CUdeviceptr, long), cuMemAllocHost(jcuda.Pointer, long), cuMemAllocPitch(jcuda.driver.CUdeviceptr, long[], long, long, int), cuMemcpy2D(jcuda.driver.CUDA_MEMCPY2D), cuMemcpy2DAsync(jcuda.driver.CUDA_MEMCPY2D, jcuda.driver.CUstream), cuMemcpy2DUnaligned(jcuda.driver.CUDA_MEMCPY2D), cuMemcpy3DAsync(jcuda.driver.CUDA_MEMCPY3D, jcuda.driver.CUstream), cuMemcpyAtoA(jcuda.driver.CUarray, long, jcuda.driver.CUarray, long, long), cuMemcpyAtoD(jcuda.driver.CUdeviceptr, jcuda.driver.CUarray, long, long), cuMemcpyAtoH(jcuda.Pointer, jcuda.driver.CUarray, long, long), cuMemcpyAtoHAsync(jcuda.Pointer, jcuda.driver.CUarray, long, long, jcuda.driver.CUstream), cuMemcpyDtoA(jcuda.driver.CUarray, long, jcuda.driver.CUdeviceptr, long), cuMemcpyDtoD(jcuda.driver.CUdeviceptr, jcuda.driver.CUdeviceptr, long), cuMemcpyDtoDAsync(jcuda.driver.CUdeviceptr, jcuda.driver.CUdeviceptr, long, jcuda.driver.CUstream), cuMemcpyDtoH(jcuda.Pointer, jcuda.driver.CUdeviceptr, long), cuMemcpyDtoHAsync(jcuda.Pointer, jcuda.driver.CUdeviceptr, long, jcuda.driver.CUstream), cuMemcpyHtoA(jcuda.driver.CUarray, long, jcuda.Pointer, long), cuMemcpyHtoAAsync(jcuda.driver.CUarray, long, jcuda.Pointer, long, jcuda.driver.CUstream), cuMemcpyHtoD(jcuda.driver.CUdeviceptr, jcuda.Pointer, long), cuMemcpyHtoDAsync(jcuda.driver.CUdeviceptr, jcuda.Pointer, long, jcuda.driver.CUstream), cuMemFree(jcuda.driver.CUdeviceptr), cuMemFreeHost(jcuda.Pointer), cuMemGetAddressRange(jcuda.driver.CUdeviceptr, long[], jcuda.driver.CUdeviceptr), cuMemGetInfo(long[], long[]), cuMemHostAlloc(jcuda.Pointer, long, int), cuMemHostGetDevicePointer(jcuda.driver.CUdeviceptr, jcuda.Pointer, int), cuMemsetD2D8(jcuda.driver.CUdeviceptr, long, byte, long, long), cuMemsetD2D16(jcuda.driver.CUdeviceptr, long, short, long, long), cuMemsetD2D32(jcuda.driver.CUdeviceptr, long, int, long, long), cuMemsetD8(jcuda.driver.CUdeviceptr, byte, long), cuMemsetD16(jcuda.driver.CUdeviceptr, short, long), cuMemsetD32(jcuda.driver.CUdeviceptr, int, long)

cuMemcpy3DPeer
```
public static int cuMemcpy3DPeer(CUDA_MEMCPY3D_PEER pCopy)
```
Copies memory between contexts.
```
 CUresult cuMemcpy3DPeer (
      const CUDA_MEMCPY3D_PEER* pCopy )
 
```
Copies memory between contexts. Perform a 3D memory copy according to the parameters specified in pCopy. See the definition of the CUDA_MEMCPY3D_PEER structure for documentation of its parameters.

Note that this function is synchronous with respect to the host only if the source or destination memory is of type CU_MEMORYTYPE_HOST. Note also that this copy is serialized with respect all pending and future asynchronous work in to the current context, the copy's source context, and the copy's destination context (use cuMemcpy3DPeerAsync to avoid this synchronization).

Note:
Note that this function may also return error codes from previous, asynchronous launches.
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

See Also:

cuMemcpyDtoD(jcuda.driver.CUdeviceptr, jcuda.driver.CUdeviceptr, long), cuMemcpyPeer(jcuda.driver.CUdeviceptr, jcuda.driver.CUcontext, jcuda.driver.CUdeviceptr, jcuda.driver.CUcontext, long), cuMemcpyDtoDAsync(jcuda.driver.CUdeviceptr, jcuda.driver.CUdeviceptr, long, jcuda.driver.CUstream), cuMemcpyPeerAsync(jcuda.driver.CUdeviceptr, jcuda.driver.CUcontext, jcuda.driver.CUdeviceptr, jcuda.driver.CUcontext, long, jcuda.driver.CUstream), cuMemcpy3DPeerAsync(jcuda.driver.CUDA_MEMCPY3D_PEER, jcuda.driver.CUstream)

cuMemcpyAsync
```
public static int cuMemcpyAsync(CUdeviceptr dst,
                                CUdeviceptr src,
                                long ByteCount,
                                CUstream hStream)
```
Copies memory asynchronously.
```
 CUresult cuMemcpyAsync (
      CUdeviceptr dst,
      CUdeviceptr src,
      size_t ByteCount,
      CUstream hStream )
 
```
Copies memory asynchronously. Copies data between two pointers. dst and src are base pointers of the destination and source, respectively. 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. Note that this function is asynchronous and can optionally be associated to a stream by passing a non-zero hStream argument

Note:
Note that this function may also return error codes from previous, asynchronous launches.
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

See Also:

cuArray3DCreate(jcuda.driver.CUarray, jcuda.driver.CUDA_ARRAY3D_DESCRIPTOR), cuArray3DGetDescriptor(jcuda.driver.CUDA_ARRAY3D_DESCRIPTOR, jcuda.driver.CUarray), cuArrayCreate(jcuda.driver.CUarray, jcuda.driver.CUDA_ARRAY_DESCRIPTOR), cuArrayDestroy(jcuda.driver.CUarray), cuArrayGetDescriptor(jcuda.driver.CUDA_ARRAY_DESCRIPTOR, jcuda.driver.CUarray), cuMemAlloc(jcuda.driver.CUdeviceptr, long), cuMemAllocHost(jcuda.Pointer, long), cuMemAllocPitch(jcuda.driver.CUdeviceptr, long[], long, long, int), cuMemcpy2D(jcuda.driver.CUDA_MEMCPY2D), cuMemcpy2DAsync(jcuda.driver.CUDA_MEMCPY2D, jcuda.driver.CUstream), cuMemcpy2DUnaligned(jcuda.driver.CUDA_MEMCPY2D), cuMemcpy3D(jcuda.driver.CUDA_MEMCPY3D), cuMemcpy3DAsync(jcuda.driver.CUDA_MEMCPY3D, jcuda.driver.CUstream), cuMemcpyAtoA(jcuda.driver.CUarray, long, jcuda.driver.CUarray, long, long), cuMemcpyAtoD(jcuda.driver.CUdeviceptr, jcuda.driver.CUarray, long, long), cuMemcpyAtoH(jcuda.Pointer, jcuda.driver.CUarray, long, long), cuMemcpyAtoHAsync(jcuda.Pointer, jcuda.driver.CUarray, long, long, jcuda.driver.CUstream), cuMemcpyDtoA(jcuda.driver.CUarray, long, jcuda.driver.CUdeviceptr, long), cuMemcpyDtoD(jcuda.driver.CUdeviceptr, jcuda.driver.CUdeviceptr, long), cuMemcpyDtoH(jcuda.Pointer, jcuda.driver.CUdeviceptr, long), cuMemcpyDtoHAsync(jcuda.Pointer, jcuda.driver.CUdeviceptr, long, jcuda.driver.CUstream), cuMemcpyHtoA(jcuda.driver.CUarray, long, jcuda.Pointer, long), cuMemcpyHtoAAsync(jcuda.driver.CUarray, long, jcuda.Pointer, long, jcuda.driver.CUstream), cuMemcpyHtoD(jcuda.driver.CUdeviceptr, jcuda.Pointer, long), cuMemcpyHtoDAsync(jcuda.driver.CUdeviceptr, jcuda.Pointer, long, jcuda.driver.CUstream), cuMemFree(jcuda.driver.CUdeviceptr), cuMemFreeHost(jcuda.Pointer), cuMemGetAddressRange(jcuda.driver.CUdeviceptr, long[], jcuda.driver.CUdeviceptr), cuMemGetInfo(long[], long[]), cuMemHostAlloc(jcuda.Pointer, long, int), cuMemHostGetDevicePointer(jcuda.driver.CUdeviceptr, jcuda.Pointer, int), cuMemsetD2D8(jcuda.driver.CUdeviceptr, long, byte, long, long), cuMemsetD2D8Async(jcuda.driver.CUdeviceptr, long, byte, long, long, jcuda.driver.CUstream), cuMemsetD2D16(jcuda.driver.CUdeviceptr, long, short, long, long), cuMemsetD2D16Async(jcuda.driver.CUdeviceptr, long, short, long, long, jcuda.driver.CUstream), cuMemsetD2D32(jcuda.driver.CUdeviceptr, long, int, long, long), cuMemsetD2D32Async(jcuda.driver.CUdeviceptr, long, int, long, long, jcuda.driver.CUstream), cuMemsetD8(jcuda.driver.CUdeviceptr, byte, long), cuMemsetD8Async(jcuda.driver.CUdeviceptr, byte, long, jcuda.driver.CUstream), cuMemsetD16(jcuda.driver.CUdeviceptr, short, long), cuMemsetD16Async(jcuda.driver.CUdeviceptr, short, long, jcuda.driver.CUstream), cuMemsetD32(jcuda.driver.CUdeviceptr, int, long), cuMemsetD32Async(jcuda.driver.CUdeviceptr, int, long, jcuda.driver.CUstream)

cuMemcpyPeerAsync
```
public static int cuMemcpyPeerAsync(CUdeviceptr dstDevice,
                                    CUcontext dstContext,
                                    CUdeviceptr srcDevice,
                                    CUcontext srcContext,
                                    long ByteCount,
                                    CUstream hStream)
```
Copies device memory between two contexts asynchronously.
```
 CUresult cuMemcpyPeerAsync (
      CUdeviceptr dstDevice,
      CUcontext dstContext,
      CUdeviceptr srcDevice,
      CUcontext srcContext,
      size_t ByteCount,
      CUstream hStream )
 
```
Copies device memory between two contexts asynchronously. Copies from device memory in one context to device memory in another context. dstDevice is the base device pointer of the destination memory and dstContext is the destination context. srcDevice is the base device pointer of the source memory and srcContext is the source pointer. ByteCount specifies the number of bytes to copy. Note that this function is asynchronous with respect to the host and all work in other streams in other devices.

Note:
Note that this function may also return error codes from previous, asynchronous launches.
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

See Also:

cuMemcpyDtoD(jcuda.driver.CUdeviceptr, jcuda.driver.CUdeviceptr, long), cuMemcpyPeer(jcuda.driver.CUdeviceptr, jcuda.driver.CUcontext, jcuda.driver.CUdeviceptr, jcuda.driver.CUcontext, long), cuMemcpy3DPeer(jcuda.driver.CUDA_MEMCPY3D_PEER), cuMemcpyDtoDAsync(jcuda.driver.CUdeviceptr, jcuda.driver.CUdeviceptr, long, jcuda.driver.CUstream), cuMemcpy3DPeerAsync(jcuda.driver.CUDA_MEMCPY3D_PEER, jcuda.driver.CUstream)

cuMemcpyHtoDAsync
```
public static int cuMemcpyHtoDAsync(CUdeviceptr dstDevice,
                                    Pointer srcHost,
                                    long ByteCount,
                                    CUstream hStream)
```
Copies memory from Host to Device.
```
 CUresult cuMemcpyHtoDAsync (
      CUdeviceptr dstDevice,
      const void* srcHost,
      size_t ByteCount,
      CUstream hStream )
 
```
Copies memory from Host to Device. Copies from host memory to device memory. dstDevice and srcHost are the base addresses of the destination and source, respectively. ByteCount specifies the number of bytes to copy.

cuMemcpyHtoDAsync() is asynchronous and can optionally be associated to a stream by passing a non-zero hStream argument. It only works on page-locked memory and returns an error if a pointer to pageable memory is passed as input.

Note:
Note that this function may also return error codes from previous, asynchronous launches.
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

See Also:

cuArray3DCreate(jcuda.driver.CUarray, jcuda.driver.CUDA_ARRAY3D_DESCRIPTOR), cuArray3DGetDescriptor(jcuda.driver.CUDA_ARRAY3D_DESCRIPTOR, jcuda.driver.CUarray), cuArrayCreate(jcuda.driver.CUarray, jcuda.driver.CUDA_ARRAY_DESCRIPTOR), cuArrayDestroy(jcuda.driver.CUarray), cuArrayGetDescriptor(jcuda.driver.CUDA_ARRAY_DESCRIPTOR, jcuda.driver.CUarray), cuMemAlloc(jcuda.driver.CUdeviceptr, long), cuMemAllocHost(jcuda.Pointer, long), cuMemAllocPitch(jcuda.driver.CUdeviceptr, long[], long, long, int), cuMemcpy2D(jcuda.driver.CUDA_MEMCPY2D), cuMemcpy2DAsync(jcuda.driver.CUDA_MEMCPY2D, jcuda.driver.CUstream), cuMemcpy2DUnaligned(jcuda.driver.CUDA_MEMCPY2D), cuMemcpy3D(jcuda.driver.CUDA_MEMCPY3D), cuMemcpy3DAsync(jcuda.driver.CUDA_MEMCPY3D, jcuda.driver.CUstream), cuMemcpyAtoA(jcuda.driver.CUarray, long, jcuda.driver.CUarray, long, long), cuMemcpyAtoD(jcuda.driver.CUdeviceptr, jcuda.driver.CUarray, long, long), cuMemcpyAtoH(jcuda.Pointer, jcuda.driver.CUarray, long, long), cuMemcpyAtoHAsync(jcuda.Pointer, jcuda.driver.CUarray, long, long, jcuda.driver.CUstream), cuMemcpyDtoA(jcuda.driver.CUarray, long, jcuda.driver.CUdeviceptr, long), cuMemcpyDtoD(jcuda.driver.CUdeviceptr, jcuda.driver.CUdeviceptr, long), cuMemcpyDtoDAsync(jcuda.driver.CUdeviceptr, jcuda.driver.CUdeviceptr, long, jcuda.driver.CUstream), cuMemcpyDtoH(jcuda.Pointer, jcuda.driver.CUdeviceptr, long), cuMemcpyDtoHAsync(jcuda.Pointer, jcuda.driver.CUdeviceptr, long, jcuda.driver.CUstream), cuMemcpyHtoA(jcuda.driver.CUarray, long, jcuda.Pointer, long), cuMemcpyHtoAAsync(jcuda.driver.CUarray, long, jcuda.Pointer, long, jcuda.driver.CUstream), cuMemcpyHtoD(jcuda.driver.CUdeviceptr, jcuda.Pointer, long), cuMemFree(jcuda.driver.CUdeviceptr), cuMemFreeHost(jcuda.Pointer), cuMemGetAddressRange(jcuda.driver.CUdeviceptr, long[], jcuda.driver.CUdeviceptr), cuMemGetInfo(long[], long[]), cuMemHostAlloc(jcuda.Pointer, long, int), cuMemHostGetDevicePointer(jcuda.driver.CUdeviceptr, jcuda.Pointer, int), cuMemsetD2D8(jcuda.driver.CUdeviceptr, long, byte, long, long), cuMemsetD2D8Async(jcuda.driver.CUdeviceptr, long, byte, long, long, jcuda.driver.CUstream), cuMemsetD2D16(jcuda.driver.CUdeviceptr, long, short, long, long), cuMemsetD2D16Async(jcuda.driver.CUdeviceptr, long, short, long, long, jcuda.driver.CUstream), cuMemsetD2D32(jcuda.driver.CUdeviceptr, long, int, long, long), cuMemsetD2D32Async(jcuda.driver.CUdeviceptr, long, int, long, long, jcuda.driver.CUstream), cuMemsetD8(jcuda.driver.CUdeviceptr, byte, long), cuMemsetD8Async(jcuda.driver.CUdeviceptr, byte, long, jcuda.driver.CUstream), cuMemsetD16(jcuda.driver.CUdeviceptr, short, long), cuMemsetD16Async(jcuda.driver.CUdeviceptr, short, long, jcuda.driver.CUstream), cuMemsetD32(jcuda.driver.CUdeviceptr, int, long), cuMemsetD32Async(jcuda.driver.CUdeviceptr, int, long, jcuda.driver.CUstream)

cuMemcpyDtoHAsync
```
public static int cuMemcpyDtoHAsync(Pointer dstHost,
                                    CUdeviceptr srcDevice,
                                    long ByteCount,
                                    CUstream hStream)
```
Copies memory from Device to Host.
```
 CUresult cuMemcpyDtoHAsync (
      void* dstHost,
      CUdeviceptr srcDevice,
      size_t ByteCount,
      CUstream hStream )
 
```
Copies memory from Device to Host. Copies from device to host memory. dstHost and srcDevice specify the base pointers of the destination and source, respectively. ByteCount specifies the number of bytes to copy.

cuMemcpyDtoHAsync() is asynchronous and can optionally be associated to a stream by passing a non-zero hStream argument. It only works on page-locked memory and returns an error if a pointer to pageable memory is passed as input.

Note:
Note that this function may also return error codes from previous, asynchronous launches.
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

See Also:

cuArray3DCreate(jcuda.driver.CUarray, jcuda.driver.CUDA_ARRAY3D_DESCRIPTOR), cuArray3DGetDescriptor(jcuda.driver.CUDA_ARRAY3D_DESCRIPTOR, jcuda.driver.CUarray), cuArrayCreate(jcuda.driver.CUarray, jcuda.driver.CUDA_ARRAY_DESCRIPTOR), cuArrayDestroy(jcuda.driver.CUarray), cuArrayGetDescriptor(jcuda.driver.CUDA_ARRAY_DESCRIPTOR, jcuda.driver.CUarray), cuMemAlloc(jcuda.driver.CUdeviceptr, long), cuMemAllocHost(jcuda.Pointer, long), cuMemAllocPitch(jcuda.driver.CUdeviceptr, long[], long, long, int), cuMemcpy2D(jcuda.driver.CUDA_MEMCPY2D), cuMemcpy2DAsync(jcuda.driver.CUDA_MEMCPY2D, jcuda.driver.CUstream), cuMemcpy2DUnaligned(jcuda.driver.CUDA_MEMCPY2D), cuMemcpy3D(jcuda.driver.CUDA_MEMCPY3D), cuMemcpy3DAsync(jcuda.driver.CUDA_MEMCPY3D, jcuda.driver.CUstream), cuMemcpyAtoA(jcuda.driver.CUarray, long, jcuda.driver.CUarray, long, long), cuMemcpyAtoD(jcuda.driver.CUdeviceptr, jcuda.driver.CUarray, long, long), cuMemcpyAtoH(jcuda.Pointer, jcuda.driver.CUarray, long, long), cuMemcpyAtoHAsync(jcuda.Pointer, jcuda.driver.CUarray, long, long, jcuda.driver.CUstream), cuMemcpyDtoA(jcuda.driver.CUarray, long, jcuda.driver.CUdeviceptr, long), cuMemcpyDtoD(jcuda.driver.CUdeviceptr, jcuda.driver.CUdeviceptr, long), cuMemcpyDtoDAsync(jcuda.driver.CUdeviceptr, jcuda.driver.CUdeviceptr, long, jcuda.driver.CUstream), cuMemcpyDtoH(jcuda.Pointer, jcuda.driver.CUdeviceptr, long), cuMemcpyHtoA(jcuda.driver.CUarray, long, jcuda.Pointer, long), cuMemcpyHtoAAsync(jcuda.driver.CUarray, long, jcuda.Pointer, long, jcuda.driver.CUstream), cuMemcpyHtoD(jcuda.driver.CUdeviceptr, jcuda.Pointer, long), cuMemcpyHtoDAsync(jcuda.driver.CUdeviceptr, jcuda.Pointer, long, jcuda.driver.CUstream), cuMemFree(jcuda.driver.CUdeviceptr), cuMemFreeHost(jcuda.Pointer), cuMemGetAddressRange(jcuda.driver.CUdeviceptr, long[], jcuda.driver.CUdeviceptr), cuMemGetInfo(long[], long[]), cuMemHostAlloc(jcuda.Pointer, long, int), cuMemHostGetDevicePointer(jcuda.driver.CUdeviceptr, jcuda.Pointer, int), cuMemsetD2D8(jcuda.driver.CUdeviceptr, long, byte, long, long), cuMemsetD2D8Async(jcuda.driver.CUdeviceptr, long, byte, long, long, jcuda.driver.CUstream), cuMemsetD2D16(jcuda.driver.CUdeviceptr, long, short, long, long), cuMemsetD2D16Async(jcuda.driver.CUdeviceptr, long, short, long, long, jcuda.driver.CUstream), cuMemsetD2D32(jcuda.driver.CUdeviceptr, long, int, long, long), cuMemsetD2D32Async(jcuda.driver.CUdeviceptr, long, int, long, long, jcuda.driver.CUstream), cuMemsetD8(jcuda.driver.CUdeviceptr, byte, long), cuMemsetD8Async(jcuda.driver.CUdeviceptr, byte, long, jcuda.driver.CUstream), cuMemsetD16(jcuda.driver.CUdeviceptr, short, long), cuMemsetD16Async(jcuda.driver.CUdeviceptr, short, long, jcuda.driver.CUstream), cuMemsetD32(jcuda.driver.CUdeviceptr, int, long), cuMemsetD32Async(jcuda.driver.CUdeviceptr, int, long, jcuda.driver.CUstream)

cuMemcpyDtoDAsync
```
public static int cuMemcpyDtoDAsync(CUdeviceptr dstDevice,
                                    CUdeviceptr srcDevice,
                                    long ByteCount,
                                    CUstream hStream)
```
Copies memory from Device to Device.
```
 CUresult cuMemcpyDtoDAsync (
      CUdeviceptr dstDevice,
      CUdeviceptr srcDevice,
      size_t ByteCount,
      CUstream hStream )
 
```
Copies memory from Device to Device. Copies from device memory to device memory. dstDevice and srcDevice are the base pointers of the destination and source, respectively. ByteCount specifies the number of bytes to copy. Note that this function is asynchronous and can optionally be associated to a stream by passing a non-zero hStream argument

Note:
Note that this function may also return error codes from previous, asynchronous launches.
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

See Also:

cuArray3DCreate(jcuda.driver.CUarray, jcuda.driver.CUDA_ARRAY3D_DESCRIPTOR), cuArray3DGetDescriptor(jcuda.driver.CUDA_ARRAY3D_DESCRIPTOR, jcuda.driver.CUarray), cuArrayCreate(jcuda.driver.CUarray, jcuda.driver.CUDA_ARRAY_DESCRIPTOR), cuArrayDestroy(jcuda.driver.CUarray), cuArrayGetDescriptor(jcuda.driver.CUDA_ARRAY_DESCRIPTOR, jcuda.driver.CUarray), cuMemAlloc(jcuda.driver.CUdeviceptr, long), cuMemAllocHost(jcuda.Pointer, long), cuMemAllocPitch(jcuda.driver.CUdeviceptr, long[], long, long, int), cuMemcpy2D(jcuda.driver.CUDA_MEMCPY2D), cuMemcpy2DAsync(jcuda.driver.CUDA_MEMCPY2D, jcuda.driver.CUstream), cuMemcpy2DUnaligned(jcuda.driver.CUDA_MEMCPY2D), cuMemcpy3D(jcuda.driver.CUDA_MEMCPY3D), cuMemcpy3DAsync(jcuda.driver.CUDA_MEMCPY3D, jcuda.driver.CUstream), cuMemcpyAtoA(jcuda.driver.CUarray, long, jcuda.driver.CUarray, long, long), cuMemcpyAtoD(jcuda.driver.CUdeviceptr, jcuda.driver.CUarray, long, long), cuMemcpyAtoH(jcuda.Pointer, jcuda.driver.CUarray, long, long), cuMemcpyAtoHAsync(jcuda.Pointer, jcuda.driver.CUarray, long, long, jcuda.driver.CUstream), cuMemcpyDtoA(jcuda.driver.CUarray, long, jcuda.driver.CUdeviceptr, long), cuMemcpyDtoD(jcuda.driver.CUdeviceptr, jcuda.driver.CUdeviceptr, long), cuMemcpyDtoH(jcuda.Pointer, jcuda.driver.CUdeviceptr, long), cuMemcpyDtoHAsync(jcuda.Pointer, jcuda.driver.CUdeviceptr, long, jcuda.driver.CUstream), cuMemcpyHtoA(jcuda.driver.CUarray, long, jcuda.Pointer, long), cuMemcpyHtoAAsync(jcuda.driver.CUarray, long, jcuda.Pointer, long, jcuda.driver.CUstream), cuMemcpyHtoD(jcuda.driver.CUdeviceptr, jcuda.Pointer, long), cuMemcpyHtoDAsync(jcuda.driver.CUdeviceptr, jcuda.Pointer, long, jcuda.driver.CUstream), cuMemFree(jcuda.driver.CUdeviceptr), cuMemFreeHost(jcuda.Pointer), cuMemGetAddressRange(jcuda.driver.CUdeviceptr, long[], jcuda.driver.CUdeviceptr), cuMemGetInfo(long[], long[]), cuMemHostAlloc(jcuda.Pointer, long, int), cuMemHostGetDevicePointer(jcuda.driver.CUdeviceptr, jcuda.Pointer, int), cuMemsetD2D8(jcuda.driver.CUdeviceptr, long, byte, long, long), cuMemsetD2D8Async(jcuda.driver.CUdeviceptr, long, byte, long, long, jcuda.driver.CUstream), cuMemsetD2D16(jcuda.driver.CUdeviceptr, long, short, long, long), cuMemsetD2D16Async(jcuda.driver.CUdeviceptr, long, short, long, long, jcuda.driver.CUstream), cuMemsetD2D32(jcuda.driver.CUdeviceptr, long, int, long, long), cuMemsetD2D32Async(jcuda.driver.CUdeviceptr, long, int, long, long, jcuda.driver.CUstream), cuMemsetD8(jcuda.driver.CUdeviceptr, byte, long), cuMemsetD8Async(jcuda.driver.CUdeviceptr, byte, long, jcuda.driver.CUstream), cuMemsetD16(jcuda.driver.CUdeviceptr, short, long), cuMemsetD16Async(jcuda.driver.CUdeviceptr, short, long, jcuda.driver.CUstream), cuMemsetD32(jcuda.driver.CUdeviceptr, int, long), cuMemsetD32Async(jcuda.driver.CUdeviceptr, int, long, jcuda.driver.CUstream)

cuMemcpyHtoAAsync
```
public static int cuMemcpyHtoAAsync(CUarray dstArray,
                                    long dstIndex,
                                    Pointer pSrc,
                                    long ByteCount,
                                    CUstream hStream)
```
Copies memory from Host to Array.
```
 CUresult cuMemcpyHtoAAsync (
      CUarray dstArray,
      size_t dstOffset,
      const void* srcHost,
      size_t ByteCount,
      CUstream hStream )
 
```
Copies memory from Host to Array. Copies from host memory to a 1D CUDA array. dstArray and dstOffset specify the CUDA array handle and starting offset in bytes of the destination data. srcHost specifies the base address of the source. ByteCount specifies the number of bytes to copy.

cuMemcpyHtoAAsync() is asynchronous and can optionally be associated to a stream by passing a non-zero hStream argument. It only works on page-locked memory and returns an error if a pointer to pageable memory is passed as input.

Note:
Note that this function may also return error codes from previous, asynchronous launches.
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

See Also:

cuArray3DCreate(jcuda.driver.CUarray, jcuda.driver.CUDA_ARRAY3D_DESCRIPTOR), cuArray3DGetDescriptor(jcuda.driver.CUDA_ARRAY3D_DESCRIPTOR, jcuda.driver.CUarray), cuArrayCreate(jcuda.driver.CUarray, jcuda.driver.CUDA_ARRAY_DESCRIPTOR), cuArrayDestroy(jcuda.driver.CUarray), cuArrayGetDescriptor(jcuda.driver.CUDA_ARRAY_DESCRIPTOR, jcuda.driver.CUarray), cuMemAlloc(jcuda.driver.CUdeviceptr, long), cuMemAllocHost(jcuda.Pointer, long), cuMemAllocPitch(jcuda.driver.CUdeviceptr, long[], long, long, int), cuMemcpy2D(jcuda.driver.CUDA_MEMCPY2D), cuMemcpy2DAsync(jcuda.driver.CUDA_MEMCPY2D, jcuda.driver.CUstream), cuMemcpy2DUnaligned(jcuda.driver.CUDA_MEMCPY2D), cuMemcpy3D(jcuda.driver.CUDA_MEMCPY3D), cuMemcpy3DAsync(jcuda.driver.CUDA_MEMCPY3D, jcuda.driver.CUstream), cuMemcpyAtoA(jcuda.driver.CUarray, long, jcuda.driver.CUarray, long, long), cuMemcpyAtoD(jcuda.driver.CUdeviceptr, jcuda.driver.CUarray, long, long), cuMemcpyAtoH(jcuda.Pointer, jcuda.driver.CUarray, long, long), cuMemcpyAtoHAsync(jcuda.Pointer, jcuda.driver.CUarray, long, long, jcuda.driver.CUstream), cuMemcpyDtoA(jcuda.driver.CUarray, long, jcuda.driver.CUdeviceptr, long), cuMemcpyDtoD(jcuda.driver.CUdeviceptr, jcuda.driver.CUdeviceptr, long), cuMemcpyDtoDAsync(jcuda.driver.CUdeviceptr, jcuda.driver.CUdeviceptr, long, jcuda.driver.CUstream), cuMemcpyDtoH(jcuda.Pointer, jcuda.driver.CUdeviceptr, long), cuMemcpyDtoHAsync(jcuda.Pointer, jcuda.driver.CUdeviceptr, long, jcuda.driver.CUstream), cuMemcpyHtoA(jcuda.driver.CUarray, long, jcuda.Pointer, long), cuMemcpyHtoD(jcuda.driver.CUdeviceptr, jcuda.Pointer, long), cuMemcpyHtoDAsync(jcuda.driver.CUdeviceptr, jcuda.Pointer, long, jcuda.driver.CUstream), cuMemFree(jcuda.driver.CUdeviceptr), cuMemFreeHost(jcuda.Pointer), cuMemGetAddressRange(jcuda.driver.CUdeviceptr, long[], jcuda.driver.CUdeviceptr), cuMemGetInfo(long[], long[]), cuMemHostAlloc(jcuda.Pointer, long, int), cuMemHostGetDevicePointer(jcuda.driver.CUdeviceptr, jcuda.Pointer, int), cuMemsetD2D8(jcuda.driver.CUdeviceptr, long, byte, long, long), cuMemsetD2D8Async(jcuda.driver.CUdeviceptr, long, byte, long, long, jcuda.driver.CUstream), cuMemsetD2D16(jcuda.driver.CUdeviceptr, long, short, long, long), cuMemsetD2D16Async(jcuda.driver.CUdeviceptr, long, short, long, long, jcuda.driver.CUstream), cuMemsetD2D32(jcuda.driver.CUdeviceptr, long, int, long, long), cuMemsetD2D32Async(jcuda.driver.CUdeviceptr, long, int, long, long, jcuda.driver.CUstream), cuMemsetD8(jcuda.driver.CUdeviceptr, byte, long), cuMemsetD8Async(jcuda.driver.CUdeviceptr, byte, long, jcuda.driver.CUstream), cuMemsetD16(jcuda.driver.CUdeviceptr, short, long), cuMemsetD16Async(jcuda.driver.CUdeviceptr, short, long, jcuda.driver.CUstream), cuMemsetD32(jcuda.driver.CUdeviceptr, int, long), cuMemsetD32Async(jcuda.driver.CUdeviceptr, int, long, jcuda.driver.CUstream)

cuMemcpyAtoHAsync
```
public static int cuMemcpyAtoHAsync(Pointer dstHost,
                                    CUarray srcArray,
                                    long srcIndex,
                                    long ByteCount,
                                    CUstream hStream)
```
Copies memory from Array to Host.
```
 CUresult cuMemcpyAtoHAsync (
      void* dstHost,
      CUarray srcArray,
      size_t srcOffset,
      size_t ByteCount,
      CUstream hStream )
 
```
Copies memory from Array to Host. Copies from one 1D CUDA array to host memory. dstHost specifies the base pointer of the destination. srcArray and srcOffset specify the CUDA array handle and starting offset in bytes of the source data. ByteCount specifies the number of bytes to copy.

cuMemcpyAtoHAsync() is asynchronous and can optionally be associated to a stream by passing a non-zero stream argument. It only works on page-locked host memory and returns an error if a pointer to pageable memory is passed as input.

Note:
Note that this function may also return error codes from previous, asynchronous launches.
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

See Also:

cuArray3DCreate(jcuda.driver.CUarray, jcuda.driver.CUDA_ARRAY3D_DESCRIPTOR), cuArray3DGetDescriptor(jcuda.driver.CUDA_ARRAY3D_DESCRIPTOR, jcuda.driver.CUarray), cuArrayCreate(jcuda.driver.CUarray, jcuda.driver.CUDA_ARRAY_DESCRIPTOR), cuArrayDestroy(jcuda.driver.CUarray), cuArrayGetDescriptor(jcuda.driver.CUDA_ARRAY_DESCRIPTOR, jcuda.driver.CUarray), cuMemAlloc(jcuda.driver.CUdeviceptr, long), cuMemAllocHost(jcuda.Pointer, long), cuMemAllocPitch(jcuda.driver.CUdeviceptr, long[], long, long, int), cuMemcpy2D(jcuda.driver.CUDA_MEMCPY2D), cuMemcpy2DAsync(jcuda.driver.CUDA_MEMCPY2D, jcuda.driver.CUstream), cuMemcpy2DUnaligned(jcuda.driver.CUDA_MEMCPY2D), cuMemcpy3D(jcuda.driver.CUDA_MEMCPY3D), cuMemcpy3DAsync(jcuda.driver.CUDA_MEMCPY3D, jcuda.driver.CUstream), cuMemcpyAtoA(jcuda.driver.CUarray, long, jcuda.driver.CUarray, long, long), cuMemcpyAtoD(jcuda.driver.CUdeviceptr, jcuda.driver.CUarray, long, long), cuMemcpyAtoH(jcuda.Pointer, jcuda.driver.CUarray, long, long), cuMemcpyDtoA(jcuda.driver.CUarray, long, jcuda.driver.CUdeviceptr, long), cuMemcpyDtoD(jcuda.driver.CUdeviceptr, jcuda.driver.CUdeviceptr, long), cuMemcpyDtoDAsync(jcuda.driver.CUdeviceptr, jcuda.driver.CUdeviceptr, long, jcuda.driver.CUstream), cuMemcpyDtoH(jcuda.Pointer, jcuda.driver.CUdeviceptr, long), cuMemcpyDtoHAsync(jcuda.Pointer, jcuda.driver.CUdeviceptr, long, jcuda.driver.CUstream), cuMemcpyHtoA(jcuda.driver.CUarray, long, jcuda.Pointer, long), cuMemcpyHtoAAsync(jcuda.driver.CUarray, long, jcuda.Pointer, long, jcuda.driver.CUstream), cuMemcpyHtoD(jcuda.driver.CUdeviceptr, jcuda.Pointer, long), cuMemcpyHtoDAsync(jcuda.driver.CUdeviceptr, jcuda.Pointer, long, jcuda.driver.CUstream), cuMemFree(jcuda.driver.CUdeviceptr), cuMemFreeHost(jcuda.Pointer), cuMemGetAddressRange(jcuda.driver.CUdeviceptr, long[], jcuda.driver.CUdeviceptr), cuMemGetInfo(long[], long[]), cuMemHostAlloc(jcuda.Pointer, long, int), cuMemHostGetDevicePointer(jcuda.driver.CUdeviceptr, jcuda.Pointer, int), cuMemsetD2D8(jcuda.driver.CUdeviceptr, long, byte, long, long), cuMemsetD2D8Async(jcuda.driver.CUdeviceptr, long, byte, long, long, jcuda.driver.CUstream), cuMemsetD2D16(jcuda.driver.CUdeviceptr, long, short, long, long), cuMemsetD2D16Async(jcuda.driver.CUdeviceptr, long, short, long, long, jcuda.driver.CUstream), cuMemsetD2D32(jcuda.driver.CUdeviceptr, long, int, long, long), cuMemsetD2D32Async(jcuda.driver.CUdeviceptr, long, int, long, long, jcuda.driver.CUstream), cuMemsetD8(jcuda.driver.CUdeviceptr, byte, long), cuMemsetD8Async(jcuda.driver.CUdeviceptr, byte, long, jcuda.driver.CUstream), cuMemsetD16(jcuda.driver.CUdeviceptr, short, long), cuMemsetD16Async(jcuda.driver.CUdeviceptr, short, long, jcuda.driver.CUstream), cuMemsetD32(jcuda.driver.CUdeviceptr, int, long), cuMemsetD32Async(jcuda.driver.CUdeviceptr, int, long, jcuda.driver.CUstream)

cuMemcpy2DAsync
```
public static int cuMemcpy2DAsync(CUDA_MEMCPY2D pCopy,
                                  CUstream hStream)
```
Copies memory for 2D arrays.
```
 CUresult cuMemcpy2DAsync (
      const CUDA_MEMCPY2D* pCopy,
      CUstream hStream )
 
```
Copies memory for 2D arrays. Perform a 2D memory copy according to the parameters specified in 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;
```
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.

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.

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.

If srcMemoryType is CU_MEMORYTYPE_ARRAY, srcArray specifies the handle of the source data. srcHost, srcDevice and srcPitch are ignored.

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.

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.

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.

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.
For host pointers, the starting address is
```
  void* Start = (void*)((char*)srcHost+srcY*srcPitch +
 srcXInBytes);
```
For device pointers, the starting address is
```
  CUdeviceptr Start =
 srcDevice+srcY*srcPitch+srcXInBytes;
```
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.
For host pointers, the base address is
```
  void* dstStart = (void*)((char*)dstHost+dstY*dstPitch +
 dstXInBytes);
```
For device pointers, the starting address is
```
  CUdeviceptr dstStart =
 dstDevice+dstY*dstPitch+dstXInBytes;
```
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.
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.

cuMemcpy2DAsync() is asynchronous and can optionally be associated to a stream by passing a non-zero hStream argument. It only works on page-locked host memory and returns an error if a pointer to pageable memory is passed as input.

Note:
Note that this function may also return error codes from previous, asynchronous launches.
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

See Also:

cuArray3DCreate(jcuda.driver.CUarray, jcuda.driver.CUDA_ARRAY3D_DESCRIPTOR), cuArray3DGetDescriptor(jcuda.driver.CUDA_ARRAY3D_DESCRIPTOR, jcuda.driver.CUarray), cuArrayCreate(jcuda.driver.CUarray, jcuda.driver.CUDA_ARRAY_DESCRIPTOR), cuArrayDestroy(jcuda.driver.CUarray), cuArrayGetDescriptor(jcuda.driver.CUDA_ARRAY_DESCRIPTOR, jcuda.driver.CUarray), cuMemAlloc(jcuda.driver.CUdeviceptr, long), cuMemAllocHost(jcuda.Pointer, long), cuMemAllocPitch(jcuda.driver.CUdeviceptr, long[], long, long, int), cuMemcpy2D(jcuda.driver.CUDA_MEMCPY2D), cuMemcpy2DUnaligned(jcuda.driver.CUDA_MEMCPY2D), cuMemcpy3D(jcuda.driver.CUDA_MEMCPY3D), cuMemcpy3DAsync(jcuda.driver.CUDA_MEMCPY3D, jcuda.driver.CUstream), cuMemcpyAtoA(jcuda.driver.CUarray, long, jcuda.driver.CUarray, long, long), cuMemcpyAtoD(jcuda.driver.CUdeviceptr, jcuda.driver.CUarray, long, long), cuMemcpyAtoH(jcuda.Pointer, jcuda.driver.CUarray, long, long), cuMemcpyAtoHAsync(jcuda.Pointer, jcuda.driver.CUarray, long, long, jcuda.driver.CUstream), cuMemcpyDtoA(jcuda.driver.CUarray, long, jcuda.driver.CUdeviceptr, long), cuMemcpyDtoD(jcuda.driver.CUdeviceptr, jcuda.driver.CUdeviceptr, long), cuMemcpyDtoDAsync(jcuda.driver.CUdeviceptr, jcuda.driver.CUdeviceptr, long, jcuda.driver.CUstream), cuMemcpyDtoH(jcuda.Pointer, jcuda.driver.CUdeviceptr, long), cuMemcpyDtoHAsync(jcuda.Pointer, jcuda.driver.CUdeviceptr, long, jcuda.driver.CUstream), cuMemcpyHtoA(jcuda.driver.CUarray, long, jcuda.Pointer, long), cuMemcpyHtoAAsync(jcuda.driver.CUarray, long, jcuda.Pointer, long, jcuda.driver.CUstream), cuMemcpyHtoD(jcuda.driver.CUdeviceptr, jcuda.Pointer, long), cuMemcpyHtoDAsync(jcuda.driver.CUdeviceptr, jcuda.Pointer, long, jcuda.driver.CUstream), cuMemFree(jcuda.driver.CUdeviceptr), cuMemFreeHost(jcuda.Pointer), cuMemGetAddressRange(jcuda.driver.CUdeviceptr, long[], jcuda.driver.CUdeviceptr), cuMemGetInfo(long[], long[]), cuMemHostAlloc(jcuda.Pointer, long, int), cuMemHostGetDevicePointer(jcuda.driver.CUdeviceptr, jcuda.Pointer, int), cuMemsetD2D8(jcuda.driver.CUdeviceptr, long, byte, long, long), cuMemsetD2D8Async(jcuda.driver.CUdeviceptr, long, byte, long, long, jcuda.driver.CUstream), cuMemsetD2D16(jcuda.driver.CUdeviceptr, long, short, long, long), cuMemsetD2D16Async(jcuda.driver.CUdeviceptr, long, short, long, long, jcuda.driver.CUstream), cuMemsetD2D32(jcuda.driver.CUdeviceptr, long, int, long, long), cuMemsetD2D32Async(jcuda.driver.CUdeviceptr, long, int, long, long, jcuda.driver.CUstream), cuMemsetD8(jcuda.driver.CUdeviceptr, byte, long), cuMemsetD8Async(jcuda.driver.CUdeviceptr, byte, long, jcuda.driver.CUstream), cuMemsetD16(jcuda.driver.CUdeviceptr, short, long), cuMemsetD16Async(jcuda.driver.CUdeviceptr, short, long, jcuda.driver.CUstream), cuMemsetD32(jcuda.driver.CUdeviceptr, int, long), cuMemsetD32Async(jcuda.driver.CUdeviceptr, int, long, jcuda.driver.CUstream)

cuMemcpy3DAsync
```
public static int cuMemcpy3DAsync(CUDA_MEMCPY3D pCopy,
                                  CUstream hStream)
```
Copies memory for 3D arrays.
```
 CUresult cuMemcpy3DAsync (
      const CUDA_MEMCPY3D* pCopy,
      CUstream hStream )
 
```
Copies memory for 3D arrays. Perform a 3D memory copy according to the parameters specified in 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;
```
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.

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.

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.

If srcMemoryType is CU_MEMORYTYPE_ARRAY, srcArray specifies the handle of the source data. srcHost, srcDevice, srcPitch and srcHeight are ignored.

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.

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.

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.

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.
For host pointers, the starting address is
```
  void* Start = (void*)((char*)srcHost+(srcZ*srcHeight+srcY)*srcPitch
 + srcXInBytes);
```
For device pointers, the starting address is
```
  CUdeviceptr Start =
 srcDevice+(srcZ*srcHeight+srcY)*srcPitch+srcXInBytes;
```
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.
For host pointers, the base address is
```
  void* dstStart = (void*)((char*)dstHost+(dstZ*dstHeight+dstY)*dstPitch
 + dstXInBytes);
```
For device pointers, the starting address is
```
  CUdeviceptr dstStart =
 dstDevice+(dstZ*dstHeight+dstY)*dstPitch+dstXInBytes;
```
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.
cuMemcpy3D() returns an error if any pitch is greater than the maximum allowed (CU_DEVICE_ATTRIBUTE_MAX_PITCH).

cuMemcpy3DAsync() is asynchronous and can optionally be associated to a stream by passing a non-zero hStream argument. It only works on page-locked host memory and returns an error if a pointer to pageable memory is passed as input.

The srcLOD and dstLOD members of the CUDA_MEMCPY3D structure must be set to 0.

Note:
Note that this function may also return error codes from previous, asynchronous launches.
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

See Also:

cuArray3DCreate(jcuda.driver.CUarray, jcuda.driver.CUDA_ARRAY3D_DESCRIPTOR), cuArray3DGetDescriptor(jcuda.driver.CUDA_ARRAY3D_DESCRIPTOR, jcuda.driver.CUarray), cuArrayCreate(jcuda.driver.CUarray, jcuda.driver.CUDA_ARRAY_DESCRIPTOR), cuArrayDestroy(jcuda.driver.CUarray), cuArrayGetDescriptor(jcuda.driver.CUDA_ARRAY_DESCRIPTOR, jcuda.driver.CUarray), cuMemAlloc(jcuda.driver.CUdeviceptr, long), cuMemAllocHost(jcuda.Pointer, long), cuMemAllocPitch(jcuda.driver.CUdeviceptr, long[], long, long, int), cuMemcpy2D(jcuda.driver.CUDA_MEMCPY2D), cuMemcpy2DAsync(jcuda.driver.CUDA_MEMCPY2D, jcuda.driver.CUstream), cuMemcpy2DUnaligned(jcuda.driver.CUDA_MEMCPY2D), cuMemcpy3D(jcuda.driver.CUDA_MEMCPY3D), cuMemcpyAtoA(jcuda.driver.CUarray, long, jcuda.driver.CUarray, long, long), cuMemcpyAtoD(jcuda.driver.CUdeviceptr, jcuda.driver.CUarray, long, long), cuMemcpyAtoH(jcuda.Pointer, jcuda.driver.CUarray, long, long), cuMemcpyAtoHAsync(jcuda.Pointer, jcuda.driver.CUarray, long, long, jcuda.driver.CUstream), cuMemcpyDtoA(jcuda.driver.CUarray, long, jcuda.driver.CUdeviceptr, long), cuMemcpyDtoD(jcuda.driver.CUdeviceptr, jcuda.driver.CUdeviceptr, long), cuMemcpyDtoDAsync(jcuda.driver.CUdeviceptr, jcuda.driver.CUdeviceptr, long, jcuda.driver.CUstream), cuMemcpyDtoH(jcuda.Pointer, jcuda.driver.CUdeviceptr, long), cuMemcpyDtoHAsync(jcuda.Pointer, jcuda.driver.CUdeviceptr, long, jcuda.driver.CUstream), cuMemcpyHtoA(jcuda.driver.CUarray, long, jcuda.Pointer, long), cuMemcpyHtoAAsync(jcuda.driver.CUarray, long, jcuda.Pointer, long, jcuda.driver.CUstream), cuMemcpyHtoD(jcuda.driver.CUdeviceptr, jcuda.Pointer, long), cuMemcpyHtoDAsync(jcuda.driver.CUdeviceptr, jcuda.Pointer, long, jcuda.driver.CUstream), cuMemFree(jcuda.driver.CUdeviceptr), cuMemFreeHost(jcuda.Pointer), cuMemGetAddressRange(jcuda.driver.CUdeviceptr, long[], jcuda.driver.CUdeviceptr), cuMemGetInfo(long[], long[]), cuMemHostAlloc(jcuda.Pointer, long, int), cuMemHostGetDevicePointer(jcuda.driver.CUdeviceptr, jcuda.Pointer, int), cuMemsetD2D8(jcuda.driver.CUdeviceptr, long, byte, long, long), cuMemsetD2D8Async(jcuda.driver.CUdeviceptr, long, byte, long, long, jcuda.driver.CUstream), cuMemsetD2D16(jcuda.driver.CUdeviceptr, long, short, long, long), cuMemsetD2D16Async(jcuda.driver.CUdeviceptr, long, short, long, long, jcuda.driver.CUstream), cuMemsetD2D32(jcuda.driver.CUdeviceptr, long, int, long, long), cuMemsetD2D32Async(jcuda.driver.CUdeviceptr, long, int, long, long, jcuda.driver.CUstream), cuMemsetD8(jcuda.driver.CUdeviceptr, byte, long), cuMemsetD8Async(jcuda.driver.CUdeviceptr, byte, long, jcuda.driver.CUstream), cuMemsetD16(jcuda.driver.CUdeviceptr, short, long), cuMemsetD16Async(jcuda.driver.CUdeviceptr, short, long, jcuda.driver.CUstream), cuMemsetD32(jcuda.driver.CUdeviceptr, int, long), cuMemsetD32Async(jcuda.driver.CUdeviceptr, int, long, jcuda.driver.CUstream)

cuMemcpy3DPeerAsync
```
public static int cuMemcpy3DPeerAsync(CUDA_MEMCPY3D_PEER pCopy,
                                      CUstream hStream)
```
Copies memory between contexts asynchronously.
```
 CUresult cuMemcpy3DPeerAsync (
      const CUDA_MEMCPY3D_PEER* pCopy,
      CUstream hStream )
 
```
Copies memory between contexts asynchronously. Perform a 3D memory copy according to the parameters specified in pCopy. See the definition of the CUDA_MEMCPY3D_PEER structure for documentation of its parameters.

Note:
Note that this function may also return error codes from previous, asynchronous launches.
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

See Also:

cuMemcpyDtoD(jcuda.driver.CUdeviceptr, jcuda.driver.CUdeviceptr, long), cuMemcpyPeer(jcuda.driver.CUdeviceptr, jcuda.driver.CUcontext, jcuda.driver.CUdeviceptr, jcuda.driver.CUcontext, long), cuMemcpyDtoDAsync(jcuda.driver.CUdeviceptr, jcuda.driver.CUdeviceptr, long, jcuda.driver.CUstream), cuMemcpyPeerAsync(jcuda.driver.CUdeviceptr, jcuda.driver.CUcontext, jcuda.driver.CUdeviceptr, jcuda.driver.CUcontext, long, jcuda.driver.CUstream), cuMemcpy3DPeerAsync(jcuda.driver.CUDA_MEMCPY3D_PEER, jcuda.driver.CUstream)

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

Note that this function is asynchronous with respect to the host unless dstDevice refers to pinned host memory.

Note:
Note that this function may also return error codes from previous, asynchronous launches.
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

See Also:

cuArray3DCreate(jcuda.driver.CUarray, jcuda.driver.CUDA_ARRAY3D_DESCRIPTOR), cuArray3DGetDescriptor(jcuda.driver.CUDA_ARRAY3D_DESCRIPTOR, jcuda.driver.CUarray), cuArrayCreate(jcuda.driver.CUarray, jcuda.driver.CUDA_ARRAY_DESCRIPTOR), cuArrayDestroy(jcuda.driver.CUarray), cuArrayGetDescriptor(jcuda.driver.CUDA_ARRAY_DESCRIPTOR, jcuda.driver.CUarray), cuMemAlloc(jcuda.driver.CUdeviceptr, long), cuMemAllocHost(jcuda.Pointer, long), cuMemAllocPitch(jcuda.driver.CUdeviceptr, long[], long, long, int), cuMemcpy2D(jcuda.driver.CUDA_MEMCPY2D), cuMemcpy2DAsync(jcuda.driver.CUDA_MEMCPY2D, jcuda.driver.CUstream), cuMemcpy2DUnaligned(jcuda.driver.CUDA_MEMCPY2D), cuMemcpy3D(jcuda.driver.CUDA_MEMCPY3D), cuMemcpy3DAsync(jcuda.driver.CUDA_MEMCPY3D, jcuda.driver.CUstream), cuMemcpyAtoA(jcuda.driver.CUarray, long, jcuda.driver.CUarray, long, long), cuMemcpyAtoD(jcuda.driver.CUdeviceptr, jcuda.driver.CUarray, long, long), cuMemcpyAtoH(jcuda.Pointer, jcuda.driver.CUarray, long, long), cuMemcpyAtoHAsync(jcuda.Pointer, jcuda.driver.CUarray, long, long, jcuda.driver.CUstream), cuMemcpyDtoA(jcuda.driver.CUarray, long, jcuda.driver.CUdeviceptr, long), cuMemcpyDtoD(jcuda.driver.CUdeviceptr, jcuda.driver.CUdeviceptr, long), cuMemcpyDtoDAsync(jcuda.driver.CUdeviceptr, jcuda.driver.CUdeviceptr, long, jcuda.driver.CUstream), cuMemcpyDtoH(jcuda.Pointer, jcuda.driver.CUdeviceptr, long), cuMemcpyDtoHAsync(jcuda.Pointer, jcuda.driver.CUdeviceptr, long, jcuda.driver.CUstream), cuMemcpyHtoA(jcuda.driver.CUarray, long, jcuda.Pointer, long), cuMemcpyHtoAAsync(jcuda.driver.CUarray, long, jcuda.Pointer, long, jcuda.driver.CUstream), cuMemcpyHtoD(jcuda.driver.CUdeviceptr, jcuda.Pointer, long), cuMemcpyHtoDAsync(jcuda.driver.CUdeviceptr, jcuda.Pointer, long, jcuda.driver.CUstream), cuMemFree(jcuda.driver.CUdeviceptr), cuMemFreeHost(jcuda.Pointer), cuMemGetAddressRange(jcuda.driver.CUdeviceptr, long[], jcuda.driver.CUdeviceptr), cuMemGetInfo(long[], long[]), cuMemHostAlloc(jcuda.Pointer, long, int), cuMemHostGetDevicePointer(jcuda.driver.CUdeviceptr, jcuda.Pointer, int), cuMemsetD2D8(jcuda.driver.CUdeviceptr, long, byte, long, long), cuMemsetD2D8Async(jcuda.driver.CUdeviceptr, long, byte, long, long, jcuda.driver.CUstream), cuMemsetD2D16(jcuda.driver.CUdeviceptr, long, short, long, long), cuMemsetD2D16Async(jcuda.driver.CUdeviceptr, long, short, long, long, jcuda.driver.CUstream), cuMemsetD2D32(jcuda.driver.CUdeviceptr, long, int, long, long), cuMemsetD2D32Async(jcuda.driver.CUdeviceptr, long, int, long, long, jcuda.driver.CUstream), cuMemsetD8Async(jcuda.driver.CUdeviceptr, byte, long, jcuda.driver.CUstream), cuMemsetD16(jcuda.driver.CUdeviceptr, short, long), cuMemsetD16Async(jcuda.driver.CUdeviceptr, short, long, jcuda.driver.CUstream), cuMemsetD32(jcuda.driver.CUdeviceptr, int, long), cuMemsetD32Async(jcuda.driver.CUdeviceptr, int, long, jcuda.driver.CUstream)

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

Note that this function is asynchronous with respect to the host unless dstDevice refers to pinned host memory.

Note:
Note that this function may also return error codes from previous, asynchronous launches.
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

See Also:

cuArray3DCreate(jcuda.driver.CUarray, jcuda.driver.CUDA_ARRAY3D_DESCRIPTOR), cuArray3DGetDescriptor(jcuda.driver.CUDA_ARRAY3D_DESCRIPTOR, jcuda.driver.CUarray), cuArrayCreate(jcuda.driver.CUarray, jcuda.driver.CUDA_ARRAY_DESCRIPTOR), cuArrayDestroy(jcuda.driver.CUarray), cuArrayGetDescriptor(jcuda.driver.CUDA_ARRAY_DESCRIPTOR, jcuda.driver.CUarray), cuMemAlloc(jcuda.driver.CUdeviceptr, long), cuMemAllocHost(jcuda.Pointer, long), cuMemAllocPitch(jcuda.driver.CUdeviceptr, long[], long, long, int), cuMemcpy2D(jcuda.driver.CUDA_MEMCPY2D), cuMemcpy2DAsync(jcuda.driver.CUDA_MEMCPY2D, jcuda.driver.CUstream), cuMemcpy2DUnaligned(jcuda.driver.CUDA_MEMCPY2D), cuMemcpy3D(jcuda.driver.CUDA_MEMCPY3D), cuMemcpy3DAsync(jcuda.driver.CUDA_MEMCPY3D, jcuda.driver.CUstream), cuMemcpyAtoA(jcuda.driver.CUarray, long, jcuda.driver.CUarray, long, long), cuMemcpyAtoD(jcuda.driver.CUdeviceptr, jcuda.driver.CUarray, long, long), cuMemcpyAtoH(jcuda.Pointer, jcuda.driver.CUarray, long, long), cuMemcpyAtoHAsync(jcuda.Pointer, jcuda.driver.CUarray, long, long, jcuda.driver.CUstream), cuMemcpyDtoA(jcuda.driver.CUarray, long, jcuda.driver.CUdeviceptr, long), cuMemcpyDtoD(jcuda.driver.CUdeviceptr, jcuda.driver.CUdeviceptr, long), cuMemcpyDtoDAsync(jcuda.driver.CUdeviceptr, jcuda.driver.CUdeviceptr, long, jcuda.driver.CUstream), cuMemcpyDtoH(jcuda.Pointer, jcuda.driver.CUdeviceptr, long), cuMemcpyDtoHAsync(jcuda.Pointer, jcuda.driver.CUdeviceptr, long, jcuda.driver.CUstream), cuMemcpyHtoA(jcuda.driver.CUarray, long, jcuda.Pointer, long), cuMemcpyHtoAAsync(jcuda.driver.CUarray, long, jcuda.Pointer, long, jcuda.driver.CUstream), cuMemcpyHtoD(jcuda.driver.CUdeviceptr, jcuda.Pointer, long), cuMemcpyHtoDAsync(jcuda.driver.CUdeviceptr, jcuda.Pointer, long, jcuda.driver.CUstream), cuMemFree(jcuda.driver.CUdeviceptr), cuMemFreeHost(jcuda.Pointer), cuMemGetAddressRange(jcuda.driver.CUdeviceptr, long[], jcuda.driver.CUdeviceptr), cuMemGetInfo(long[], long[]), cuMemHostAlloc(jcuda.Pointer, long, int), cuMemHostGetDevicePointer(jcuda.driver.CUdeviceptr, jcuda.Pointer, int), cuMemsetD2D8(jcuda.driver.CUdeviceptr, long, byte, long, long), cuMemsetD2D8Async(jcuda.driver.CUdeviceptr, long, byte, long, long, jcuda.driver.CUstream), cuMemsetD2D16(jcuda.driver.CUdeviceptr, long, short, long, long), cuMemsetD2D16Async(jcuda.driver.CUdeviceptr, long, short, long, long, jcuda.driver.CUstream), cuMemsetD2D32(jcuda.driver.CUdeviceptr, long, int, long, long), cuMemsetD2D32Async(jcuda.driver.CUdeviceptr, long, int, long, long, jcuda.driver.CUstream), cuMemsetD8(jcuda.driver.CUdeviceptr, byte, long), cuMemsetD8Async(jcuda.driver.CUdeviceptr, byte, long, jcuda.driver.CUstream), cuMemsetD16Async(jcuda.driver.CUdeviceptr, short, long, jcuda.driver.CUstream), cuMemsetD32(jcuda.driver.CUdeviceptr, int, long), cuMemsetD32Async(jcuda.driver.CUdeviceptr, int, long, jcuda.driver.CUstream)

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

Note that this function is asynchronous with respect to the host unless dstDevice refers to pinned host memory.

Note:
Note that this function may also return error codes from previous, asynchronous launches.
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

See Also:

cuArray3DCreate(jcuda.driver.CUarray, jcuda.driver.CUDA_ARRAY3D_DESCRIPTOR), cuArray3DGetDescriptor(jcuda.driver.CUDA_ARRAY3D_DESCRIPTOR, jcuda.driver.CUarray), cuArrayCreate(jcuda.driver.CUarray, jcuda.driver.CUDA_ARRAY_DESCRIPTOR), cuArrayDestroy(jcuda.driver.CUarray), cuArrayGetDescriptor(jcuda.driver.CUDA_ARRAY_DESCRIPTOR, jcuda.driver.CUarray), cuMemAlloc(jcuda.driver.CUdeviceptr, long), cuMemAllocHost(jcuda.Pointer, long), cuMemAllocPitch(jcuda.driver.CUdeviceptr, long[], long, long, int), cuMemcpy2D(jcuda.driver.CUDA_MEMCPY2D), cuMemcpy2DAsync(jcuda.driver.CUDA_MEMCPY2D, jcuda.driver.CUstream), cuMemcpy2DUnaligned(jcuda.driver.CUDA_MEMCPY2D), cuMemcpy3D(jcuda.driver.CUDA_MEMCPY3D), cuMemcpy3DAsync(jcuda.driver.CUDA_MEMCPY3D, jcuda.driver.CUstream), cuMemcpyAtoA(jcuda.driver.CUarray, long, jcuda.driver.CUarray, long, long), cuMemcpyAtoD(jcuda.driver.CUdeviceptr, jcuda.driver.CUarray, long, long), cuMemcpyAtoH(jcuda.Pointer, jcuda.driver.CUarray, long, long), cuMemcpyAtoHAsync(jcuda.Pointer, jcuda.driver.CUarray, long, long, jcuda.driver.CUstream), cuMemcpyDtoA(jcuda.driver.CUarray, long, jcuda.driver.CUdeviceptr, long), cuMemcpyDtoD(jcuda.driver.CUdeviceptr, jcuda.driver.CUdeviceptr, long), cuMemcpyDtoDAsync(jcuda.driver.CUdeviceptr, jcuda.driver.CUdeviceptr, long, jcuda.driver.CUstream), cuMemcpyDtoH(jcuda.Pointer, jcuda.driver.CUdeviceptr, long), cuMemcpyDtoHAsync(jcuda.Pointer, jcuda.driver.CUdeviceptr, long, jcuda.driver.CUstream), cuMemcpyHtoA(jcuda.driver.CUarray, long, jcuda.Pointer, long), cuMemcpyHtoAAsync(jcuda.driver.CUarray, long, jcuda.Pointer, long, jcuda.driver.CUstream), cuMemcpyHtoD(jcuda.driver.CUdeviceptr, jcuda.Pointer, long), cuMemcpyHtoDAsync(jcuda.driver.CUdeviceptr, jcuda.Pointer, long, jcuda.driver.CUstream), cuMemFree(jcuda.driver.CUdeviceptr), cuMemFreeHost(jcuda.Pointer), cuMemGetAddressRange(jcuda.driver.CUdeviceptr, long[], jcuda.driver.CUdeviceptr), cuMemGetInfo(long[], long[]), cuMemHostAlloc(jcuda.Pointer, long, int), cuMemHostGetDevicePointer(jcuda.driver.CUdeviceptr, jcuda.Pointer, int), cuMemsetD2D8(jcuda.driver.CUdeviceptr, long, byte, long, long), cuMemsetD2D8Async(jcuda.driver.CUdeviceptr, long, byte, long, long, jcuda.driver.CUstream), cuMemsetD2D16(jcuda.driver.CUdeviceptr, long, short, long, long), cuMemsetD2D16Async(jcuda.driver.CUdeviceptr, long, short, long, long, jcuda.driver.CUstream), cuMemsetD2D32(jcuda.driver.CUdeviceptr, long, int, long, long), cuMemsetD2D32Async(jcuda.driver.CUdeviceptr, long, int, long, long, jcuda.driver.CUstream), cuMemsetD8(jcuda.driver.CUdeviceptr, byte, long), cuMemsetD8Async(jcuda.driver.CUdeviceptr, byte, long, jcuda.driver.CUstream), cuMemsetD16(jcuda.driver.CUdeviceptr, short, long), cuMemsetD16Async(jcuda.driver.CUdeviceptr, short, long, jcuda.driver.CUstream), cuMemsetD32Async(jcuda.driver.CUdeviceptr, int, long, jcuda.driver.CUstream)

cuMemsetD2D8
```
public static int cuMemsetD2D8(CUdeviceptr dstDevice,
                               long dstPitch,
                               byte uc,
                               long Width,
                               long Height)
```
Initializes device memory.
```
 CUresult cuMemsetD2D8 (
      CUdeviceptr dstDevice,
      size_t dstPitch,
      unsigned char  uc,
      size_t Width,
      size_t Height )
 
```
Initializes device memory. Sets the 2D memory range of Width 8-bit values to the specified value uc. Height specifies the number of rows to set, and 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().

Note that this function is asynchronous with respect to the host unless dstDevice refers to pinned host memory.

Note:
Note that this function may also return error codes from previous, asynchronous launches.
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

See Also:

cuArray3DCreate(jcuda.driver.CUarray, jcuda.driver.CUDA_ARRAY3D_DESCRIPTOR), cuArray3DGetDescriptor(jcuda.driver.CUDA_ARRAY3D_DESCRIPTOR, jcuda.driver.CUarray), cuArrayCreate(jcuda.driver.CUarray, jcuda.driver.CUDA_ARRAY_DESCRIPTOR), cuArrayDestroy(jcuda.driver.CUarray), cuArrayGetDescriptor(jcuda.driver.CUDA_ARRAY_DESCRIPTOR, jcuda.driver.CUarray), cuMemAlloc(jcuda.driver.CUdeviceptr, long), cuMemAllocHost(jcuda.Pointer, long), cuMemAllocPitch(jcuda.driver.CUdeviceptr, long[], long, long, int), cuMemcpy2D(jcuda.driver.CUDA_MEMCPY2D), cuMemcpy2DAsync(jcuda.driver.CUDA_MEMCPY2D, jcuda.driver.CUstream), cuMemcpy2DUnaligned(jcuda.driver.CUDA_MEMCPY2D), cuMemcpy3D(jcuda.driver.CUDA_MEMCPY3D), cuMemcpy3DAsync(jcuda.driver.CUDA_MEMCPY3D, jcuda.driver.CUstream), cuMemcpyAtoA(jcuda.driver.CUarray, long, jcuda.driver.CUarray, long, long), cuMemcpyAtoD(jcuda.driver.CUdeviceptr, jcuda.driver.CUarray, long, long), cuMemcpyAtoH(jcuda.Pointer, jcuda.driver.CUarray, long, long), cuMemcpyAtoHAsync(jcuda.Pointer, jcuda.driver.CUarray, long, long, jcuda.driver.CUstream), cuMemcpyDtoA(jcuda.driver.CUarray, long, jcuda.driver.CUdeviceptr, long), cuMemcpyDtoD(jcuda.driver.CUdeviceptr, jcuda.driver.CUdeviceptr, long), cuMemcpyDtoDAsync(jcuda.driver.CUdeviceptr, jcuda.driver.CUdeviceptr, long, jcuda.driver.CUstream), cuMemcpyDtoH(jcuda.Pointer, jcuda.driver.CUdeviceptr, long), cuMemcpyDtoHAsync(jcuda.Pointer, jcuda.driver.CUdeviceptr, long, jcuda.driver.CUstream), cuMemcpyHtoA(jcuda.driver.CUarray, long, jcuda.Pointer, long), cuMemcpyHtoAAsync(jcuda.driver.CUarray, long, jcuda.Pointer, long, jcuda.driver.CUstream), cuMemcpyHtoD(jcuda.driver.CUdeviceptr, jcuda.Pointer, long), cuMemcpyHtoDAsync(jcuda.driver.CUdeviceptr, jcuda.Pointer, long, jcuda.driver.CUstream), cuMemFree(jcuda.driver.CUdeviceptr), cuMemFreeHost(jcuda.Pointer), cuMemGetAddressRange(jcuda.driver.CUdeviceptr, long[], jcuda.driver.CUdeviceptr), cuMemGetInfo(long[], long[]), cuMemHostAlloc(jcuda.Pointer, long, int), cuMemHostGetDevicePointer(jcuda.driver.CUdeviceptr, jcuda.Pointer, int), cuMemsetD2D8Async(jcuda.driver.CUdeviceptr, long, byte, long, long, jcuda.driver.CUstream), cuMemsetD2D16(jcuda.driver.CUdeviceptr, long, short, long, long), cuMemsetD2D16Async(jcuda.driver.CUdeviceptr, long, short, long, long, jcuda.driver.CUstream), cuMemsetD2D32(jcuda.driver.CUdeviceptr, long, int, long, long), cuMemsetD2D32Async(jcuda.driver.CUdeviceptr, long, int, long, long, jcuda.driver.CUstream), cuMemsetD8(jcuda.driver.CUdeviceptr, byte, long), cuMemsetD8Async(jcuda.driver.CUdeviceptr, byte, long, jcuda.driver.CUstream), cuMemsetD16(jcuda.driver.CUdeviceptr, short, long), cuMemsetD16Async(jcuda.driver.CUdeviceptr, short, long, jcuda.driver.CUstream), cuMemsetD32(jcuda.driver.CUdeviceptr, int, long), cuMemsetD32Async(jcuda.driver.CUdeviceptr, int, long, jcuda.driver.CUstream)

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

Note that this function is asynchronous with respect to the host unless dstDevice refers to pinned host memory.

Note:
Note that this function may also return error codes from previous, asynchronous launches.
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

See Also:

cuArray3DCreate(jcuda.driver.CUarray, jcuda.driver.CUDA_ARRAY3D_DESCRIPTOR), cuArray3DGetDescriptor(jcuda.driver.CUDA_ARRAY3D_DESCRIPTOR, jcuda.driver.CUarray), cuArrayCreate(jcuda.driver.CUarray, jcuda.driver.CUDA_ARRAY_DESCRIPTOR), cuArrayDestroy(jcuda.driver.CUarray), cuArrayGetDescriptor(jcuda.driver.CUDA_ARRAY_DESCRIPTOR, jcuda.driver.CUarray), cuMemAlloc(jcuda.driver.CUdeviceptr, long), cuMemAllocHost(jcuda.Pointer, long), cuMemAllocPitch(jcuda.driver.CUdeviceptr, long[], long, long, int), cuMemcpy2D(jcuda.driver.CUDA_MEMCPY2D), cuMemcpy2DAsync(jcuda.driver.CUDA_MEMCPY2D, jcuda.driver.CUstream), cuMemcpy2DUnaligned(jcuda.driver.CUDA_MEMCPY2D), cuMemcpy3D(jcuda.driver.CUDA_MEMCPY3D), cuMemcpy3DAsync(jcuda.driver.CUDA_MEMCPY3D, jcuda.driver.CUstream), cuMemcpyAtoA(jcuda.driver.CUarray, long, jcuda.driver.CUarray, long, long), cuMemcpyAtoD(jcuda.driver.CUdeviceptr, jcuda.driver.CUarray, long, long), cuMemcpyAtoH(jcuda.Pointer, jcuda.driver.CUarray, long, long), cuMemcpyAtoHAsync(jcuda.Pointer, jcuda.driver.CUarray, long, long, jcuda.driver.CUstream), cuMemcpyDtoA(jcuda.driver.CUarray, long, jcuda.driver.CUdeviceptr, long), cuMemcpyDtoD(jcuda.driver.CUdeviceptr, jcuda.driver.CUdeviceptr, long), cuMemcpyDtoDAsync(jcuda.driver.CUdeviceptr, jcuda.driver.CUdeviceptr, long, jcuda.driver.CUstream), cuMemcpyDtoH(jcuda.Pointer, jcuda.driver.CUdeviceptr, long), cuMemcpyDtoHAsync(jcuda.Pointer, jcuda.driver.CUdeviceptr, long, jcuda.driver.CUstream), cuMemcpyHtoA(jcuda.driver.CUarray, long, jcuda.Pointer, long), cuMemcpyHtoAAsync(jcuda.driver.CUarray, long, jcuda.Pointer, long, jcuda.driver.CUstream), cuMemcpyHtoD(jcuda.driver.CUdeviceptr, jcuda.Pointer, long), cuMemcpyHtoDAsync(jcuda.driver.CUdeviceptr, jcuda.Pointer, long, jcuda.driver.CUstream), cuMemFree(jcuda.driver.CUdeviceptr), cuMemFreeHost(jcuda.Pointer), cuMemGetAddressRange(jcuda.driver.CUdeviceptr, long[], jcuda.driver.CUdeviceptr), cuMemGetInfo(long[], long[]), cuMemHostAlloc(jcuda.Pointer, long, int), cuMemHostGetDevicePointer(jcuda.driver.CUdeviceptr, jcuda.Pointer, int), cuMemsetD2D8(jcuda.driver.CUdeviceptr, long, byte, long, long), cuMemsetD2D8Async(jcuda.driver.CUdeviceptr, long, byte, long, long, jcuda.driver.CUstream), cuMemsetD2D16Async(jcuda.driver.CUdeviceptr, long, short, long, long, jcuda.driver.CUstream), cuMemsetD2D32(jcuda.driver.CUdeviceptr, long, int, long, long), cuMemsetD2D32Async(jcuda.driver.CUdeviceptr, long, int, long, long, jcuda.driver.CUstream), cuMemsetD8(jcuda.driver.CUdeviceptr, byte, long), cuMemsetD8Async(jcuda.driver.CUdeviceptr, byte, long, jcuda.driver.CUstream), cuMemsetD16(jcuda.driver.CUdeviceptr, short, long), cuMemsetD16Async(jcuda.driver.CUdeviceptr, short, long, jcuda.driver.CUstream), cuMemsetD32(jcuda.driver.CUdeviceptr, int, long), cuMemsetD32Async(jcuda.driver.CUdeviceptr, int, long, jcuda.driver.CUstream)

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

Note that this function is asynchronous with respect to the host unless dstDevice refers to pinned host memory.

Note:
Note that this function may also return error codes from previous, asynchronous launches.
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

See Also:

cuArray3DCreate(jcuda.driver.CUarray, jcuda.driver.CUDA_ARRAY3D_DESCRIPTOR), cuArray3DGetDescriptor(jcuda.driver.CUDA_ARRAY3D_DESCRIPTOR, jcuda.driver.CUarray), cuArrayCreate(jcuda.driver.CUarray, jcuda.driver.CUDA_ARRAY_DESCRIPTOR), cuArrayDestroy(jcuda.driver.CUarray), cuArrayGetDescriptor(jcuda.driver.CUDA_ARRAY_DESCRIPTOR, jcuda.driver.CUarray), cuMemAlloc(jcuda.driver.CUdeviceptr, long), cuMemAllocHost(jcuda.Pointer, long), cuMemAllocPitch(jcuda.driver.CUdeviceptr, long[], long, long, int), cuMemcpy2D(jcuda.driver.CUDA_MEMCPY2D), cuMemcpy2DAsync(jcuda.driver.CUDA_MEMCPY2D, jcuda.driver.CUstream), cuMemcpy2DUnaligned(jcuda.driver.CUDA_MEMCPY2D), cuMemcpy3D(jcuda.driver.CUDA_MEMCPY3D), cuMemcpy3DAsync(jcuda.driver.CUDA_MEMCPY3D, jcuda.driver.CUstream), cuMemcpyAtoA(jcuda.driver.CUarray, long, jcuda.driver.CUarray, long, long), cuMemcpyAtoD(jcuda.driver.CUdeviceptr, jcuda.driver.CUarray, long, long), cuMemcpyAtoH(jcuda.Pointer, jcuda.driver.CUarray, long, long), cuMemcpyAtoHAsync(jcuda.Pointer, jcuda.driver.CUarray, long, long, jcuda.driver.CUstream), cuMemcpyDtoA(jcuda.driver.CUarray, long, jcuda.driver.CUdeviceptr, long), cuMemcpyDtoD(jcuda.driver.CUdeviceptr, jcuda.driver.CUdeviceptr, long), cuMemcpyDtoDAsync(jcuda.driver.CUdeviceptr, jcuda.driver.CUdeviceptr, long, jcuda.driver.CUstream), cuMemcpyDtoH(jcuda.Pointer, jcuda.driver.CUdeviceptr, long), cuMemcpyDtoHAsync(jcuda.Pointer, jcuda.driver.CUdeviceptr, long, jcuda.driver.CUstream), cuMemcpyHtoA(jcuda.driver.CUarray, long, jcuda.Pointer, long), cuMemcpyHtoAAsync(jcuda.driver.CUarray, long, jcuda.Pointer, long, jcuda.driver.CUstream), cuMemcpyHtoD(jcuda.driver.CUdeviceptr, jcuda.Pointer, long), cuMemcpyHtoDAsync(jcuda.driver.CUdeviceptr, jcuda.Pointer, long, jcuda.driver.CUstream), cuMemFree(jcuda.driver.CUdeviceptr), cuMemFreeHost(jcuda.Pointer), cuMemGetAddressRange(jcuda.driver.CUdeviceptr, long[], jcuda.driver.CUdeviceptr), cuMemGetInfo(long[], long[]), cuMemHostAlloc(jcuda.Pointer, long, int), cuMemHostGetDevicePointer(jcuda.driver.CUdeviceptr, jcuda.Pointer, int), cuMemsetD2D8(jcuda.driver.CUdeviceptr, long, byte, long, long), cuMemsetD2D8Async(jcuda.driver.CUdeviceptr, long, byte, long, long, jcuda.driver.CUstream), cuMemsetD2D16(jcuda.driver.CUdeviceptr, long, short, long, long), cuMemsetD2D16Async(jcuda.driver.CUdeviceptr, long, short, long, long, jcuda.driver.CUstream), cuMemsetD2D32Async(jcuda.driver.CUdeviceptr, long, int, long, long, jcuda.driver.CUstream), cuMemsetD8(jcuda.driver.CUdeviceptr, byte, long), cuMemsetD8Async(jcuda.driver.CUdeviceptr, byte, long, jcuda.driver.CUstream), cuMemsetD16(jcuda.driver.CUdeviceptr, short, long), cuMemsetD16Async(jcuda.driver.CUdeviceptr, short, long, jcuda.driver.CUstream), cuMemsetD32(jcuda.driver.CUdeviceptr, int, long), cuMemsetD32Async(jcuda.driver.CUdeviceptr, int, long, jcuda.driver.CUstream)

cuMemsetD8Async
```
public static int cuMemsetD8Async(CUdeviceptr dstDevice,
                                  byte uc,
                                  long N,
                                  CUstream hStream)
```
Sets device memory.
```
 CUresult cuMemsetD8Async (
      CUdeviceptr dstDevice,
      unsigned char  uc,
      size_t N,
      CUstream hStream )
 
```
Sets device memory. Sets the memory range of N 8-bit values to the specified value uc.

cuMemsetD8Async() is asynchronous and can optionally be associated to a stream by passing a non-zero stream argument.

Note:
Note that this function may also return error codes from previous, asynchronous launches.
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

See Also:

cuArray3DCreate(jcuda.driver.CUarray, jcuda.driver.CUDA_ARRAY3D_DESCRIPTOR), cuArray3DGetDescriptor(jcuda.driver.CUDA_ARRAY3D_DESCRIPTOR, jcuda.driver.CUarray), cuArrayCreate(jcuda.driver.CUarray, jcuda.driver.CUDA_ARRAY_DESCRIPTOR), cuArrayDestroy(jcuda.driver.CUarray), cuArrayGetDescriptor(jcuda.driver.CUDA_ARRAY_DESCRIPTOR, jcuda.driver.CUarray), cuMemAlloc(jcuda.driver.CUdeviceptr, long), cuMemAllocHost(jcuda.Pointer, long), cuMemAllocPitch(jcuda.driver.CUdeviceptr, long[], long, long, int), cuMemcpy2D(jcuda.driver.CUDA_MEMCPY2D), cuMemcpy2DAsync(jcuda.driver.CUDA_MEMCPY2D, jcuda.driver.CUstream), cuMemcpy2DUnaligned(jcuda.driver.CUDA_MEMCPY2D), cuMemcpy3D(jcuda.driver.CUDA_MEMCPY3D), cuMemcpy3DAsync(jcuda.driver.CUDA_MEMCPY3D, jcuda.driver.CUstream), cuMemcpyAtoA(jcuda.driver.CUarray, long, jcuda.driver.CUarray, long, long), cuMemcpyAtoD(jcuda.driver.CUdeviceptr, jcuda.driver.CUarray, long, long), cuMemcpyAtoH(jcuda.Pointer, jcuda.driver.CUarray, long, long), cuMemcpyAtoHAsync(jcuda.Pointer, jcuda.driver.CUarray, long, long, jcuda.driver.CUstream), cuMemcpyDtoA(jcuda.driver.CUarray, long, jcuda.driver.CUdeviceptr, long), cuMemcpyDtoD(jcuda.driver.CUdeviceptr, jcuda.driver.CUdeviceptr, long), cuMemcpyDtoDAsync(jcuda.driver.CUdeviceptr, jcuda.driver.CUdeviceptr, long, jcuda.driver.CUstream), cuMemcpyDtoH(jcuda.Pointer, jcuda.driver.CUdeviceptr, long), cuMemcpyDtoHAsync(jcuda.Pointer, jcuda.driver.CUdeviceptr, long, jcuda.driver.CUstream), cuMemcpyHtoA(jcuda.driver.CUarray, long, jcuda.Pointer, long), cuMemcpyHtoAAsync(jcuda.driver.CUarray, long, jcuda.Pointer, long, jcuda.driver.CUstream), cuMemcpyHtoD(jcuda.driver.CUdeviceptr, jcuda.Pointer, long), cuMemcpyHtoDAsync(jcuda.driver.CUdeviceptr, jcuda.Pointer, long, jcuda.driver.CUstream), cuMemFree(jcuda.driver.CUdeviceptr), cuMemFreeHost(jcuda.Pointer), cuMemGetAddressRange(jcuda.driver.CUdeviceptr, long[], jcuda.driver.CUdeviceptr), cuMemGetInfo(long[], long[]), cuMemHostAlloc(jcuda.Pointer, long, int), cuMemHostGetDevicePointer(jcuda.driver.CUdeviceptr, jcuda.Pointer, int), cuMemsetD2D8(jcuda.driver.CUdeviceptr, long, byte, long, long), cuMemsetD2D8Async(jcuda.driver.CUdeviceptr, long, byte, long, long, jcuda.driver.CUstream), cuMemsetD2D16(jcuda.driver.CUdeviceptr, long, short, long, long), cuMemsetD2D16Async(jcuda.driver.CUdeviceptr, long, short, long, long, jcuda.driver.CUstream), cuMemsetD2D32(jcuda.driver.CUdeviceptr, long, int, long, long), cuMemsetD2D32Async(jcuda.driver.CUdeviceptr, long, int, long, long, jcuda.driver.CUstream), cuMemsetD8(jcuda.driver.CUdeviceptr, byte, long), cuMemsetD16(jcuda.driver.CUdeviceptr, short, long), cuMemsetD16Async(jcuda.driver.CUdeviceptr, short, long, jcuda.driver.CUstream), cuMemsetD32(jcuda.driver.CUdeviceptr, int, long), cuMemsetD32Async(jcuda.driver.CUdeviceptr, int, long, jcuda.driver.CUstream)

cuMemsetD16Async
```
public static int cuMemsetD16Async(CUdeviceptr dstDevice,
                                   short us,
                                   long N,
                                   CUstream hStream)
```
Sets device memory.
```
 CUresult cuMemsetD16Async (
      CUdeviceptr dstDevice,
      unsigned short us,
      size_t N,
      CUstream hStream )
 
```
Sets device memory. Sets the memory range of N 16-bit values to the specified value us. The dstDevice pointer must be two byte aligned.

cuMemsetD16Async() is asynchronous and can optionally be associated to a stream by passing a non-zero stream argument.

Note:
Note that this function may also return error codes from previous, asynchronous launches.
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

See Also:

cuArray3DCreate(jcuda.driver.CUarray, jcuda.driver.CUDA_ARRAY3D_DESCRIPTOR), cuArray3DGetDescriptor(jcuda.driver.CUDA_ARRAY3D_DESCRIPTOR, jcuda.driver.CUarray), cuArrayCreate(jcuda.driver.CUarray, jcuda.driver.CUDA_ARRAY_DESCRIPTOR), cuArrayDestroy(jcuda.driver.CUarray), cuArrayGetDescriptor(jcuda.driver.CUDA_ARRAY_DESCRIPTOR, jcuda.driver.CUarray), cuMemAlloc(jcuda.driver.CUdeviceptr, long), cuMemAllocHost(jcuda.Pointer, long), cuMemAllocPitch(jcuda.driver.CUdeviceptr, long[], long, long, int), cuMemcpy2D(jcuda.driver.CUDA_MEMCPY2D), cuMemcpy2DAsync(jcuda.driver.CUDA_MEMCPY2D, jcuda.driver.CUstream), cuMemcpy2DUnaligned(jcuda.driver.CUDA_MEMCPY2D), cuMemcpy3D(jcuda.driver.CUDA_MEMCPY3D), cuMemcpy3DAsync(jcuda.driver.CUDA_MEMCPY3D, jcuda.driver.CUstream), cuMemcpyAtoA(jcuda.driver.CUarray, long, jcuda.driver.CUarray, long, long), cuMemcpyAtoD(jcuda.driver.CUdeviceptr, jcuda.driver.CUarray, long, long), cuMemcpyAtoH(jcuda.Pointer, jcuda.driver.CUarray, long, long), cuMemcpyAtoHAsync(jcuda.Pointer, jcuda.driver.CUarray, long, long, jcuda.driver.CUstream), cuMemcpyDtoA(jcuda.driver.CUarray, long, jcuda.driver.CUdeviceptr, long), cuMemcpyDtoD(jcuda.driver.CUdeviceptr, jcuda.driver.CUdeviceptr, long), cuMemcpyDtoDAsync(jcuda.driver.CUdeviceptr, jcuda.driver.CUdeviceptr, long, jcuda.driver.CUstream), cuMemcpyDtoH(jcuda.Pointer, jcuda.driver.CUdeviceptr, long), cuMemcpyDtoHAsync(jcuda.Pointer, jcuda.driver.CUdeviceptr, long, jcuda.driver.CUstream), cuMemcpyHtoA(jcuda.driver.CUarray, long, jcuda.Pointer, long), cuMemcpyHtoAAsync(jcuda.driver.CUarray, long, jcuda.Pointer, long, jcuda.driver.CUstream), cuMemcpyHtoD(jcuda.driver.CUdeviceptr, jcuda.Pointer, long), cuMemcpyHtoDAsync(jcuda.driver.CUdeviceptr, jcuda.Pointer, long, jcuda.driver.CUstream), cuMemFree(jcuda.driver.CUdeviceptr), cuMemFreeHost(jcuda.Pointer), cuMemGetAddressRange(jcuda.driver.CUdeviceptr, long[], jcuda.driver.CUdeviceptr), cuMemGetInfo(long[], long[]), cuMemHostAlloc(jcuda.Pointer, long, int), cuMemHostGetDevicePointer(jcuda.driver.CUdeviceptr, jcuda.Pointer, int), cuMemsetD2D8(jcuda.driver.CUdeviceptr, long, byte, long, long), cuMemsetD2D8Async(jcuda.driver.CUdeviceptr, long, byte, long, long, jcuda.driver.CUstream), cuMemsetD2D16(jcuda.driver.CUdeviceptr, long, short, long, long), cuMemsetD2D16Async(jcuda.driver.CUdeviceptr, long, short, long, long, jcuda.driver.CUstream), cuMemsetD2D32(jcuda.driver.CUdeviceptr, long, int, long, long), cuMemsetD2D32Async(jcuda.driver.CUdeviceptr, long, int, long, long, jcuda.driver.CUstream), cuMemsetD8(jcuda.driver.CUdeviceptr, byte, long), cuMemsetD8Async(jcuda.driver.CUdeviceptr, byte, long, jcuda.driver.CUstream), cuMemsetD16(jcuda.driver.CUdeviceptr, short, long), cuMemsetD32(jcuda.driver.CUdeviceptr, int, long), cuMemsetD32Async(jcuda.driver.CUdeviceptr, int, long, jcuda.driver.CUstream)

cuMemsetD32Async
```
public static int cuMemsetD32Async(CUdeviceptr dstDevice,
                                   int ui,
                                   long N,
                                   CUstream hStream)
```
Sets device memory.
```
 CUresult cuMemsetD32Async (
      CUdeviceptr dstDevice,
      unsigned int  ui,
      size_t N,
      CUstream hStream )
 
```
Sets device memory. Sets the memory range of N 32-bit values to the specified value ui. The dstDevice pointer must be four byte aligned.

cuMemsetD32Async() is asynchronous and can optionally be associated to a stream by passing a non-zero stream argument.

Note:
Note that this function may also return error codes from previous, asynchronous launches.
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

See Also:

cuArray3DCreate(jcuda.driver.CUarray, jcuda.driver.CUDA_ARRAY3D_DESCRIPTOR), cuArray3DGetDescriptor(jcuda.driver.CUDA_ARRAY3D_DESCRIPTOR, jcuda.driver.CUarray), cuArrayCreate(jcuda.driver.CUarray, jcuda.driver.CUDA_ARRAY_DESCRIPTOR), cuArrayDestroy(jcuda.driver.CUarray), cuArrayGetDescriptor(jcuda.driver.CUDA_ARRAY_DESCRIPTOR, jcuda.driver.CUarray), cuMemAlloc(jcuda.driver.CUdeviceptr, long), cuMemAllocHost(jcuda.Pointer, long), cuMemAllocPitch(jcuda.driver.CUdeviceptr, long[], long, long, int), cuMemcpy2D(jcuda.driver.CUDA_MEMCPY2D), cuMemcpy2DAsync(jcuda.driver.CUDA_MEMCPY2D, jcuda.driver.CUstream), cuMemcpy2DUnaligned(jcuda.driver.CUDA_MEMCPY2D), cuMemcpy3D(jcuda.driver.CUDA_MEMCPY3D), cuMemcpy3DAsync(jcuda.driver.CUDA_MEMCPY3D, jcuda.driver.CUstream), cuMemcpyAtoA(jcuda.driver.CUarray, long, jcuda.driver.CUarray, long, long), cuMemcpyAtoD(jcuda.driver.CUdeviceptr, jcuda.driver.CUarray, long, long), cuMemcpyAtoH(jcuda.Pointer, jcuda.driver.CUarray, long, long), cuMemcpyAtoHAsync(jcuda.Pointer, jcuda.driver.CUarray, long, long, jcuda.driver.CUstream), cuMemcpyDtoA(jcuda.driver.CUarray, long, jcuda.driver.CUdeviceptr, long), cuMemcpyDtoD(jcuda.driver.CUdeviceptr, jcuda.driver.CUdeviceptr, long), cuMemcpyDtoDAsync(jcuda.driver.CUdeviceptr, jcuda.driver.CUdeviceptr, long, jcuda.driver.CUstream), cuMemcpyDtoH(jcuda.Pointer, jcuda.driver.CUdeviceptr, long), cuMemcpyDtoHAsync(jcuda.Pointer, jcuda.driver.CUdeviceptr, long, jcuda.driver.CUstream), cuMemcpyHtoA(jcuda.driver.CUarray, long, jcuda.Pointer, long), cuMemcpyHtoAAsync(jcuda.driver.CUarray, long, jcuda.Pointer, long, jcuda.driver.CUstream), cuMemcpyHtoD(jcuda.driver.CUdeviceptr, jcuda.Pointer, long), cuMemcpyHtoDAsync(jcuda.driver.CUdeviceptr, jcuda.Pointer, long, jcuda.driver.CUstream), cuMemFree(jcuda.driver.CUdeviceptr), cuMemFreeHost(jcuda.Pointer), cuMemGetAddressRange(jcuda.driver.CUdeviceptr, long[], jcuda.driver.CUdeviceptr), cuMemGetInfo(long[], long[]), cuMemHostAlloc(jcuda.Pointer, long, int), cuMemHostGetDevicePointer(jcuda.driver.CUdeviceptr, jcuda.Pointer, int), cuMemsetD2D8(jcuda.driver.CUdeviceptr, long, byte, long, long), cuMemsetD2D8Async(jcuda.driver.CUdeviceptr, long, byte, long, long, jcuda.driver.CUstream), cuMemsetD2D16(jcuda.driver.CUdeviceptr, long, short, long, long), cuMemsetD2D16Async(jcuda.driver.CUdeviceptr, long, short, long, long, jcuda.driver.CUstream), cuMemsetD2D32(jcuda.driver.CUdeviceptr, long, int, long, long), cuMemsetD2D32Async(jcuda.driver.CUdeviceptr, long, int, long, long, jcuda.driver.CUstream), cuMemsetD8(jcuda.driver.CUdeviceptr, byte, long), cuMemsetD8Async(jcuda.driver.CUdeviceptr, byte, long, jcuda.driver.CUstream), cuMemsetD16(jcuda.driver.CUdeviceptr, short, long), cuMemsetD16Async(jcuda.driver.CUdeviceptr, short, long, jcuda.driver.CUstream), cuMemsetD32(jcuda.driver.CUdeviceptr, int, long)

cuMemsetD2D8Async
```
public static int cuMemsetD2D8Async(CUdeviceptr dstDevice,
                                    long dstPitch,
                                    byte uc,
                                    long Width,
                                    long Height,
                                    CUstream hStream)
```
Sets device memory.
```
 CUresult cuMemsetD2D8Async (
      CUdeviceptr dstDevice,
      size_t dstPitch,
      unsigned char  uc,
      size_t Width,
      size_t Height,
      CUstream hStream )
 
```
Sets device memory. Sets the 2D memory range of Width 8-bit values to the specified value uc. Height specifies the number of rows to set, and 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().

cuMemsetD2D8Async() is asynchronous and can optionally be associated to a stream by passing a non-zero stream argument.

Note:
Note that this function may also return error codes from previous, asynchronous launches.
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

See Also:

cuArray3DCreate(jcuda.driver.CUarray, jcuda.driver.CUDA_ARRAY3D_DESCRIPTOR), cuArray3DGetDescriptor(jcuda.driver.CUDA_ARRAY3D_DESCRIPTOR, jcuda.driver.CUarray), cuArrayCreate(jcuda.driver.CUarray, jcuda.driver.CUDA_ARRAY_DESCRIPTOR), cuArrayDestroy(jcuda.driver.CUarray), cuArrayGetDescriptor(jcuda.driver.CUDA_ARRAY_DESCRIPTOR, jcuda.driver.CUarray), cuMemAlloc(jcuda.driver.CUdeviceptr, long), cuMemAllocHost(jcuda.Pointer, long), cuMemAllocPitch(jcuda.driver.CUdeviceptr, long[], long, long, int), cuMemcpy2D(jcuda.driver.CUDA_MEMCPY2D), cuMemcpy2DAsync(jcuda.driver.CUDA_MEMCPY2D, jcuda.driver.CUstream), cuMemcpy2DUnaligned(jcuda.driver.CUDA_MEMCPY2D), cuMemcpy3D(jcuda.driver.CUDA_MEMCPY3D), cuMemcpy3DAsync(jcuda.driver.CUDA_MEMCPY3D, jcuda.driver.CUstream), cuMemcpyAtoA(jcuda.driver.CUarray, long, jcuda.driver.CUarray, long, long), cuMemcpyAtoD(jcuda.driver.CUdeviceptr, jcuda.driver.CUarray, long, long), cuMemcpyAtoH(jcuda.Pointer, jcuda.driver.CUarray, long, long), cuMemcpyAtoHAsync(jcuda.Pointer, jcuda.driver.CUarray, long, long, jcuda.driver.CUstream), cuMemcpyDtoA(jcuda.driver.CUarray, long, jcuda.driver.CUdeviceptr, long), cuMemcpyDtoD(jcuda.driver.CUdeviceptr, jcuda.driver.CUdeviceptr, long), cuMemcpyDtoDAsync(jcuda.driver.CUdeviceptr, jcuda.driver.CUdeviceptr, long, jcuda.driver.CUstream), cuMemcpyDtoH(jcuda.Pointer, jcuda.driver.CUdeviceptr, long), cuMemcpyDtoHAsync(jcuda.Pointer, jcuda.driver.CUdeviceptr, long, jcuda.driver.CUstream), cuMemcpyHtoA(jcuda.driver.CUarray, long, jcuda.Pointer, long), cuMemcpyHtoAAsync(jcuda.driver.CUarray, long, jcuda.Pointer, long, jcuda.driver.CUstream), cuMemcpyHtoD(jcuda.driver.CUdeviceptr, jcuda.Pointer, long), cuMemcpyHtoDAsync(jcuda.driver.CUdeviceptr, jcuda.Pointer, long, jcuda.driver.CUstream), cuMemFree(jcuda.driver.CUdeviceptr), cuMemFreeHost(jcuda.Pointer), cuMemGetAddressRange(jcuda.driver.CUdeviceptr, long[], jcuda.driver.CUdeviceptr), cuMemGetInfo(long[], long[]), cuMemHostAlloc(jcuda.Pointer, long, int), cuMemHostGetDevicePointer(jcuda.driver.CUdeviceptr, jcuda.Pointer, int), cuMemsetD2D8(jcuda.driver.CUdeviceptr, long, byte, long, long), cuMemsetD2D16(jcuda.driver.CUdeviceptr, long, short, long, long), cuMemsetD2D16Async(jcuda.driver.CUdeviceptr, long, short, long, long, jcuda.driver.CUstream), cuMemsetD2D32(jcuda.driver.CUdeviceptr, long, int, long, long), cuMemsetD2D32Async(jcuda.driver.CUdeviceptr, long, int, long, long, jcuda.driver.CUstream), cuMemsetD8(jcuda.driver.CUdeviceptr, byte, long), cuMemsetD8Async(jcuda.driver.CUdeviceptr, byte, long, jcuda.driver.CUstream), cuMemsetD16(jcuda.driver.CUdeviceptr, short, long), cuMemsetD16Async(jcuda.driver.CUdeviceptr, short, long, jcuda.driver.CUstream), cuMemsetD32(jcuda.driver.CUdeviceptr, int, long), cuMemsetD32Async(jcuda.driver.CUdeviceptr, int, long, jcuda.driver.CUstream)

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

cuMemsetD2D16Async() is asynchronous and can optionally be associated to a stream by passing a non-zero stream argument.

Note:
Note that this function may also return error codes from previous, asynchronous launches.
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

See Also:

cuArray3DCreate(jcuda.driver.CUarray, jcuda.driver.CUDA_ARRAY3D_DESCRIPTOR), cuArray3DGetDescriptor(jcuda.driver.CUDA_ARRAY3D_DESCRIPTOR, jcuda.driver.CUarray), cuArrayCreate(jcuda.driver.CUarray, jcuda.driver.CUDA_ARRAY_DESCRIPTOR), cuArrayDestroy(jcuda.driver.CUarray), cuArrayGetDescriptor(jcuda.driver.CUDA_ARRAY_DESCRIPTOR, jcuda.driver.CUarray), cuMemAlloc(jcuda.driver.CUdeviceptr, long), cuMemAllocHost(jcuda.Pointer, long), cuMemAllocPitch(jcuda.driver.CUdeviceptr, long[], long, long, int), cuMemcpy2D(jcuda.driver.CUDA_MEMCPY2D), cuMemcpy2DAsync(jcuda.driver.CUDA_MEMCPY2D, jcuda.driver.CUstream), cuMemcpy2DUnaligned(jcuda.driver.CUDA_MEMCPY2D), cuMemcpy3D(jcuda.driver.CUDA_MEMCPY3D), cuMemcpy3DAsync(jcuda.driver.CUDA_MEMCPY3D, jcuda.driver.CUstream), cuMemcpyAtoA(jcuda.driver.CUarray, long, jcuda.driver.CUarray, long, long), cuMemcpyAtoD(jcuda.driver.CUdeviceptr, jcuda.driver.CUarray, long, long), cuMemcpyAtoH(jcuda.Pointer, jcuda.driver.CUarray, long, long), cuMemcpyAtoHAsync(jcuda.Pointer, jcuda.driver.CUarray, long, long, jcuda.driver.CUstream), cuMemcpyDtoA(jcuda.driver.CUarray, long, jcuda.driver.CUdeviceptr, long), cuMemcpyDtoD(jcuda.driver.CUdeviceptr, jcuda.driver.CUdeviceptr, long), cuMemcpyDtoDAsync(jcuda.driver.CUdeviceptr, jcuda.driver.CUdeviceptr, long, jcuda.driver.CUstream), cuMemcpyDtoH(jcuda.Pointer, jcuda.driver.CUdeviceptr, long), cuMemcpyDtoHAsync(jcuda.Pointer, jcuda.driver.CUdeviceptr, long, jcuda.driver.CUstream), cuMemcpyHtoA(jcuda.driver.CUarray, long, jcuda.Pointer, long), cuMemcpyHtoAAsync(jcuda.driver.CUarray, long, jcuda.Pointer, long, jcuda.driver.CUstream), cuMemcpyHtoD(jcuda.driver.CUdeviceptr, jcuda.Pointer, long), cuMemcpyHtoDAsync(jcuda.driver.CUdeviceptr, jcuda.Pointer, long, jcuda.driver.CUstream), cuMemFree(jcuda.driver.CUdeviceptr), cuMemFreeHost(jcuda.Pointer), cuMemGetAddressRange(jcuda.driver.CUdeviceptr, long[], jcuda.driver.CUdeviceptr), cuMemGetInfo(long[], long[]), cuMemHostAlloc(jcuda.Pointer, long, int), cuMemHostGetDevicePointer(jcuda.driver.CUdeviceptr, jcuda.Pointer, int), cuMemsetD2D8(jcuda.driver.CUdeviceptr, long, byte, long, long), cuMemsetD2D8Async(jcuda.driver.CUdeviceptr, long, byte, long, long, jcuda.driver.CUstream), cuMemsetD2D16(jcuda.driver.CUdeviceptr, long, short, long, long), cuMemsetD2D32(jcuda.driver.CUdeviceptr, long, int, long, long), cuMemsetD2D32Async(jcuda.driver.CUdeviceptr, long, int, long, long, jcuda.driver.CUstream), cuMemsetD8(jcuda.driver.CUdeviceptr, byte, long), cuMemsetD8Async(jcuda.driver.CUdeviceptr, byte, long, jcuda.driver.CUstream), cuMemsetD16(jcuda.driver.CUdeviceptr, short, long), cuMemsetD16Async(jcuda.driver.CUdeviceptr, short, long, jcuda.driver.CUstream), cuMemsetD32(jcuda.driver.CUdeviceptr, int, long), cuMemsetD32Async(jcuda.driver.CUdeviceptr, int, long, jcuda.driver.CUstream)

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

cuMemsetD2D32Async() is asynchronous and can optionally be associated to a stream by passing a non-zero stream argument.

Note:
Note that this function may also return error codes from previous, asynchronous launches.
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

See Also:

cuArray3DCreate(jcuda.driver.CUarray, jcuda.driver.CUDA_ARRAY3D_DESCRIPTOR), cuArray3DGetDescriptor(jcuda.driver.CUDA_ARRAY3D_DESCRIPTOR, jcuda.driver.CUarray), cuArrayCreate(jcuda.driver.CUarray, jcuda.driver.CUDA_ARRAY_DESCRIPTOR), cuArrayDestroy(jcuda.driver.CUarray), cuArrayGetDescriptor(jcuda.driver.CUDA_ARRAY_DESCRIPTOR, jcuda.driver.CUarray), cuMemAlloc(jcuda.driver.CUdeviceptr, long), cuMemAllocHost(jcuda.Pointer, long), cuMemAllocPitch(jcuda.driver.CUdeviceptr, long[], long, long, int), cuMemcpy2D(jcuda.driver.CUDA_MEMCPY2D), cuMemcpy2DAsync(jcuda.driver.CUDA_MEMCPY2D, jcuda.driver.CUstream), cuMemcpy2DUnaligned(jcuda.driver.CUDA_MEMCPY2D), cuMemcpy3D(jcuda.driver.CUDA_MEMCPY3D), cuMemcpy3DAsync(jcuda.driver.CUDA_MEMCPY3D, jcuda.driver.CUstream), cuMemcpyAtoA(jcuda.driver.CUarray, long, jcuda.driver.CUarray, long, long), cuMemcpyAtoD(jcuda.driver.CUdeviceptr, jcuda.driver.CUarray, long, long), cuMemcpyAtoH(jcuda.Pointer, jcuda.driver.CUarray, long, long), cuMemcpyAtoHAsync(jcuda.Pointer, jcuda.driver.CUarray, long, long, jcuda.driver.CUstream), cuMemcpyDtoA(jcuda.driver.CUarray, long, jcuda.driver.CUdeviceptr, long), cuMemcpyDtoD(jcuda.driver.CUdeviceptr, jcuda.driver.CUdeviceptr, long), cuMemcpyDtoDAsync(jcuda.driver.CUdeviceptr, jcuda.driver.CUdeviceptr, long, jcuda.driver.CUstream), cuMemcpyDtoH(jcuda.Pointer, jcuda.driver.CUdeviceptr, long), cuMemcpyDtoHAsync(jcuda.Pointer, jcuda.driver.CUdeviceptr, long, jcuda.driver.CUstream), cuMemcpyHtoA(jcuda.driver.CUarray, long, jcuda.Pointer, long), cuMemcpyHtoAAsync(jcuda.driver.CUarray, long, jcuda.Pointer, long, jcuda.driver.CUstream), cuMemcpyHtoD(jcuda.driver.CUdeviceptr, jcuda.Pointer, long), cuMemcpyHtoDAsync(jcuda.driver.CUdeviceptr, jcuda.Pointer, long, jcuda.driver.CUstream), cuMemFree(jcuda.driver.CUdeviceptr), cuMemFreeHost(jcuda.Pointer), cuMemGetAddressRange(jcuda.driver.CUdeviceptr, long[], jcuda.driver.CUdeviceptr), cuMemGetInfo(long[], long[]), cuMemHostAlloc(jcuda.Pointer, long, int), cuMemHostGetDevicePointer(jcuda.driver.CUdeviceptr, jcuda.Pointer, int), cuMemsetD2D8(jcuda.driver.CUdeviceptr, long, byte, long, long), cuMemsetD2D8Async(jcuda.driver.CUdeviceptr, long, byte, long, long, jcuda.driver.CUstream), cuMemsetD2D16(jcuda.driver.CUdeviceptr, long, short, long, long), cuMemsetD2D16Async(jcuda.driver.CUdeviceptr, long, short, long, long, jcuda.driver.CUstream), cuMemsetD2D32(jcuda.driver.CUdeviceptr, long, int, long, long), cuMemsetD8(jcuda.driver.CUdeviceptr, byte, long), cuMemsetD8Async(jcuda.driver.CUdeviceptr, byte, long, jcuda.driver.CUstream), cuMemsetD16(jcuda.driver.CUdeviceptr, short, long), cuMemsetD16Async(jcuda.driver.CUdeviceptr, short, long, jcuda.driver.CUstream), cuMemsetD32(jcuda.driver.CUdeviceptr, int, long), cuMemsetD32Async(jcuda.driver.CUdeviceptr, int, long, jcuda.driver.CUstream)

cuFuncGetAttribute
```
public static int cuFuncGetAttribute(int[] pi,
                                     int attrib,
                                     CUfunction func)
```
Returns information about a function.
```
 CUresult cuFuncGetAttribute (
      int* pi,
      CUfunction_attribute attrib,
      CUfunction hfunc )
 
```
Returns information about a function. Returns in *pi the integer value of the attribute attrib on the kernel given by 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.
Note:
Note that this function may also return error codes from previous, asynchronous launches.
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

See Also:

cuCtxGetCacheConfig(int[]), cuCtxSetCacheConfig(int), cuFuncSetCacheConfig(jcuda.driver.CUfunction, int), cuLaunchKernel(jcuda.driver.CUfunction, int, int, int, int, int, int, int, jcuda.driver.CUstream, jcuda.Pointer, jcuda.Pointer)

cuFuncSetAttribute
```
public static int cuFuncSetAttribute(CUfunction hfunc,
                                     int attrib,
                                     int value)
```
Sets information about a function.

This call sets the value of a specified attribute attrib on the kernel given by hfunc to an integer value specified by 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 resources. 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

See Also:

cuCtxGetCacheConfig(int[]), cuCtxSetCacheConfig(int), cuFuncSetCacheConfig(jcuda.driver.CUfunction, int), cuLaunchKernel(jcuda.driver.CUfunction, int, int, int, int, int, int, int, jcuda.driver.CUstream, jcuda.Pointer, jcuda.Pointer), JCuda.cudaFuncGetAttributes(jcuda.runtime.cudaFuncAttributes, java.lang.String), JCuda#cudaFuncSetAttribute

cuFuncSetBlockShape
```
@Deprecated
public static int cuFuncSetBlockShape(CUfunction hfunc,
                                                   int x,
                                                   int y,
                                                   int z)
```
Deprecated. Deprecated in CUDA
Sets the block-dimensions for the function.
```
 CUresult cuFuncSetBlockShape (
      CUfunction hfunc,
      int  x,
      int  y,
      int  z )
 
```
Sets the block-dimensions for the function. Deprecated Specifies the x, y, and z dimensions of the thread blocks that are created when the kernel given by hfunc is launched.

Note:
Note that this function may also return error codes from previous, asynchronous launches.
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

See Also:

cuFuncSetSharedSize(jcuda.driver.CUfunction, int), cuFuncSetCacheConfig(jcuda.driver.CUfunction, int), cuFuncGetAttribute(int[], int, jcuda.driver.CUfunction), cuParamSetSize(jcuda.driver.CUfunction, int), cuParamSeti(jcuda.driver.CUfunction, int, int), cuParamSetf(jcuda.driver.CUfunction, int, float), cuParamSetv(jcuda.driver.CUfunction, int, jcuda.Pointer, int), cuLaunch(jcuda.driver.CUfunction), cuLaunchGrid(jcuda.driver.CUfunction, int, int), cuLaunchGridAsync(jcuda.driver.CUfunction, int, int, jcuda.driver.CUstream), cuLaunchKernel(jcuda.driver.CUfunction, int, int, int, int, int, int, int, jcuda.driver.CUstream, jcuda.Pointer, jcuda.Pointer)

cuFuncSetSharedSize
```
@Deprecated
public static int cuFuncSetSharedSize(CUfunction hfunc,
                                                   int bytes)
```
Deprecated. Deprecated in CUDA
Sets the dynamic shared-memory size for the function.
```
 CUresult cuFuncSetSharedSize (
      CUfunction hfunc,
      unsigned int  bytes )
 
```
Sets the dynamic shared-memory size for the function. Deprecated Sets through bytes the amount of dynamic shared memory that will be available to each thread block when the kernel given by hfunc is launched.

Note:
Note that this function may also return error codes from previous, asynchronous launches.
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

See Also:

cuFuncSetBlockShape(jcuda.driver.CUfunction, int, int, int), cuFuncSetCacheConfig(jcuda.driver.CUfunction, int), cuFuncGetAttribute(int[], int, jcuda.driver.CUfunction), cuParamSetSize(jcuda.driver.CUfunction, int), cuParamSeti(jcuda.driver.CUfunction, int, int), cuParamSetf(jcuda.driver.CUfunction, int, float), cuParamSetv(jcuda.driver.CUfunction, int, jcuda.Pointer, int), cuLaunch(jcuda.driver.CUfunction), cuLaunchGrid(jcuda.driver.CUfunction, int, int), cuLaunchGridAsync(jcuda.driver.CUfunction, int, int, jcuda.driver.CUstream), cuLaunchKernel(jcuda.driver.CUfunction, int, int, int, int, int, int, int, jcuda.driver.CUstream, jcuda.Pointer, jcuda.Pointer)

cuFuncSetCacheConfig
```
public static int cuFuncSetCacheConfig(CUfunction hfunc,
                                       int config)
```
Sets the preferred cache configuration for a device function.
```
 CUresult cuFuncSetCacheConfig (
      CUfunction hfunc,
      CUfunc_cache config )
 
```
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 config the preferred cache configuration for the device function 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 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
Note:
Note that this function may also return error codes from previous, asynchronous launches.
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

See Also:

cuCtxGetCacheConfig(int[]), cuCtxSetCacheConfig(int), cuFuncGetAttribute(int[], int, jcuda.driver.CUfunction), cuLaunchKernel(jcuda.driver.CUfunction, int, int, int, int, int, int, int, jcuda.driver.CUstream, jcuda.Pointer, jcuda.Pointer)

cuFuncSetSharedMemConfig
```
public static int cuFuncSetSharedMemConfig(CUfunction hfunc,
                                           int config)
```
Sets the shared memory configuration for a device function.
```
 CUresult cuFuncSetSharedMemConfig (
      CUfunction hfunc,
      CUsharedconfig config )
 
```
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.
Note:
Note that this function may also return error codes from previous, asynchronous launches.
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

See Also:

cuCtxGetCacheConfig(int[]), cuCtxSetCacheConfig(int), cuCtxGetSharedMemConfig(int[]), JCudaDriver#cuCtxSetSharedMemConfigcuFuncGetAttribute, cuLaunchKernel(jcuda.driver.CUfunction, int, int, int, int, int, int, int, jcuda.driver.CUstream, jcuda.Pointer, jcuda.Pointer)

cuArrayCreate
```
public static int cuArrayCreate(CUarray pHandle,
                                CUDA_ARRAY_DESCRIPTOR pAllocateArray)
```
Creates a 1D or 2D CUDA array.
```
 CUresult cuArrayCreate (
      CUarray* pHandle,
      const CUDA_ARRAY_DESCRIPTOR* pAllocateArray )
 
```
Creates a 1D or 2D CUDA array. Creates a CUDA array according to the CUDA_ARRAY_DESCRIPTOR structure pAllocateArray and returns a handle to the new CUDA array in *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:
- Width, and 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;
- 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 width x 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 width x 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;
```
Note:
Note that this function may also return error codes from previous, asynchronous launches.
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

See Also:

cuArray3DCreate(jcuda.driver.CUarray, jcuda.driver.CUDA_ARRAY3D_DESCRIPTOR), cuArray3DGetDescriptor(jcuda.driver.CUDA_ARRAY3D_DESCRIPTOR, jcuda.driver.CUarray), cuArrayDestroy(jcuda.driver.CUarray), cuArrayGetDescriptor(jcuda.driver.CUDA_ARRAY_DESCRIPTOR, jcuda.driver.CUarray), cuMemAlloc(jcuda.driver.CUdeviceptr, long), cuMemAllocHost(jcuda.Pointer, long), cuMemAllocPitch(jcuda.driver.CUdeviceptr, long[], long, long, int), cuMemcpy2D(jcuda.driver.CUDA_MEMCPY2D), cuMemcpy2DAsync(jcuda.driver.CUDA_MEMCPY2D, jcuda.driver.CUstream), cuMemcpy2DUnaligned(jcuda.driver.CUDA_MEMCPY2D), cuMemcpy3D(jcuda.driver.CUDA_MEMCPY3D), cuMemcpy3DAsync(jcuda.driver.CUDA_MEMCPY3D, jcuda.driver.CUstream), cuMemcpyAtoA(jcuda.driver.CUarray, long, jcuda.driver.CUarray, long, long), cuMemcpyAtoD(jcuda.driver.CUdeviceptr, jcuda.driver.CUarray, long, long), cuMemcpyAtoH(jcuda.Pointer, jcuda.driver.CUarray, long, long), cuMemcpyAtoHAsync(jcuda.Pointer, jcuda.driver.CUarray, long, long, jcuda.driver.CUstream), cuMemcpyDtoA(jcuda.driver.CUarray, long, jcuda.driver.CUdeviceptr, long), cuMemcpyDtoD(jcuda.driver.CUdeviceptr, jcuda.driver.CUdeviceptr, long), cuMemcpyDtoDAsync(jcuda.driver.CUdeviceptr, jcuda.driver.CUdeviceptr, long, jcuda.driver.CUstream), cuMemcpyDtoH(jcuda.Pointer, jcuda.driver.CUdeviceptr, long), cuMemcpyDtoHAsync(jcuda.Pointer, jcuda.driver.CUdeviceptr, long, jcuda.driver.CUstream), cuMemcpyHtoA(jcuda.driver.CUarray, long, jcuda.Pointer, long), cuMemcpyHtoAAsync(jcuda.driver.CUarray, long, jcuda.Pointer, long, jcuda.driver.CUstream), cuMemcpyHtoD(jcuda.driver.CUdeviceptr, jcuda.Pointer, long), cuMemcpyHtoDAsync(jcuda.driver.CUdeviceptr, jcuda.Pointer, long, jcuda.driver.CUstream), cuMemFree(jcuda.driver.CUdeviceptr), cuMemFreeHost(jcuda.Pointer), cuMemGetAddressRange(jcuda.driver.CUdeviceptr, long[], jcuda.driver.CUdeviceptr), cuMemGetInfo(long[], long[]), cuMemHostAlloc(jcuda.Pointer, long, int), cuMemHostGetDevicePointer(jcuda.driver.CUdeviceptr, jcuda.Pointer, int), cuMemsetD2D8(jcuda.driver.CUdeviceptr, long, byte, long, long), cuMemsetD2D16(jcuda.driver.CUdeviceptr, long, short, long, long), cuMemsetD2D32(jcuda.driver.CUdeviceptr, long, int, long, long), cuMemsetD8(jcuda.driver.CUdeviceptr, byte, long), cuMemsetD16(jcuda.driver.CUdeviceptr, short, long), cuMemsetD32(jcuda.driver.CUdeviceptr, int, long)

cuArrayGetDescriptor
```
public static int cuArrayGetDescriptor(CUDA_ARRAY_DESCRIPTOR pArrayDescriptor,
                                       CUarray hArray)
```
Get a 1D or 2D CUDA array descriptor.
```
 CUresult cuArrayGetDescriptor (
      CUDA_ARRAY_DESCRIPTOR* pArrayDescriptor,
      CUarray hArray )
 
```
Get a 1D or 2D CUDA array descriptor. Returns in *pArrayDescriptor a descriptor containing information on the format and dimensions of the CUDA array 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.

Note:
Note that this function may also return error codes from previous, asynchronous launches.
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

See Also:

cuArray3DCreate(jcuda.driver.CUarray, jcuda.driver.CUDA_ARRAY3D_DESCRIPTOR), cuArray3DGetDescriptor(jcuda.driver.CUDA_ARRAY3D_DESCRIPTOR, jcuda.driver.CUarray), cuArrayCreate(jcuda.driver.CUarray, jcuda.driver.CUDA_ARRAY_DESCRIPTOR), cuArrayDestroy(jcuda.driver.CUarray), cuMemAlloc(jcuda.driver.CUdeviceptr, long), cuMemAllocHost(jcuda.Pointer, long), cuMemAllocPitch(jcuda.driver.CUdeviceptr, long[], long, long, int), cuMemcpy2D(jcuda.driver.CUDA_MEMCPY2D), cuMemcpy2DAsync(jcuda.driver.CUDA_MEMCPY2D, jcuda.driver.CUstream), cuMemcpy2DUnaligned(jcuda.driver.CUDA_MEMCPY2D), cuMemcpy3D(jcuda.driver.CUDA_MEMCPY3D), cuMemcpy3DAsync(jcuda.driver.CUDA_MEMCPY3D, jcuda.driver.CUstream), cuMemcpyAtoA(jcuda.driver.CUarray, long, jcuda.driver.CUarray, long, long), cuMemcpyAtoD(jcuda.driver.CUdeviceptr, jcuda.driver.CUarray, long, long), cuMemcpyAtoH(jcuda.Pointer, jcuda.driver.CUarray, long, long), cuMemcpyAtoHAsync(jcuda.Pointer, jcuda.driver.CUarray, long, long, jcuda.driver.CUstream), cuMemcpyDtoA(jcuda.driver.CUarray, long, jcuda.driver.CUdeviceptr, long), cuMemcpyDtoD(jcuda.driver.CUdeviceptr, jcuda.driver.CUdeviceptr, long), cuMemcpyDtoDAsync(jcuda.driver.CUdeviceptr, jcuda.driver.CUdeviceptr, long, jcuda.driver.CUstream), cuMemcpyDtoH(jcuda.Pointer, jcuda.driver.CUdeviceptr, long), cuMemcpyDtoHAsync(jcuda.Pointer, jcuda.driver.CUdeviceptr, long, jcuda.driver.CUstream), cuMemcpyHtoA(jcuda.driver.CUarray, long, jcuda.Pointer, long), cuMemcpyHtoAAsync(jcuda.driver.CUarray, long, jcuda.Pointer, long, jcuda.driver.CUstream), cuMemcpyHtoD(jcuda.driver.CUdeviceptr, jcuda.Pointer, long), cuMemcpyHtoDAsync(jcuda.driver.CUdeviceptr, jcuda.Pointer, long, jcuda.driver.CUstream), cuMemFree(jcuda.driver.CUdeviceptr), cuMemFreeHost(jcuda.Pointer), cuMemGetAddressRange(jcuda.driver.CUdeviceptr, long[], jcuda.driver.CUdeviceptr), cuMemGetInfo(long[], long[]), cuMemHostAlloc(jcuda.Pointer, long, int), cuMemHostGetDevicePointer(jcuda.driver.CUdeviceptr, jcuda.Pointer, int), cuMemsetD2D8(jcuda.driver.CUdeviceptr, long, byte, long, long), cuMemsetD2D16(jcuda.driver.CUdeviceptr, long, short, long, long), cuMemsetD2D32(jcuda.driver.CUdeviceptr, long, int, long, long), cuMemsetD8(jcuda.driver.CUdeviceptr, byte, long), cuMemsetD16(jcuda.driver.CUdeviceptr, short, long), cuMemsetD32(jcuda.driver.CUdeviceptr, int, long)

cuArrayDestroy
```
public static int cuArrayDestroy(CUarray hArray)
```
Destroys a CUDA array.
```
 CUresult cuArrayDestroy (
      CUarray hArray )
 
```
Destroys a CUDA array. Destroys the CUDA array hArray.

Note:
Note that this function may also return error codes from previous, asynchronous launches.
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

See Also:

cuArray3DCreate(jcuda.driver.CUarray, jcuda.driver.CUDA_ARRAY3D_DESCRIPTOR), cuArray3DGetDescriptor(jcuda.driver.CUDA_ARRAY3D_DESCRIPTOR, jcuda.driver.CUarray), cuArrayCreate(jcuda.driver.CUarray, jcuda.driver.CUDA_ARRAY_DESCRIPTOR), cuArrayGetDescriptor(jcuda.driver.CUDA_ARRAY_DESCRIPTOR, jcuda.driver.CUarray), cuMemAlloc(jcuda.driver.CUdeviceptr, long), cuMemAllocHost(jcuda.Pointer, long), cuMemAllocPitch(jcuda.driver.CUdeviceptr, long[], long, long, int), cuMemcpy2D(jcuda.driver.CUDA_MEMCPY2D), cuMemcpy2DAsync(jcuda.driver.CUDA_MEMCPY2D, jcuda.driver.CUstream), cuMemcpy2DUnaligned(jcuda.driver.CUDA_MEMCPY2D), cuMemcpy3D(jcuda.driver.CUDA_MEMCPY3D), cuMemcpy3DAsync(jcuda.driver.CUDA_MEMCPY3D, jcuda.driver.CUstream), cuMemcpyAtoA(jcuda.driver.CUarray, long, jcuda.driver.CUarray, long, long), cuMemcpyAtoD(jcuda.driver.CUdeviceptr, jcuda.driver.CUarray, long, long), cuMemcpyAtoH(jcuda.Pointer, jcuda.driver.CUarray, long, long), cuMemcpyAtoHAsync(jcuda.Pointer, jcuda.driver.CUarray, long, long, jcuda.driver.CUstream), cuMemcpyDtoA(jcuda.driver.CUarray, long, jcuda.driver.CUdeviceptr, long), cuMemcpyDtoD(jcuda.driver.CUdeviceptr, jcuda.driver.CUdeviceptr, long), cuMemcpyDtoDAsync(jcuda.driver.CUdeviceptr, jcuda.driver.CUdeviceptr, long, jcuda.driver.CUstream), cuMemcpyDtoH(jcuda.Pointer, jcuda.driver.CUdeviceptr, long), cuMemcpyDtoHAsync(jcuda.Pointer, jcuda.driver.CUdeviceptr, long, jcuda.driver.CUstream), cuMemcpyHtoA(jcuda.driver.CUarray, long, jcuda.Pointer, long), cuMemcpyHtoAAsync(jcuda.driver.CUarray, long, jcuda.Pointer, long, jcuda.driver.CUstream), cuMemcpyHtoD(jcuda.driver.CUdeviceptr, jcuda.Pointer, long), cuMemcpyHtoDAsync(jcuda.driver.CUdeviceptr, jcuda.Pointer, long, jcuda.driver.CUstream), cuMemFree(jcuda.driver.CUdeviceptr), cuMemFreeHost(jcuda.Pointer), cuMemGetAddressRange(jcuda.driver.CUdeviceptr, long[], jcuda.driver.CUdeviceptr), cuMemGetInfo(long[], long[]), cuMemHostAlloc(jcuda.Pointer, long, int), cuMemHostGetDevicePointer(jcuda.driver.CUdeviceptr, jcuda.Pointer, int), cuMemsetD2D8(jcuda.driver.CUdeviceptr, long, byte, long, long), cuMemsetD2D16(jcuda.driver.CUdeviceptr, long, short, long, long), cuMemsetD2D32(jcuda.driver.CUdeviceptr, long, int, long, long), cuMemsetD8(jcuda.driver.CUdeviceptr, byte, long), cuMemsetD16(jcuda.driver.CUdeviceptr, short, long), cuMemsetD32(jcuda.driver.CUdeviceptr, int, long)

cuArray3DCreate

public static int cuArray3DCreate(CUarray pHandle,
                                  CUDA_ARRAY3D_DESCRIPTOR pAllocateArray)

Creates a 3D CUDA array.

 CUresult cuArray3DCreate (
      CUarray* pHandle,
      const CUDA_ARRAY3D_DESCRIPTOR* pAllocateArray )

Creates a 3D CUDA array. Creates a CUDA array according to the CUDA_ARRAY3D_DESCRIPTOR structure pAllocateArray and returns a handle to the new CUDA array in *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:

Width, Height, and 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 Height and Depth extents are both zero.
- A 2D array is allocated if only 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 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. 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 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. 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.

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;

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, 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, Width must be equal to Height, and Depth must be six. If the CUDA_ARRAY3D_LAYERED flag is also set, then 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.

Width, Height and 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. Width and 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 width x height x 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;

Note:

Note that this function may also return error codes from previous, asynchronous launches.

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
See Also:: cuArray3DGetDescriptor(jcuda.driver.CUDA_ARRAY3D_DESCRIPTOR, jcuda.driver.CUarray), cuArrayCreate(jcuda.driver.CUarray, jcuda.driver.CUDA_ARRAY_DESCRIPTOR), cuArrayDestroy(jcuda.driver.CUarray), cuArrayGetDescriptor(jcuda.driver.CUDA_ARRAY_DESCRIPTOR, jcuda.driver.CUarray), cuMemAlloc(jcuda.driver.CUdeviceptr, long), cuMemAllocHost(jcuda.Pointer, long), cuMemAllocPitch(jcuda.driver.CUdeviceptr, long[], long, long, int), cuMemcpy2D(jcuda.driver.CUDA_MEMCPY2D), cuMemcpy2DAsync(jcuda.driver.CUDA_MEMCPY2D, jcuda.driver.CUstream), cuMemcpy2DUnaligned(jcuda.driver.CUDA_MEMCPY2D), cuMemcpy3D(jcuda.driver.CUDA_MEMCPY3D), cuMemcpy3DAsync(jcuda.driver.CUDA_MEMCPY3D, jcuda.driver.CUstream), cuMemcpyAtoA(jcuda.driver.CUarray, long, jcuda.driver.CUarray, long, long), cuMemcpyAtoD(jcuda.driver.CUdeviceptr, jcuda.driver.CUarray, long, long), cuMemcpyAtoH(jcuda.Pointer, jcuda.driver.CUarray, long, long), cuMemcpyAtoHAsync(jcuda.Pointer, jcuda.driver.CUarray, long, long, jcuda.driver.CUstream), cuMemcpyDtoA(jcuda.driver.CUarray, long, jcuda.driver.CUdeviceptr, long), cuMemcpyDtoD(jcuda.driver.CUdeviceptr, jcuda.driver.CUdeviceptr, long), cuMemcpyDtoDAsync(jcuda.driver.CUdeviceptr, jcuda.driver.CUdeviceptr, long, jcuda.driver.CUstream), cuMemcpyDtoH(jcuda.Pointer, jcuda.driver.CUdeviceptr, long), cuMemcpyDtoHAsync(jcuda.Pointer, jcuda.driver.CUdeviceptr, long, jcuda.driver.CUstream), cuMemcpyHtoA(jcuda.driver.CUarray, long, jcuda.Pointer, long), cuMemcpyHtoAAsync(jcuda.driver.CUarray, long, jcuda.Pointer, long, jcuda.driver.CUstream), cuMemcpyHtoD(jcuda.driver.CUdeviceptr, jcuda.Pointer, long), cuMemcpyHtoDAsync(jcuda.driver.CUdeviceptr, jcuda.Pointer, long, jcuda.driver.CUstream), cuMemFree(jcuda.driver.CUdeviceptr), cuMemFreeHost(jcuda.Pointer), cuMemGetAddressRange(jcuda.driver.CUdeviceptr, long[], jcuda.driver.CUdeviceptr), cuMemGetInfo(long[], long[]), cuMemHostAlloc(jcuda.Pointer, long, int), cuMemHostGetDevicePointer(jcuda.driver.CUdeviceptr, jcuda.Pointer, int), cuMemsetD2D8(jcuda.driver.CUdeviceptr, long, byte, long, long), cuMemsetD2D16(jcuda.driver.CUdeviceptr, long, short, long, long), cuMemsetD2D32(jcuda.driver.CUdeviceptr, long, int, long, long), cuMemsetD8(jcuda.driver.CUdeviceptr, byte, long), cuMemsetD16(jcuda.driver.CUdeviceptr, short, long), cuMemsetD32(jcuda.driver.CUdeviceptr, int, long)

cuArray3DGetDescriptor
```
public static int cuArray3DGetDescriptor(CUDA_ARRAY3D_DESCRIPTOR pArrayDescriptor,
                                         CUarray hArray)
```
Get a 3D CUDA array descriptor.
```
 CUresult cuArray3DGetDescriptor (
      CUDA_ARRAY3D_DESCRIPTOR* pArrayDescriptor,
      CUarray hArray )
 
```
Get a 3D CUDA array descriptor. Returns in *pArrayDescriptor a descriptor containing information on the format and dimensions of the CUDA array 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 Height and/or Depth members of the descriptor struct will be set to 0.

Note:
Note that this function may also return error codes from previous, asynchronous launches.
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

See Also:

cuArray3DCreate(jcuda.driver.CUarray, jcuda.driver.CUDA_ARRAY3D_DESCRIPTOR), cuArrayCreate(jcuda.driver.CUarray, jcuda.driver.CUDA_ARRAY_DESCRIPTOR), cuArrayDestroy(jcuda.driver.CUarray), cuArrayGetDescriptor(jcuda.driver.CUDA_ARRAY_DESCRIPTOR, jcuda.driver.CUarray), cuMemAlloc(jcuda.driver.CUdeviceptr, long), cuMemAllocHost(jcuda.Pointer, long), cuMemAllocPitch(jcuda.driver.CUdeviceptr, long[], long, long, int), cuMemcpy2D(jcuda.driver.CUDA_MEMCPY2D), cuMemcpy2DAsync(jcuda.driver.CUDA_MEMCPY2D, jcuda.driver.CUstream), cuMemcpy2DUnaligned(jcuda.driver.CUDA_MEMCPY2D), cuMemcpy3D(jcuda.driver.CUDA_MEMCPY3D), cuMemcpy3DAsync(jcuda.driver.CUDA_MEMCPY3D, jcuda.driver.CUstream), cuMemcpyAtoA(jcuda.driver.CUarray, long, jcuda.driver.CUarray, long, long), cuMemcpyAtoD(jcuda.driver.CUdeviceptr, jcuda.driver.CUarray, long, long), cuMemcpyAtoH(jcuda.Pointer, jcuda.driver.CUarray, long, long), cuMemcpyAtoHAsync(jcuda.Pointer, jcuda.driver.CUarray, long, long, jcuda.driver.CUstream), cuMemcpyDtoA(jcuda.driver.CUarray, long, jcuda.driver.CUdeviceptr, long), cuMemcpyDtoD(jcuda.driver.CUdeviceptr, jcuda.driver.CUdeviceptr, long), cuMemcpyDtoDAsync(jcuda.driver.CUdeviceptr, jcuda.driver.CUdeviceptr, long, jcuda.driver.CUstream), cuMemcpyDtoH(jcuda.Pointer, jcuda.driver.CUdeviceptr, long), cuMemcpyDtoHAsync(jcuda.Pointer, jcuda.driver.CUdeviceptr, long, jcuda.driver.CUstream), cuMemcpyHtoA(jcuda.driver.CUarray, long, jcuda.Pointer, long), cuMemcpyHtoAAsync(jcuda.driver.CUarray, long, jcuda.Pointer, long, jcuda.driver.CUstream), cuMemcpyHtoD(jcuda.driver.CUdeviceptr, jcuda.Pointer, long), cuMemcpyHtoDAsync(jcuda.driver.CUdeviceptr, jcuda.Pointer, long, jcuda.driver.CUstream), cuMemFree(jcuda.driver.CUdeviceptr), cuMemFreeHost(jcuda.Pointer), cuMemGetAddressRange(jcuda.driver.CUdeviceptr, long[], jcuda.driver.CUdeviceptr), cuMemGetInfo(long[], long[]), cuMemHostAlloc(jcuda.Pointer, long, int), cuMemHostGetDevicePointer(jcuda.driver.CUdeviceptr, jcuda.Pointer, int), cuMemsetD2D8(jcuda.driver.CUdeviceptr, long, byte, long, long), cuMemsetD2D16(jcuda.driver.CUdeviceptr, long, short, long, long), cuMemsetD2D32(jcuda.driver.CUdeviceptr, long, int, long, long), cuMemsetD8(jcuda.driver.CUdeviceptr, byte, long), cuMemsetD16(jcuda.driver.CUdeviceptr, short, long), cuMemsetD32(jcuda.driver.CUdeviceptr, int, long)

cuMipmappedArrayCreate

public static int cuMipmappedArrayCreate(CUmipmappedArray pHandle,
                                         CUDA_ARRAY3D_DESCRIPTOR pMipmappedArrayDesc,
                                         int numMipmapLevels)

Creates a CUDA mipmapped array.

 CUresult cuMipmappedArrayCreate (
      CUmipmappedArray* pHandle,
      const CUDA_ARRAY3D_DESCRIPTOR* pMipmappedArrayDesc,
      unsigned int  numMipmapLevels )

Creates a CUDA mipmapped array. Creates a CUDA mipmapped array according to the CUDA_ARRAY3D_DESCRIPTOR structure pMipmappedArrayDesc and returns a handle to the new CUDA mipmapped array in *pHandle. 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:

Width, Height, and 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 Height and Depth extents are both zero.
- A 2D mipmapped array is allocated if only 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 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. 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 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. 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.

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;

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, 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, Width must be equal to Height, and Depth must be six. If the CUDA_ARRAY3D_LAYERED flag is also set, then 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.

Width, Height and 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)}
1D	{ (1,TEXTURE1D_MIPMAPPED_WIDTH), 0, 0 }
2D	{ (1,TEXTURE2D_MIPMAPPED_WIDTH), (1,TEXTURE2D_MIPMAPPED_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) }
1D Layered	{ (1,TEXTURE1D_LAYERED_WIDTH), 0, (1,TEXTURE1D_LAYERED_LAYERS) }
2D Layered	{ (1,TEXTURE2D_LAYERED_WIDTH), (1,TEXTURE2D_LAYERED_HEIGHT), (1,TEXTURE2D_LAYERED_LAYERS) }
Cubemap	{ (1,TEXTURECUBEMAP_WIDTH), (1,TEXTURECUBEMAP_WIDTH), 6 }
Cubemap Layered	{ (1,TEXTURECUBEMAP_LAYERED_WIDTH), (1,TEXTURECUBEMAP_LAYERED_WIDTH), (1,TEXTURECUBEMAP_LAYERED_LAYERS) }

Note:

Note that this function may also return error codes from previous, asynchronous launches.

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
See Also:: cuMipmappedArrayDestroy(jcuda.driver.CUmipmappedArray), cuMipmappedArrayGetLevel(jcuda.driver.CUarray, jcuda.driver.CUmipmappedArray, int), cuArrayCreate(jcuda.driver.CUarray, jcuda.driver.CUDA_ARRAY_DESCRIPTOR)

cuMipmappedArrayGetLevel
```
public static int cuMipmappedArrayGetLevel(CUarray pLevelArray,
                                           CUmipmappedArray hMipmappedArray,
                                           int level)
```
Gets a mipmap level of a CUDA mipmapped array.
```
 CUresult cuMipmappedArrayGetLevel (
      CUarray* pLevelArray,
      CUmipmappedArray hMipmappedArray,
      unsigned int  level )
 
```
Gets a mipmap level of a CUDA mipmapped array. Returns in *pLevelArray a CUDA array that represents a single mipmap level of the CUDA mipmapped array hMipmappedArray.

If level is greater than the maximum number of levels in this mipmapped array, CUDA_ERROR_INVALID_VALUE is returned.

Note:
Note that this function may also return error codes from previous, asynchronous launches.
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

See Also:

cuMipmappedArrayCreate(jcuda.driver.CUmipmappedArray, jcuda.driver.CUDA_ARRAY3D_DESCRIPTOR, int), cuMipmappedArrayDestroy(jcuda.driver.CUmipmappedArray), cuArrayCreate(jcuda.driver.CUarray, jcuda.driver.CUDA_ARRAY_DESCRIPTOR)

cuMipmappedArrayDestroy
```
public static int cuMipmappedArrayDestroy(CUmipmappedArray hMipmappedArray)
```
Destroys a CUDA mipmapped array.
```
 CUresult cuMipmappedArrayDestroy (
      CUmipmappedArray hMipmappedArray )
 
```
Destroys a CUDA mipmapped array. Destroys the CUDA mipmapped array hMipmappedArray.

Note:
Note that this function may also return error codes from previous, asynchronous launches.
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

See Also:

cuMipmappedArrayCreate(jcuda.driver.CUmipmappedArray, jcuda.driver.CUDA_ARRAY3D_DESCRIPTOR, int), cuMipmappedArrayGetLevel(jcuda.driver.CUarray, jcuda.driver.CUmipmappedArray, int), cuArrayCreate(jcuda.driver.CUarray, jcuda.driver.CUDA_ARRAY_DESCRIPTOR)

cuMemAddressReserve
```
public static int cuMemAddressReserve(CUdeviceptr ptr,
                                      long size,
                                      long alignment,
                                      CUdeviceptr addr,
                                      long flags)
```
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 - Resulting pointer to start of virtual address range allocated

size - Size of the reserved virtual address range requested

alignment - - Alignment of the reserved virtual address range requested

addr - Fixed starting address range requested

flags - 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

See Also:

cuMemAddressFree(jcuda.driver.CUdeviceptr, long)

cuMemAddressFree
```
public static int cuMemAddressFree(CUdeviceptr ptr,
                                   long size)
```
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 - Starting address of the virtual address range to free

size - Size of the virtual address region to free

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

See Also:

cuMemAddressReserve(jcuda.driver.CUdeviceptr, long, long, jcuda.driver.CUdeviceptr, long)

cuMemCreate
```
public static int cuMemCreate(CUmemGenericAllocationHandle handle,
                              long size,
                              CUmemAllocationProp prop,
                              long flags)
```
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 - Value of handle returned. All operations on this allocation are to be performed using this handle.

size - Size of the allocation requested

prop - Properties of the allocation to create.

flags - 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

See Also:

cuMemRelease(jcuda.driver.CUmemGenericAllocationHandle), cuMemExportToShareableHandle(jcuda.Pointer, jcuda.driver.CUmemGenericAllocationHandle, int, long), cuMemImportFromShareableHandle(jcuda.driver.CUmemGenericAllocationHandle, jcuda.Pointer, int)

cuMemRelease
```
public static int cuMemRelease(CUmemGenericAllocationHandle handle)
```
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 - 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

See Also:

cuMemCreate

cuMemMap
```
public static int cuMemMap(CUdeviceptr ptr,
                           long size,
                           long offset,
                           CUmemGenericAllocationHandle handle,
                           long flags)
```
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 - Address where memory will be mapped.

size - Size of the memory mapping.

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

handle - Handle to a shareable memory

flags - 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

See Also:

cuMemUnmap(jcuda.driver.CUdeviceptr, long), cuMemSetAccess(jcuda.driver.CUdeviceptr, long, jcuda.driver.CUmemAccessDesc[], long), cuMemCreate(jcuda.driver.CUmemGenericAllocationHandle, long, jcuda.driver.CUmemAllocationProp, long), cuMemAddressReserve(jcuda.driver.CUdeviceptr, long, long, jcuda.driver.CUdeviceptr, long), cuMemImportFromShareableHandle(jcuda.driver.CUmemGenericAllocationHandle, jcuda.Pointer, int)

cuMemUnmap
```
public static int cuMemUnmap(CUdeviceptr ptr,
                             long size)
```
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 - Starting address for the virtual address range to unmap

size - Size of the virtual address range to unmap

Returns:

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

See Also:

cuMemCreate(jcuda.driver.CUmemGenericAllocationHandle, long, jcuda.driver.CUmemAllocationProp, long), cuMemAddressReserve(jcuda.driver.CUdeviceptr, long, long, jcuda.driver.CUdeviceptr, long)

cuMemSetAccess
```
public static int cuMemSetAccess(CUdeviceptr ptr,
                                 long size,
                                 CUmemAccessDesc[] desc,
                                 long count)
```
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 - Starting address for the virtual address range

size - Length of the virtual address range

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

count - Number of ::CUmemAccessDesc in \p desc

Returns:

CUDA_SUCCESS, CUDA_ERROR_INVALID_VALUE, CUDA_ERROR_INVALID_DEVICE, CUDA_ERROR_NOT_SUPPORTED

See Also:

cuMemSetAccess(jcuda.driver.CUdeviceptr, long, jcuda.driver.CUmemAccessDesc[], long), cuMemCreate(jcuda.driver.CUmemGenericAllocationHandle, long, jcuda.driver.CUmemAllocationProp, long), cuMemMap(jcuda.driver.CUdeviceptr, long, long, jcuda.driver.CUmemGenericAllocationHandle, long)

cuMemGetAccess
```
public static int cuMemGetAccess(long[] flags,
                                 CUmemLocation location,
                                 CUdeviceptr ptr)
```
Get the access \p flags set for the given \p location and \p ptr

Parameters:

flags - Flags set for this location

location - Location in which to check the flags for

ptr - 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

See Also:

cuMemSetAccess(jcuda.driver.CUdeviceptr, long, jcuda.driver.CUmemAccessDesc[], long)

cuMemExportToShareableHandle
```
public static int cuMemExportToShareableHandle(Pointer shareableHandle,
                                               CUmemGenericAllocationHandle handle,
                                               int handleType,
                                               long flags)
```
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 - Pointer to the location in which to store the requested handle type

handle - CUDA handle for the memory allocation

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

flags - 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

See Also:

cuMemImportFromShareableHandle(jcuda.driver.CUmemGenericAllocationHandle, jcuda.Pointer, int)

cuMemImportFromShareableHandle
```
public static int cuMemImportFromShareableHandle(CUmemGenericAllocationHandle handle,
                                                 Pointer osHandle,
                                                 int shHandleType)
```
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 - CUDA Memory handle for the memory allocation.

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

shHandleType - 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

See Also:

cuMemExportToShareableHandle(jcuda.Pointer, jcuda.driver.CUmemGenericAllocationHandle, int, long), cuMemMap(jcuda.driver.CUdeviceptr, long, long, jcuda.driver.CUmemGenericAllocationHandle, long), cuMemRelease(jcuda.driver.CUmemGenericAllocationHandle)

cuMemGetAllocationGranularity
```
public static int cuMemGetAllocationGranularity(long[] granularity,
                                                CUmemAllocationProp prop,
                                                int option)
```
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 - Returned granularity.

prop - Property for which to determine the granularity for

option - 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

See Also:

cuMemCreate(jcuda.driver.CUmemGenericAllocationHandle, long, jcuda.driver.CUmemAllocationProp, long), cuMemMap(jcuda.driver.CUdeviceptr, long, long, jcuda.driver.CUmemGenericAllocationHandle, long)

cuMemGetAllocationPropertiesFromHandle
```
public static int cuMemGetAllocationPropertiesFromHandle(CUmemAllocationProp prop,
                                                         CUmemGenericAllocationHandle handle)
```
Retrieve the contents of the property structure defining properties for this handle

Parameters:

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

handle - 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

See Also:

cuMemCreate(jcuda.driver.CUmemGenericAllocationHandle, long, jcuda.driver.CUmemAllocationProp, long), cuMemImportFromShareableHandle(jcuda.driver.CUmemGenericAllocationHandle, jcuda.Pointer, int)

cuMemRetainAllocationHandle
```
public static int cuMemRetainAllocationHandle(CUmemGenericAllocationHandle handle,
                                              Pointer addr)
```
Given an address addr, returns the allocation handle of the backing memory allocation. The handle is guaranteed to be the same handle value used to map the memory. If the address requested is not mapped, the function will fail. The returned handle must be released with corresponding number of calls to ::cuMemRelease. The address addr, can be any address in a range previously mapped by ::cuMemMap, and not necessarily the start address.

Parameters:

handle - CUDA Memory handle for the backing memory allocation.

addr - Memory address to query, that has been mapped previously.

Returns:

CUDA_SUCCESS, CUDA_ERROR_INVALID_VALUE, CUDA_ERROR_NOT_INITIALIZED, CUDA_ERROR_DEINITIALIZED, CUDA_ERROR_NOT_PERMITTED, CUDA_ERROR_NOT_SUPPORTED

See Also:

cuMemCreate(jcuda.driver.CUmemGenericAllocationHandle, long, jcuda.driver.CUmemAllocationProp, long), cuMemRelease(jcuda.driver.CUmemGenericAllocationHandle), cuMemMap(jcuda.driver.CUdeviceptr, long, long, jcuda.driver.CUmemGenericAllocationHandle, long)

cuTexRefCreate
```
@Deprecated
public static int cuTexRefCreate(CUtexref pTexRef)
```
Deprecated. Deprecated in CUDA
Creates a texture reference.
```
 CUresult cuTexRefCreate (
      CUtexref* pTexRef )
 
```
Creates a texture reference. Deprecated Creates a texture reference and returns its handle in *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.
Parameters:

pTexRef - Returned texture reference

Returns:

CUDA_SUCCESS, CUDA_ERROR_DEINITIALIZED, CUDA_ERROR_NOT_INITIALIZED, CUDA_ERROR_INVALID_CONTEXT, CUDA_ERROR_INVALID_VALUE

See Also:

cuTexRefDestroy(jcuda.driver.CUtexref)

cuTexRefDestroy
```
@Deprecated
public static int cuTexRefDestroy(CUtexref hTexRef)
```
Deprecated. Deprecated in CUDA
Destroys a texture reference.
```
 CUresult cuTexRefDestroy (
      CUtexref hTexRef )
 
```
Destroys a texture reference. Deprecated Destroys the texture reference specified by hTexRef.
Parameters:

hTexRef - Texture reference to destroy

Returns:

CUDA_SUCCESS, CUDA_ERROR_DEINITIALIZED, CUDA_ERROR_NOT_INITIALIZED, CUDA_ERROR_INVALID_CONTEXT, CUDA_ERROR_INVALID_VALUE

See Also:

cuTexRefCreate(jcuda.driver.CUtexref)

cuTexRefSetArray
```
public static int cuTexRefSetArray(CUtexref hTexRef,
                                   CUarray hArray,
                                   int Flags)
```
Deprecated. Deprecated as of CUDA 10.1
Binds an array as a texture reference.
```
 CUresult cuTexRefSetArray (
      CUtexref hTexRef,
      CUarray hArray,
      unsigned int  Flags )
 
```
Binds an array as a texture reference. Binds the CUDA array hArray to the texture reference hTexRef. Any previous address or CUDA array state associated with the texture reference is superseded by this function. Flags must be set to CU_TRSA_OVERRIDE_FORMAT. Any CUDA array previously bound to hTexRef is unbound.
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

See Also:

cuTexRefSetAddress(long[], jcuda.driver.CUtexref, jcuda.driver.CUdeviceptr, long), cuTexRefSetAddress2D(jcuda.driver.CUtexref, jcuda.driver.CUDA_ARRAY_DESCRIPTOR, jcuda.driver.CUdeviceptr, long), cuTexRefSetAddressMode(jcuda.driver.CUtexref, int, int), cuTexRefSetFilterMode(jcuda.driver.CUtexref, int), cuTexRefSetFlags(jcuda.driver.CUtexref, int), cuTexRefSetFormat(jcuda.driver.CUtexref, int, int), cuTexRefGetAddress(jcuda.driver.CUdeviceptr, jcuda.driver.CUtexref), cuTexRefGetAddressMode(int[], jcuda.driver.CUtexref, int), cuTexRefGetArray(jcuda.driver.CUarray, jcuda.driver.CUtexref), cuTexRefGetFilterMode(int[], jcuda.driver.CUtexref), cuTexRefGetFlags(int[], jcuda.driver.CUtexref), cuTexRefGetFormat(int[], int[], jcuda.driver.CUtexref)

cuTexRefSetMipmappedArray
```
public static int cuTexRefSetMipmappedArray(CUtexref hTexRef,
                                            CUmipmappedArray hMipmappedArray,
                                            int Flags)
```
Deprecated. Deprecated as of CUDA 10.1
Binds a mipmapped array to a texture reference.
```
 CUresult cuTexRefSetMipmappedArray (
      CUtexref hTexRef,
      CUmipmappedArray hMipmappedArray,
      unsigned int  Flags )
 
```
Binds a mipmapped array to a texture reference. Binds the CUDA mipmapped array hMipmappedArray to the texture reference hTexRef. Any previous address or CUDA array state associated with the texture reference is superseded by this function. Flags must be set to CU_TRSA_OVERRIDE_FORMAT. Any CUDA array previously bound to hTexRef is unbound.
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

See Also:

cuTexRefSetAddress(long[], jcuda.driver.CUtexref, jcuda.driver.CUdeviceptr, long), cuTexRefSetAddress2D(jcuda.driver.CUtexref, jcuda.driver.CUDA_ARRAY_DESCRIPTOR, jcuda.driver.CUdeviceptr, long), cuTexRefSetAddressMode(jcuda.driver.CUtexref, int, int), cuTexRefSetFilterMode(jcuda.driver.CUtexref, int), cuTexRefSetFlags(jcuda.driver.CUtexref, int), cuTexRefSetFormat(jcuda.driver.CUtexref, int, int), cuTexRefGetAddress(jcuda.driver.CUdeviceptr, jcuda.driver.CUtexref), cuTexRefGetAddressMode(int[], jcuda.driver.CUtexref, int), cuTexRefGetArray(jcuda.driver.CUarray, jcuda.driver.CUtexref), cuTexRefGetFilterMode(int[], jcuda.driver.CUtexref), cuTexRefGetFlags(int[], jcuda.driver.CUtexref), cuTexRefGetFormat(int[], int[], jcuda.driver.CUtexref)

cuTexRefSetAddress
```
public static int cuTexRefSetAddress(long[] ByteOffset,
                                     CUtexref hTexRef,
                                     CUdeviceptr dptr,
                                     long bytes)
```
Deprecated. Deprecated as of CUDA 10.1
Binds an address as a texture reference.
```
 CUresult cuTexRefSetAddress (
      size_t* ByteOffset,
      CUtexref hTexRef,
      CUdeviceptr dptr,
      size_t bytes )
 
```
Binds an address as a texture reference. Binds a linear address range to the texture reference hTexRef. Any previous address or CUDA array state associated with the texture reference is superseded by this function. Any memory previously bound to hTexRef is unbound.

Since the hardware enforces an alignment requirement on texture base addresses, cuTexRefSetAddress() passes back a byte offset in *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 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 (bytes / bytesPerElement), where bytesPerElement is determined from the data format and number of components set using cuTexRefSetFormat().
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

See Also:

cuTexRefSetAddress2D(jcuda.driver.CUtexref, jcuda.driver.CUDA_ARRAY_DESCRIPTOR, jcuda.driver.CUdeviceptr, long), cuTexRefSetAddressMode(jcuda.driver.CUtexref, int, int), cuTexRefSetArray(jcuda.driver.CUtexref, jcuda.driver.CUarray, int), cuTexRefSetFilterMode(jcuda.driver.CUtexref, int), cuTexRefSetFlags(jcuda.driver.CUtexref, int), cuTexRefSetFormat(jcuda.driver.CUtexref, int, int), cuTexRefGetAddress(jcuda.driver.CUdeviceptr, jcuda.driver.CUtexref), cuTexRefGetAddressMode(int[], jcuda.driver.CUtexref, int), cuTexRefGetArray(jcuda.driver.CUarray, jcuda.driver.CUtexref), cuTexRefGetFilterMode(int[], jcuda.driver.CUtexref), cuTexRefGetFlags(int[], jcuda.driver.CUtexref), cuTexRefGetFormat(int[], int[], jcuda.driver.CUtexref)

cuTexRefSetFormat
```
public static int cuTexRefSetFormat(CUtexref hTexRef,
                                    int fmt,
                                    int NumPackedComponents)
```
Deprecated. Deprecated as of CUDA 10.1
Sets the format for a texture reference.
```
 CUresult cuTexRefSetFormat (
      CUtexref hTexRef,
      CUarray_format fmt,
      int  NumPackedComponents )
 
```
Sets the format for a texture reference. Specifies the format of the data to be read by the texture reference hTexRef. fmt and 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.
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

See Also:

cuTexRefSetAddress(long[], jcuda.driver.CUtexref, jcuda.driver.CUdeviceptr, long), cuTexRefSetAddress2D(jcuda.driver.CUtexref, jcuda.driver.CUDA_ARRAY_DESCRIPTOR, jcuda.driver.CUdeviceptr, long), cuTexRefSetAddressMode(jcuda.driver.CUtexref, int, int), cuTexRefSetArray(jcuda.driver.CUtexref, jcuda.driver.CUarray, int), cuTexRefSetFilterMode(jcuda.driver.CUtexref, int), cuTexRefSetFlags(jcuda.driver.CUtexref, int), cuTexRefGetAddress(jcuda.driver.CUdeviceptr, jcuda.driver.CUtexref), cuTexRefGetAddressMode(int[], jcuda.driver.CUtexref, int), cuTexRefGetArray(jcuda.driver.CUarray, jcuda.driver.CUtexref), cuTexRefGetFilterMode(int[], jcuda.driver.CUtexref), cuTexRefGetFlags(int[], jcuda.driver.CUtexref), cuTexRefGetFormat(int[], int[], jcuda.driver.CUtexref)

cuTexRefSetAddress2D
```
public static int cuTexRefSetAddress2D(CUtexref hTexRef,
                                       CUDA_ARRAY_DESCRIPTOR desc,
                                       CUdeviceptr dptr,
                                       long PitchInBytes)
```
Deprecated. Deprecated as of CUDA 10.1
Binds an address as a 2D texture reference.
```
 CUresult cuTexRefSetAddress2D (
      CUtexref hTexRef,
      const CUDA_ARRAY_DESCRIPTOR* desc,
      CUdeviceptr dptr,
      size_t Pitch )
 
```
Binds an address as a 2D texture reference. Binds a linear address range to the texture reference hTexRef. Any previous address or CUDA array state associated with the texture reference is superseded by this function. Any memory previously bound to 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 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 dptr is supplied, CUDA_ERROR_INVALID_VALUE is returned.

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 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. Pitch, which is specified in bytes, cannot exceed CU_DEVICE_ATTRIBUTE_MAXIMUM_TEXTURE2D_LINEAR_PITCH.
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

See Also:

cuTexRefSetAddress(long[], jcuda.driver.CUtexref, jcuda.driver.CUdeviceptr, long), cuTexRefSetAddressMode(jcuda.driver.CUtexref, int, int), cuTexRefSetArray(jcuda.driver.CUtexref, jcuda.driver.CUarray, int), cuTexRefSetFilterMode(jcuda.driver.CUtexref, int), cuTexRefSetFlags(jcuda.driver.CUtexref, int), cuTexRefSetFormat(jcuda.driver.CUtexref, int, int), cuTexRefGetAddress(jcuda.driver.CUdeviceptr, jcuda.driver.CUtexref), cuTexRefGetAddressMode(int[], jcuda.driver.CUtexref, int), cuTexRefGetArray(jcuda.driver.CUarray, jcuda.driver.CUtexref), cuTexRefGetFilterMode(int[], jcuda.driver.CUtexref), cuTexRefGetFlags(int[], jcuda.driver.CUtexref), cuTexRefGetFormat(int[], int[], jcuda.driver.CUtexref)

cuTexRefSetAddressMode
```
public static int cuTexRefSetAddressMode(CUtexref hTexRef,
                                         int dim,
                                         int am)
```
Deprecated. Deprecated as of CUDA 10.1
Sets the addressing mode for a texture reference.
```
 CUresult cuTexRefSetAddressMode (
      CUtexref hTexRef,
      int  dim,
      CUaddress_mode am )
 
```
Sets the addressing mode for a texture reference. Specifies the addressing mode am for the given dimension dim of the texture reference hTexRef. If dim is zero, the addressing mode is applied to the first parameter of the functions used to fetch from the texture; if 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 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.
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

See Also:

cuTexRefSetAddress(long[], jcuda.driver.CUtexref, jcuda.driver.CUdeviceptr, long), cuTexRefSetAddress2D(jcuda.driver.CUtexref, jcuda.driver.CUDA_ARRAY_DESCRIPTOR, jcuda.driver.CUdeviceptr, long), cuTexRefSetArray(jcuda.driver.CUtexref, jcuda.driver.CUarray, int), cuTexRefSetFilterMode(jcuda.driver.CUtexref, int), cuTexRefSetFlags(jcuda.driver.CUtexref, int), cuTexRefSetFormat(jcuda.driver.CUtexref, int, int), cuTexRefGetAddress(jcuda.driver.CUdeviceptr, jcuda.driver.CUtexref), cuTexRefGetAddressMode(int[], jcuda.driver.CUtexref, int), cuTexRefGetArray(jcuda.driver.CUarray, jcuda.driver.CUtexref), cuTexRefGetFilterMode(int[], jcuda.driver.CUtexref), cuTexRefGetFlags(int[], jcuda.driver.CUtexref), cuTexRefGetFormat(int[], int[], jcuda.driver.CUtexref)

cuTexRefSetFilterMode
```
public static int cuTexRefSetFilterMode(CUtexref hTexRef,
                                        int fm)
```
Deprecated. Deprecated as of CUDA 10.1
Sets the filtering mode for a texture reference.
```
 CUresult cuTexRefSetFilterMode (
      CUtexref hTexRef,
      CUfilter_mode fm )
 
```
Sets the filtering mode for a texture reference. Specifies the filtering mode fm to be used when reading memory through the texture reference 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 hTexRef is bound to linear memory.
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

See Also:

cuTexRefSetAddress(long[], jcuda.driver.CUtexref, jcuda.driver.CUdeviceptr, long), cuTexRefSetAddress2D(jcuda.driver.CUtexref, jcuda.driver.CUDA_ARRAY_DESCRIPTOR, jcuda.driver.CUdeviceptr, long), cuTexRefSetAddressMode(jcuda.driver.CUtexref, int, int), cuTexRefSetArray(jcuda.driver.CUtexref, jcuda.driver.CUarray, int), cuTexRefSetFlags(jcuda.driver.CUtexref, int), cuTexRefSetFormat(jcuda.driver.CUtexref, int, int), cuTexRefGetAddress(jcuda.driver.CUdeviceptr, jcuda.driver.CUtexref), cuTexRefGetAddressMode(int[], jcuda.driver.CUtexref, int), cuTexRefGetArray(jcuda.driver.CUarray, jcuda.driver.CUtexref), cuTexRefGetFilterMode(int[], jcuda.driver.CUtexref), cuTexRefGetFlags(int[], jcuda.driver.CUtexref), cuTexRefGetFormat(int[], int[], jcuda.driver.CUtexref)

cuTexRefSetMipmapFilterMode
```
public static int cuTexRefSetMipmapFilterMode(CUtexref hTexRef,
                                              int fm)
```
Deprecated. Deprecated as of CUDA 10.1
Sets the mipmap filtering mode for a texture reference.
```
 CUresult cuTexRefSetMipmapFilterMode (
      CUtexref hTexRef,
      CUfilter_mode fm )
 
```
Sets the mipmap filtering mode for a texture reference. Specifies the mipmap filtering mode fm to be used when reading memory through the texture reference 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 hTexRef is not bound to a mipmapped array.
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

See Also:

cuTexRefSetAddress(long[], jcuda.driver.CUtexref, jcuda.driver.CUdeviceptr, long), cuTexRefSetAddress2D(jcuda.driver.CUtexref, jcuda.driver.CUDA_ARRAY_DESCRIPTOR, jcuda.driver.CUdeviceptr, long), cuTexRefSetAddressMode(jcuda.driver.CUtexref, int, int), cuTexRefSetArray(jcuda.driver.CUtexref, jcuda.driver.CUarray, int), cuTexRefSetFlags(jcuda.driver.CUtexref, int), cuTexRefSetFormat(jcuda.driver.CUtexref, int, int), cuTexRefGetAddress(jcuda.driver.CUdeviceptr, jcuda.driver.CUtexref), cuTexRefGetAddressMode(int[], jcuda.driver.CUtexref, int), cuTexRefGetArray(jcuda.driver.CUarray, jcuda.driver.CUtexref), cuTexRefGetFilterMode(int[], jcuda.driver.CUtexref), cuTexRefGetFlags(int[], jcuda.driver.CUtexref), cuTexRefGetFormat(int[], int[], jcuda.driver.CUtexref)

cuTexRefSetMipmapLevelBias
```
public static int cuTexRefSetMipmapLevelBias(CUtexref hTexRef,
                                             float bias)
```
Deprecated. Deprecated as of CUDA 10.1
Sets the mipmap level bias for a texture reference.
```
 CUresult cuTexRefSetMipmapLevelBias (
      CUtexref hTexRef,
      float  bias )
 
```
Sets the mipmap level bias for a texture reference. Specifies the mipmap level bias bias to be added to the specified mipmap level when reading memory through the texture reference hTexRef.

Note that this call has no effect if hTexRef is not bound to a mipmapped array.
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

See Also:

cuTexRefSetAddress(long[], jcuda.driver.CUtexref, jcuda.driver.CUdeviceptr, long), cuTexRefSetAddress2D(jcuda.driver.CUtexref, jcuda.driver.CUDA_ARRAY_DESCRIPTOR, jcuda.driver.CUdeviceptr, long), cuTexRefSetAddressMode(jcuda.driver.CUtexref, int, int), cuTexRefSetArray(jcuda.driver.CUtexref, jcuda.driver.CUarray, int), cuTexRefSetFlags(jcuda.driver.CUtexref, int), cuTexRefSetFormat(jcuda.driver.CUtexref, int, int), cuTexRefGetAddress(jcuda.driver.CUdeviceptr, jcuda.driver.CUtexref), cuTexRefGetAddressMode(int[], jcuda.driver.CUtexref, int), cuTexRefGetArray(jcuda.driver.CUarray, jcuda.driver.CUtexref), cuTexRefGetFilterMode(int[], jcuda.driver.CUtexref), cuTexRefGetFlags(int[], jcuda.driver.CUtexref), cuTexRefGetFormat(int[], int[], jcuda.driver.CUtexref)

cuTexRefSetMipmapLevelClamp
```
public static int cuTexRefSetMipmapLevelClamp(CUtexref hTexRef,
                                              float minMipmapLevelClamp,
                                              float maxMipmapLevelClamp)
```
Deprecated. Deprecated as of CUDA 10.1
Sets the mipmap min/max mipmap level clamps for a texture reference.
```
 CUresult cuTexRefSetMipmapLevelClamp (
      CUtexref hTexRef,
      float  minMipmapLevelClamp,
      float  maxMipmapLevelClamp )
 
```
Sets the mipmap min/max mipmap level clamps for a texture reference. Specifies the min/max mipmap level clamps, minMipmapLevelClamp and maxMipmapLevelClamp respectively, to be used when reading memory through the texture reference hTexRef.

Note that this call has no effect if hTexRef is not bound to a mipmapped array.
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

See Also:

cuTexRefSetAddress(long[], jcuda.driver.CUtexref, jcuda.driver.CUdeviceptr, long), cuTexRefSetAddress2D(jcuda.driver.CUtexref, jcuda.driver.CUDA_ARRAY_DESCRIPTOR, jcuda.driver.CUdeviceptr, long), cuTexRefSetAddressMode(jcuda.driver.CUtexref, int, int), cuTexRefSetArray(jcuda.driver.CUtexref, jcuda.driver.CUarray, int), cuTexRefSetFlags(jcuda.driver.CUtexref, int), cuTexRefSetFormat(jcuda.driver.CUtexref, int, int), cuTexRefGetAddress(jcuda.driver.CUdeviceptr, jcuda.driver.CUtexref), cuTexRefGetAddressMode(int[], jcuda.driver.CUtexref, int), cuTexRefGetArray(jcuda.driver.CUarray, jcuda.driver.CUtexref), cuTexRefGetFilterMode(int[], jcuda.driver.CUtexref), cuTexRefGetFlags(int[], jcuda.driver.CUtexref), cuTexRefGetFormat(int[], int[], jcuda.driver.CUtexref)

cuTexRefSetMaxAnisotropy
```
public static int cuTexRefSetMaxAnisotropy(CUtexref hTexRef,
                                           int maxAniso)
```
Deprecated. Deprecated as of CUDA 10.1
Sets the maximum anistropy for a texture reference.
```
 CUresult cuTexRefSetMaxAnisotropy (
      CUtexref hTexRef,
      unsigned int  maxAniso )
 
```
Sets the maximum anistropy for a texture reference. Specifies the maximum aniostropy maxAniso to be used when reading memory through the texture reference hTexRef.

Note that this call has no effect if hTexRef is bound to linear memory.
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

See Also:

cuTexRefSetAddress(long[], jcuda.driver.CUtexref, jcuda.driver.CUdeviceptr, long), cuTexRefSetAddress2D(jcuda.driver.CUtexref, jcuda.driver.CUDA_ARRAY_DESCRIPTOR, jcuda.driver.CUdeviceptr, long), cuTexRefSetAddressMode(jcuda.driver.CUtexref, int, int), cuTexRefSetArray(jcuda.driver.CUtexref, jcuda.driver.CUarray, int), cuTexRefSetFlags(jcuda.driver.CUtexref, int), cuTexRefSetFormat(jcuda.driver.CUtexref, int, int), cuTexRefGetAddress(jcuda.driver.CUdeviceptr, jcuda.driver.CUtexref), cuTexRefGetAddressMode(int[], jcuda.driver.CUtexref, int), cuTexRefGetArray(jcuda.driver.CUarray, jcuda.driver.CUtexref), cuTexRefGetFilterMode(int[], jcuda.driver.CUtexref), cuTexRefGetFlags(int[], jcuda.driver.CUtexref), cuTexRefGetFormat(int[], int[], jcuda.driver.CUtexref)

cuTexRefSetBorderColor
```
public static int cuTexRefSetBorderColor(CUtexref hTexRef,
                                         float[] pBorderColor)
```
Deprecated. Deprecated as of CUDA 10.1

Sets the border color for a texture reference

Specifies the value of the RGBA color via the pBorderColor to the texture reference 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.

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

See Also:

cuTexRefSetAddressMode(jcuda.driver.CUtexref, int, int), cuTexRefGetAddressMode(int[], jcuda.driver.CUtexref, int), cuTexRefGetBorderColor(float[], jcuda.driver.CUtexref)

cuTexRefSetFlags
```
public static int cuTexRefSetFlags(CUtexref hTexRef,
                                   int Flags)
```
Deprecated. Deprecated as of CUDA 10.1
Sets the flags for a texture reference.
```
 CUresult cuTexRefSetFlags (
      CUtexref hTexRef,
      unsigned int  Flags )
 
```
Sets the flags for a texture reference. Specifies optional flags via Flags to specify the behavior of data returned through the texture reference 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;
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

See Also:

cuTexRefSetAddress(long[], jcuda.driver.CUtexref, jcuda.driver.CUdeviceptr, long), cuTexRefSetAddress2D(jcuda.driver.CUtexref, jcuda.driver.CUDA_ARRAY_DESCRIPTOR, jcuda.driver.CUdeviceptr, long), cuTexRefSetAddressMode(jcuda.driver.CUtexref, int, int), cuTexRefSetArray(jcuda.driver.CUtexref, jcuda.driver.CUarray, int), cuTexRefSetFilterMode(jcuda.driver.CUtexref, int), cuTexRefSetFormat(jcuda.driver.CUtexref, int, int), cuTexRefGetAddress(jcuda.driver.CUdeviceptr, jcuda.driver.CUtexref), cuTexRefGetAddressMode(int[], jcuda.driver.CUtexref, int), cuTexRefGetArray(jcuda.driver.CUarray, jcuda.driver.CUtexref), cuTexRefGetFilterMode(int[], jcuda.driver.CUtexref), cuTexRefGetFlags(int[], jcuda.driver.CUtexref), cuTexRefGetFormat(int[], int[], jcuda.driver.CUtexref)

cuTexRefGetAddress
```
public static int cuTexRefGetAddress(CUdeviceptr pdptr,
                                     CUtexref hTexRef)
```
Deprecated. Deprecated as of CUDA 10.1
Gets the address associated with a texture reference.
```
 CUresult cuTexRefGetAddress (
      CUdeviceptr* pdptr,
      CUtexref hTexRef )
 
```
Gets the address associated with a texture reference. Returns in *pdptr the base address bound to the texture reference hTexRef, or returns CUDA_ERROR_INVALID_VALUE if the texture reference is not bound to any device memory range.
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

See Also:

cuTexRefSetAddress(long[], jcuda.driver.CUtexref, jcuda.driver.CUdeviceptr, long), cuTexRefSetAddress2D(jcuda.driver.CUtexref, jcuda.driver.CUDA_ARRAY_DESCRIPTOR, jcuda.driver.CUdeviceptr, long), cuTexRefSetAddressMode(jcuda.driver.CUtexref, int, int), cuTexRefSetArray(jcuda.driver.CUtexref, jcuda.driver.CUarray, int), cuTexRefSetFilterMode(jcuda.driver.CUtexref, int), cuTexRefSetFlags(jcuda.driver.CUtexref, int), cuTexRefSetFormat(jcuda.driver.CUtexref, int, int), cuTexRefGetAddressMode(int[], jcuda.driver.CUtexref, int), cuTexRefGetArray(jcuda.driver.CUarray, jcuda.driver.CUtexref), cuTexRefGetFilterMode(int[], jcuda.driver.CUtexref), cuTexRefGetFlags(int[], jcuda.driver.CUtexref), cuTexRefGetFormat(int[], int[], jcuda.driver.CUtexref)

cuTexRefGetArray
```
public static int cuTexRefGetArray(CUarray phArray,
                                   CUtexref hTexRef)
```
Deprecated. Deprecated as of CUDA 10.1
Gets the array bound to a texture reference.
```
 CUresult cuTexRefGetArray (
      CUarray* phArray,
      CUtexref hTexRef )
 
```
Gets the array bound to a texture reference. Returns in *phArray the CUDA array bound to the texture reference hTexRef, or returns CUDA_ERROR_INVALID_VALUE if the texture reference is not bound to any CUDA array.
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

See Also:

cuTexRefSetAddress(long[], jcuda.driver.CUtexref, jcuda.driver.CUdeviceptr, long), cuTexRefSetAddress2D(jcuda.driver.CUtexref, jcuda.driver.CUDA_ARRAY_DESCRIPTOR, jcuda.driver.CUdeviceptr, long), cuTexRefSetAddressMode(jcuda.driver.CUtexref, int, int), cuTexRefSetArray(jcuda.driver.CUtexref, jcuda.driver.CUarray, int), cuTexRefSetFilterMode(jcuda.driver.CUtexref, int), cuTexRefSetFlags(jcuda.driver.CUtexref, int), cuTexRefSetFormat(jcuda.driver.CUtexref, int, int), cuTexRefGetAddress(jcuda.driver.CUdeviceptr, jcuda.driver.CUtexref), cuTexRefGetAddressMode(int[], jcuda.driver.CUtexref, int), cuTexRefGetFilterMode(int[], jcuda.driver.CUtexref), cuTexRefGetFlags(int[], jcuda.driver.CUtexref), cuTexRefGetFormat(int[], int[], jcuda.driver.CUtexref)

cuTexRefGetMipmappedArray
```
public static int cuTexRefGetMipmappedArray(CUmipmappedArray phMipmappedArray,
                                            CUtexref hTexRef)
```
Deprecated. Deprecated as of CUDA 10.1
Gets the mipmapped array bound to a texture reference.
```
 CUresult cuTexRefGetMipmappedArray (
      CUmipmappedArray* phMipmappedArray,
      CUtexref hTexRef )
 
```
Gets the mipmapped array bound to a texture reference. Returns in *phMipmappedArray the CUDA mipmapped array bound to the texture reference hTexRef, or returns CUDA_ERROR_INVALID_VALUE if the texture reference is not bound to any CUDA mipmapped array.
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

See Also:

cuTexRefSetAddress(long[], jcuda.driver.CUtexref, jcuda.driver.CUdeviceptr, long), cuTexRefSetAddress2D(jcuda.driver.CUtexref, jcuda.driver.CUDA_ARRAY_DESCRIPTOR, jcuda.driver.CUdeviceptr, long), cuTexRefSetAddressMode(jcuda.driver.CUtexref, int, int), cuTexRefSetArray(jcuda.driver.CUtexref, jcuda.driver.CUarray, int), cuTexRefSetFilterMode(jcuda.driver.CUtexref, int), cuTexRefSetFlags(jcuda.driver.CUtexref, int), cuTexRefSetFormat(jcuda.driver.CUtexref, int, int), cuTexRefGetAddress(jcuda.driver.CUdeviceptr, jcuda.driver.CUtexref), cuTexRefGetAddressMode(int[], jcuda.driver.CUtexref, int), cuTexRefGetFilterMode(int[], jcuda.driver.CUtexref), cuTexRefGetFlags(int[], jcuda.driver.CUtexref), cuTexRefGetFormat(int[], int[], jcuda.driver.CUtexref)

cuTexRefGetAddressMode
```
public static int cuTexRefGetAddressMode(int[] pam,
                                         CUtexref hTexRef,
                                         int dim)
```
Deprecated. Deprecated as of CUDA 10.1
Gets the addressing mode used by a texture reference.
```
 CUresult cuTexRefGetAddressMode (
      CUaddress_mode* pam,
      CUtexref hTexRef,
      int  dim )
 
```
Gets the addressing mode used by a texture reference. Returns in *pam the addressing mode corresponding to the dimension dim of the texture reference hTexRef. Currently, the only valid value for dim are 0 and 1.
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

See Also:

cuTexRefSetAddress(long[], jcuda.driver.CUtexref, jcuda.driver.CUdeviceptr, long), cuTexRefSetAddress2D(jcuda.driver.CUtexref, jcuda.driver.CUDA_ARRAY_DESCRIPTOR, jcuda.driver.CUdeviceptr, long), cuTexRefSetAddressMode(jcuda.driver.CUtexref, int, int), cuTexRefSetArray(jcuda.driver.CUtexref, jcuda.driver.CUarray, int), cuTexRefSetFilterMode(jcuda.driver.CUtexref, int), cuTexRefSetFlags(jcuda.driver.CUtexref, int), cuTexRefSetFormat(jcuda.driver.CUtexref, int, int), cuTexRefGetAddress(jcuda.driver.CUdeviceptr, jcuda.driver.CUtexref), cuTexRefGetArray(jcuda.driver.CUarray, jcuda.driver.CUtexref), cuTexRefGetFilterMode(int[], jcuda.driver.CUtexref), cuTexRefGetFlags(int[], jcuda.driver.CUtexref), cuTexRefGetFormat(int[], int[], jcuda.driver.CUtexref)

cuTexRefGetFilterMode
```
public static int cuTexRefGetFilterMode(int[] pfm,
                                        CUtexref hTexRef)
```
Deprecated. Deprecated as of CUDA 10.1
Gets the filter-mode used by a texture reference.
```
 CUresult cuTexRefGetFilterMode (
      CUfilter_mode* pfm,
      CUtexref hTexRef )
 
```
Gets the filter-mode used by a texture reference. Returns in *pfm the filtering mode of the texture reference hTexRef.
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

See Also:

cuTexRefSetAddress(long[], jcuda.driver.CUtexref, jcuda.driver.CUdeviceptr, long), cuTexRefSetAddress2D(jcuda.driver.CUtexref, jcuda.driver.CUDA_ARRAY_DESCRIPTOR, jcuda.driver.CUdeviceptr, long), cuTexRefSetAddressMode(jcuda.driver.CUtexref, int, int), cuTexRefSetArray(jcuda.driver.CUtexref, jcuda.driver.CUarray, int), cuTexRefSetFilterMode(jcuda.driver.CUtexref, int), cuTexRefSetFlags(jcuda.driver.CUtexref, int), cuTexRefSetFormat(jcuda.driver.CUtexref, int, int), cuTexRefGetAddress(jcuda.driver.CUdeviceptr, jcuda.driver.CUtexref), cuTexRefGetAddressMode(int[], jcuda.driver.CUtexref, int), cuTexRefGetArray(jcuda.driver.CUarray, jcuda.driver.CUtexref), cuTexRefGetFlags(int[], jcuda.driver.CUtexref), cuTexRefGetFormat(int[], int[], jcuda.driver.CUtexref)

cuTexRefGetFormat
```
public static int cuTexRefGetFormat(int[] pFormat,
                                    int[] pNumChannels,
                                    CUtexref hTexRef)
```
Deprecated. Deprecated as of CUDA 10.1
Gets the format used by a texture reference.
```
 CUresult cuTexRefGetFormat (
      CUarray_format* pFormat,
      int* pNumChannels,
      CUtexref hTexRef )
 
```
Gets the format used by a texture reference. Returns in *pFormat and *pNumChannels the format and number of components of the CUDA array bound to the texture reference hTexRef. If pFormat or pNumChannels is NULL, it will be ignored.
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

See Also:

cuTexRefSetAddress(long[], jcuda.driver.CUtexref, jcuda.driver.CUdeviceptr, long), cuTexRefSetAddress2D(jcuda.driver.CUtexref, jcuda.driver.CUDA_ARRAY_DESCRIPTOR, jcuda.driver.CUdeviceptr, long), cuTexRefSetAddressMode(jcuda.driver.CUtexref, int, int), cuTexRefSetArray(jcuda.driver.CUtexref, jcuda.driver.CUarray, int), cuTexRefSetFilterMode(jcuda.driver.CUtexref, int), cuTexRefSetFlags(jcuda.driver.CUtexref, int), cuTexRefSetFormat(jcuda.driver.CUtexref, int, int), cuTexRefGetAddress(jcuda.driver.CUdeviceptr, jcuda.driver.CUtexref), cuTexRefGetAddressMode(int[], jcuda.driver.CUtexref, int), cuTexRefGetArray(jcuda.driver.CUarray, jcuda.driver.CUtexref), cuTexRefGetFilterMode(int[], jcuda.driver.CUtexref), cuTexRefGetFlags(int[], jcuda.driver.CUtexref)

cuTexRefGetMipmapFilterMode
```
public static int cuTexRefGetMipmapFilterMode(int[] pfm,
                                              CUtexref hTexRef)
```
Deprecated. Deprecated as of CUDA 10.1
Gets the mipmap filtering mode for a texture reference.
```
 CUresult cuTexRefGetMipmapFilterMode (
      CUfilter_mode* pfm,
      CUtexref hTexRef )
 
```
Gets the mipmap filtering mode for a texture reference. Returns the mipmap filtering mode in pfm that's used when reading memory through the texture reference hTexRef.
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

See Also:

cuTexRefSetAddress(long[], jcuda.driver.CUtexref, jcuda.driver.CUdeviceptr, long), cuTexRefSetAddress2D(jcuda.driver.CUtexref, jcuda.driver.CUDA_ARRAY_DESCRIPTOR, jcuda.driver.CUdeviceptr, long), cuTexRefSetAddressMode(jcuda.driver.CUtexref, int, int), cuTexRefSetArray(jcuda.driver.CUtexref, jcuda.driver.CUarray, int), cuTexRefSetFlags(jcuda.driver.CUtexref, int), cuTexRefSetFormat(jcuda.driver.CUtexref, int, int), cuTexRefGetAddress(jcuda.driver.CUdeviceptr, jcuda.driver.CUtexref), cuTexRefGetAddressMode(int[], jcuda.driver.CUtexref, int), cuTexRefGetArray(jcuda.driver.CUarray, jcuda.driver.CUtexref), cuTexRefGetFilterMode(int[], jcuda.driver.CUtexref), cuTexRefGetFlags(int[], jcuda.driver.CUtexref), cuTexRefGetFormat(int[], int[], jcuda.driver.CUtexref)

cuTexRefGetMipmapLevelBias
```
public static int cuTexRefGetMipmapLevelBias(float[] pbias,
                                             CUtexref hTexRef)
```
Deprecated. Deprecated as of CUDA 10.1
Gets the mipmap level bias for a texture reference.
```
 CUresult cuTexRefGetMipmapLevelBias (
      float* pbias,
      CUtexref hTexRef )
 
```
Gets the mipmap level bias for a texture reference. Returns the mipmap level bias in pBias that's added to the specified mipmap level when reading memory through the texture reference hTexRef.
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

See Also:

cuTexRefSetAddress(long[], jcuda.driver.CUtexref, jcuda.driver.CUdeviceptr, long), cuTexRefSetAddress2D(jcuda.driver.CUtexref, jcuda.driver.CUDA_ARRAY_DESCRIPTOR, jcuda.driver.CUdeviceptr, long), cuTexRefSetAddressMode(jcuda.driver.CUtexref, int, int), cuTexRefSetArray(jcuda.driver.CUtexref, jcuda.driver.CUarray, int), cuTexRefSetFlags(jcuda.driver.CUtexref, int), cuTexRefSetFormat(jcuda.driver.CUtexref, int, int), cuTexRefGetAddress(jcuda.driver.CUdeviceptr, jcuda.driver.CUtexref), cuTexRefGetAddressMode(int[], jcuda.driver.CUtexref, int), cuTexRefGetArray(jcuda.driver.CUarray, jcuda.driver.CUtexref), cuTexRefGetFilterMode(int[], jcuda.driver.CUtexref), cuTexRefGetFlags(int[], jcuda.driver.CUtexref), cuTexRefGetFormat(int[], int[], jcuda.driver.CUtexref)

cuTexRefGetMipmapLevelClamp
```
public static int cuTexRefGetMipmapLevelClamp(float[] pminMipmapLevelClamp,
                                              float[] pmaxMipmapLevelClamp,
                                              CUtexref hTexRef)
```
Deprecated. Deprecated as of CUDA 10.1
Gets the min/max mipmap level clamps for a texture reference.
```
 CUresult cuTexRefGetMipmapLevelClamp (
      float* pminMipmapLevelClamp,
      float* pmaxMipmapLevelClamp,
      CUtexref hTexRef )
 
```
Gets the min/max mipmap level clamps for a texture reference. Returns the min/max mipmap level clamps in pminMipmapLevelClamp and pmaxMipmapLevelClamp that's used when reading memory through the texture reference hTexRef.
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

See Also:

cuTexRefSetAddress(long[], jcuda.driver.CUtexref, jcuda.driver.CUdeviceptr, long), cuTexRefSetAddress2D(jcuda.driver.CUtexref, jcuda.driver.CUDA_ARRAY_DESCRIPTOR, jcuda.driver.CUdeviceptr, long), cuTexRefSetAddressMode(jcuda.driver.CUtexref, int, int), cuTexRefSetArray(jcuda.driver.CUtexref, jcuda.driver.CUarray, int), cuTexRefSetFlags(jcuda.driver.CUtexref, int), cuTexRefSetFormat(jcuda.driver.CUtexref, int, int), cuTexRefGetAddress(jcuda.driver.CUdeviceptr, jcuda.driver.CUtexref), cuTexRefGetAddressMode(int[], jcuda.driver.CUtexref, int), cuTexRefGetArray(jcuda.driver.CUarray, jcuda.driver.CUtexref), cuTexRefGetFilterMode(int[], jcuda.driver.CUtexref), cuTexRefGetFlags(int[], jcuda.driver.CUtexref), cuTexRefGetFormat(int[], int[], jcuda.driver.CUtexref)

cuTexRefGetMaxAnisotropy
```
public static int cuTexRefGetMaxAnisotropy(int[] pmaxAniso,
                                           CUtexref hTexRef)
```
Deprecated. Deprecated as of CUDA 10.1
Gets the maximum anistropy for a texture reference.
```
 CUresult cuTexRefGetMaxAnisotropy (
      int* pmaxAniso,
      CUtexref hTexRef )
 
```
Gets the maximum anistropy for a texture reference. Returns the maximum aniostropy in pmaxAniso that's used when reading memory through the texture reference hTexRef.
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

See Also:

cuTexRefSetAddress(long[], jcuda.driver.CUtexref, jcuda.driver.CUdeviceptr, long), cuTexRefSetAddress2D(jcuda.driver.CUtexref, jcuda.driver.CUDA_ARRAY_DESCRIPTOR, jcuda.driver.CUdeviceptr, long), cuTexRefSetAddressMode(jcuda.driver.CUtexref, int, int), cuTexRefSetArray(jcuda.driver.CUtexref, jcuda.driver.CUarray, int), cuTexRefSetFlags(jcuda.driver.CUtexref, int), cuTexRefSetFormat(jcuda.driver.CUtexref, int, int), cuTexRefGetAddress(jcuda.driver.CUdeviceptr, jcuda.driver.CUtexref), cuTexRefGetAddressMode(int[], jcuda.driver.CUtexref, int), cuTexRefGetArray(jcuda.driver.CUarray, jcuda.driver.CUtexref), cuTexRefGetFilterMode(int[], jcuda.driver.CUtexref), cuTexRefGetFlags(int[], jcuda.driver.CUtexref), cuTexRefGetFormat(int[], int[], jcuda.driver.CUtexref)

cuTexRefGetBorderColor
```
public static int cuTexRefGetBorderColor(float[] pBorderColor,
                                         CUtexref hTexRef)
```
Deprecated. Deprecated as of CUDA 10.1

brief Gets the border color used by a texture reference

Returns in pBorderColor, values of the RGBA color used by the texture reference 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

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

See Also:

cuTexRefSetAddressMode(jcuda.driver.CUtexref, int, int), cuTexRefSetAddressMode(jcuda.driver.CUtexref, int, int), cuTexRefSetBorderColor(jcuda.driver.CUtexref, float[])

cuTexRefGetFlags
```
public static int cuTexRefGetFlags(int[] pFlags,
                                   CUtexref hTexRef)
```
Deprecated. Deprecated as of CUDA 10.1
Gets the flags used by a texture reference.
```
 CUresult cuTexRefGetFlags (
      unsigned int* pFlags,
      CUtexref hTexRef )
 
```
Gets the flags used by a texture reference. Returns in *pFlags the flags of the texture reference hTexRef.
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

See Also:

cuTexRefSetAddress(long[], jcuda.driver.CUtexref, jcuda.driver.CUdeviceptr, long), cuTexRefSetAddress2D(jcuda.driver.CUtexref, jcuda.driver.CUDA_ARRAY_DESCRIPTOR, jcuda.driver.CUdeviceptr, long), cuTexRefSetAddressMode(jcuda.driver.CUtexref, int, int), cuTexRefSetArray(jcuda.driver.CUtexref, jcuda.driver.CUarray, int), cuTexRefSetFilterMode(jcuda.driver.CUtexref, int), cuTexRefSetFlags(jcuda.driver.CUtexref, int), cuTexRefSetFormat(jcuda.driver.CUtexref, int, int), cuTexRefGetAddress(jcuda.driver.CUdeviceptr, jcuda.driver.CUtexref), cuTexRefGetAddressMode(int[], jcuda.driver.CUtexref, int), cuTexRefGetArray(jcuda.driver.CUarray, jcuda.driver.CUtexref), cuTexRefGetFilterMode(int[], jcuda.driver.CUtexref), cuTexRefGetFormat(int[], int[], jcuda.driver.CUtexref)

cuSurfRefSetArray
```
public static int cuSurfRefSetArray(CUsurfref hSurfRef,
                                    CUarray hArray,
                                    int Flags)
```
Deprecated. Deprecated as of CUDA 10.1
Sets the CUDA array for a surface reference.
```
 CUresult cuSurfRefSetArray (
      CUsurfref hSurfRef,
      CUarray hArray,
      unsigned int  Flags )
 
```
Sets the CUDA array for a surface reference. Sets the CUDA array hArray to be read and written by the surface reference hSurfRef. Any previous CUDA array state associated with the surface reference is superseded by this function. 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 hSurfRef is unbound.
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

See Also:

cuModuleGetSurfRef(jcuda.driver.CUsurfref, jcuda.driver.CUmodule, java.lang.String), cuSurfRefGetArray(jcuda.driver.CUarray, jcuda.driver.CUsurfref)

cuSurfRefGetArray
```
public static int cuSurfRefGetArray(CUarray phArray,
                                    CUsurfref hSurfRef)
```
Deprecated. Deprecated as of CUDA 10.1
Passes back the CUDA array bound to a surface reference.
```
 CUresult cuSurfRefGetArray (
      CUarray* phArray,
      CUsurfref hSurfRef )
 
```
Passes back the CUDA array bound to a surface reference. Returns in *phArray the CUDA array bound to the surface reference hSurfRef, or returns CUDA_ERROR_INVALID_VALUE if the surface reference is not bound to any CUDA array.
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

See Also:

cuModuleGetSurfRef(jcuda.driver.CUsurfref, jcuda.driver.CUmodule, java.lang.String), cuSurfRefSetArray(jcuda.driver.CUsurfref, jcuda.driver.CUarray, int)

cuTexObjectCreate
```
public static int cuTexObjectCreate(CUtexObject pTexObject,
                                    CUDA_RESOURCE_DESC pResDesc,
                                    CUDA_TEXTURE_DESC pTexDesc,
                                    CUDA_RESOURCE_VIEW_DESC pResViewDesc)
```
Creates a texture object.
```
 CUresult cuTexObjectCreate (
      CUtexObject* pTexObject,
      const CUDA_RESOURCE_DESC* pResDesc,
      const CUDA_TEXTURE_DESC* pTexDesc,
      const CUDA_RESOURCE_VIEW_DESC* pResViewDesc )
 
```
Creates a texture object. Creates a texture object and returns it in pTexObject. pResDesc describes the data to texture from. pTexDesc describes how the data should be sampled. pResViewDesc is an optional argument that specifies an alternate format for the data described by pResDesc, and also describes the subresource region to restrict access to when texturing. 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.

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;
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.

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.

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)).

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 anistropy 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

See Also:

cuTexObjectDestroy(jcuda.driver.CUtexObject)

cuTexObjectDestroy
```
public static int cuTexObjectDestroy(CUtexObject texObject)
```
Destroys a texture object.
```
 CUresult cuTexObjectDestroy (
      CUtexObject texObject )
 
```
Destroys a texture object. Destroys the texture object specified by 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

See Also:

cuTexObjectCreate(jcuda.driver.CUtexObject, jcuda.driver.CUDA_RESOURCE_DESC, jcuda.driver.CUDA_TEXTURE_DESC, jcuda.driver.CUDA_RESOURCE_VIEW_DESC)

cuTexObjectGetResourceDesc
```
public static int cuTexObjectGetResourceDesc(CUDA_RESOURCE_DESC pResDesc,
                                             CUtexObject texObject)
```
Returns a texture object's resource descriptor.
```
 CUresult cuTexObjectGetResourceDesc (
      CUDA_RESOURCE_DESC* pResDesc,
      CUtexObject texObject )
 
```
Returns a texture object's resource descriptor. Returns the resource descriptor for the texture object specified by 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

See Also:

cuTexObjectCreate(jcuda.driver.CUtexObject, jcuda.driver.CUDA_RESOURCE_DESC, jcuda.driver.CUDA_TEXTURE_DESC, jcuda.driver.CUDA_RESOURCE_VIEW_DESC)

cuTexObjectGetTextureDesc
```
public static int cuTexObjectGetTextureDesc(CUDA_TEXTURE_DESC pTexDesc,
                                            CUtexObject texObject)
```
Returns a texture object's texture descriptor.
```
 CUresult cuTexObjectGetTextureDesc (
      CUDA_TEXTURE_DESC* pTexDesc,
      CUtexObject texObject )
 
```
Returns a texture object's texture descriptor. Returns the texture descriptor for the texture object specified by 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

See Also:

cuTexObjectCreate(jcuda.driver.CUtexObject, jcuda.driver.CUDA_RESOURCE_DESC, jcuda.driver.CUDA_TEXTURE_DESC, jcuda.driver.CUDA_RESOURCE_VIEW_DESC)

cuTexObjectGetResourceViewDesc
```
public static int cuTexObjectGetResourceViewDesc(CUDA_RESOURCE_VIEW_DESC pResViewDesc,
                                                 CUtexObject texObject)
```
Returns a texture object's resource view descriptor.
```
 CUresult cuTexObjectGetResourceViewDesc (
      CUDA_RESOURCE_VIEW_DESC* pResViewDesc,
      CUtexObject texObject )
 
```
Returns a texture object's resource view descriptor. Returns the resource view descriptor for the texture object specified by texObject. If no resource view was set for 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

See Also:

cuTexObjectCreate(jcuda.driver.CUtexObject, jcuda.driver.CUDA_RESOURCE_DESC, jcuda.driver.CUDA_TEXTURE_DESC, jcuda.driver.CUDA_RESOURCE_VIEW_DESC)

cuSurfObjectCreate
```
public static int cuSurfObjectCreate(CUsurfObject pSurfObject,
                                     CUDA_RESOURCE_DESC pResDesc)
```
Creates a surface object.
```
 CUresult cuSurfObjectCreate (
      CUsurfObject* pSurfObject,
      const CUDA_RESOURCE_DESC* pResDesc )
 
```
Creates a surface object. Creates a surface object and returns it in pSurfObject. 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.
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

See Also:

cuSurfObjectDestroy(jcuda.driver.CUsurfObject)

cuSurfObjectDestroy
```
public static int cuSurfObjectDestroy(CUsurfObject surfObject)
```
Destroys a surface object.
```
 CUresult cuSurfObjectDestroy (
      CUsurfObject surfObject )
 
```
Destroys a surface object. Destroys the surface object specified by 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

See Also:

cuSurfObjectCreate(jcuda.driver.CUsurfObject, jcuda.driver.CUDA_RESOURCE_DESC)

cuSurfObjectGetResourceDesc
```
public static int cuSurfObjectGetResourceDesc(CUDA_RESOURCE_DESC pResDesc,
                                              CUsurfObject surfObject)
```
Returns a surface object's resource descriptor.
```
 CUresult cuSurfObjectGetResourceDesc (
      CUDA_RESOURCE_DESC* pResDesc,
      CUsurfObject surfObject )
 
```
Returns a surface object's resource descriptor. Returns the resource descriptor for the surface object specified by 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

See Also:

cuSurfObjectCreate(jcuda.driver.CUsurfObject, jcuda.driver.CUDA_RESOURCE_DESC)

cuDeviceCanAccessPeer
```
public static int cuDeviceCanAccessPeer(int[] canAccessPeer,
                                        CUdevice dev,
                                        CUdevice peerDev)
```
Queries if a device may directly access a peer device's memory.
```
 CUresult cuDeviceCanAccessPeer (
      int* canAccessPeer,
      CUdevice dev,
      CUdevice peerDev )
 
```
Queries if a device may directly access a peer device's memory. Returns in *canAccessPeer a value of 1 if contexts on dev are capable of directly accessing memory from contexts on peerDev and 0 otherwise. If direct access of peerDev from dev is possible, then access may be enabled on two specific contexts by calling cuCtxEnablePeerAccess().

Note:
Note that this function may also return error codes from previous, asynchronous launches.
Parameters:

canAccessPeer - Returned access capability

dev - Device from which allocations on peerDev are to be directly accessed.

peerDev - Device on which the allocations to be directly accessed by dev reside.

Returns:

CUDA_SUCCESS, CUDA_ERROR_DEINITIALIZED, CUDA_ERROR_NOT_INITIALIZED, CUDA_ERROR_INVALID_DEVICE

See Also:

cuCtxEnablePeerAccess(jcuda.driver.CUcontext, int), cuCtxDisablePeerAccess(jcuda.driver.CUcontext)

cuDeviceGetP2PAttribute
```
public static int cuDeviceGetP2PAttribute(int[] value,
                                          int attrib,
                                          CUdevice srcDevice,
                                          CUdevice dstDevice)
```
Queries attributes of the link between two devices.

Returns in *value the value of the requested attribute attrib of the link between srcDevice and dstDevice. The supported attributes are:
- CU_DEVICE_P2P_ATTRIBUTE_PERFORMANCE_RANK: A relative value indicating the performance of the link between two devices.
- CU_DEVICE_P2P_ATTRIBUTE_ACCESS_SUPPORTED P2P: 1 if P2P Access is enable.
- CU_DEVICE_P2P_ATTRIBUTE_NATIVE_ATOMIC_SUPPORTED: 1 if Atomic operations over the link are supported.
Returns ::CUDA_ERROR_INVALID_DEVICE if srcDevice or dstDevice are not valid or if they represent the same device.

Returns ::CUDA_ERROR_INVALID_VALUE if attrib is not valid or if 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:

CUDA_SUCCESS, CUDA_ERROR_DEINITIALIZED, CUDA_ERROR_NOT_INITIALIZED, CUDA_ERROR_INVALID_DEVICE, CUDA_ERROR_INVALID_VALUE

See Also:

cuCtxEnablePeerAccess(jcuda.driver.CUcontext, int), cuCtxDisablePeerAccess(jcuda.driver.CUcontext), JCudaDriver#cuCtxCanAccessPeer

cuCtxEnablePeerAccess
```
public static int cuCtxEnablePeerAccess(CUcontext peerContext,
                                        int Flags)
```
Enables direct access to memory allocations in a peer context.
```
 CUresult cuCtxEnablePeerAccess (
      CUcontext peerContext,
      unsigned int  Flags )
 
```
Enables direct access to memory allocations in a peer context. If both the current context and 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 peerContext will immediately be accessible by the current context. See Unified Addressing for additional details.

Note that access granted by this call is unidirectional and that in order to access memory from the current context in peerContext, a separate symmetric call to cuCtxEnablePeerAccess() is required.
There is a system-wide maximum of eight peer connections per device.

Returns CUDA_ERROR_PEER_ACCESS_UNSUPPORTED if cuDeviceCanAccessPeer() indicates that the CUdevice of the current context cannot directly access memory from the CUdevice of peerContext.

Returns CUDA_ERROR_PEER_ACCESS_ALREADY_ENABLED if direct access of 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, peerContext is not a valid context, or if the current context is peerContext.

Returns CUDA_ERROR_INVALID_VALUE if Flags is not 0.

Note:
Note that this function may also return error codes from previous, asynchronous launches.
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

See Also:

cuDeviceCanAccessPeer(int[], jcuda.driver.CUdevice, jcuda.driver.CUdevice), cuCtxDisablePeerAccess(jcuda.driver.CUcontext)

cuCtxDisablePeerAccess
```
public static int cuCtxDisablePeerAccess(CUcontext peerContext)
```
Disables direct access to memory allocations in a peer context and unregisters any registered allocations.
```
 CUresult cuCtxDisablePeerAccess (
      CUcontext peerContext )
 
```
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 peerContext to the current context.

Returns CUDA_ERROR_INVALID_CONTEXT if there is no current context, or if peerContext is not a valid context.

Note:
Note that this function may also return error codes from previous, asynchronous launches.
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,

See Also:

cuDeviceCanAccessPeer(int[], jcuda.driver.CUdevice, jcuda.driver.CUdevice), cuCtxEnablePeerAccess(jcuda.driver.CUcontext, int)

cuParamSetSize
```
@Deprecated
public static int cuParamSetSize(CUfunction hfunc,
                                              int numbytes)
```
Deprecated. Deprecated in CUDA
Sets the parameter size for the function.
```
 CUresult cuParamSetSize (
      CUfunction hfunc,
      unsigned int  numbytes )
 
```
Sets the parameter size for the function. Deprecated Sets through numbytes the total size in bytes needed by the function parameters of the kernel corresponding to hfunc.

Note:
Note that this function may also return error codes from previous, asynchronous launches.
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

See Also:

cuFuncSetBlockShape(jcuda.driver.CUfunction, int, int, int), cuFuncSetSharedSize(jcuda.driver.CUfunction, int), cuFuncGetAttribute(int[], int, jcuda.driver.CUfunction), cuParamSetf(jcuda.driver.CUfunction, int, float), cuParamSeti(jcuda.driver.CUfunction, int, int), cuParamSetv(jcuda.driver.CUfunction, int, jcuda.Pointer, int), cuLaunch(jcuda.driver.CUfunction), cuLaunchGrid(jcuda.driver.CUfunction, int, int), cuLaunchGridAsync(jcuda.driver.CUfunction, int, int, jcuda.driver.CUstream), cuLaunchKernel(jcuda.driver.CUfunction, int, int, int, int, int, int, int, jcuda.driver.CUstream, jcuda.Pointer, jcuda.Pointer)

cuParamSeti
```
@Deprecated
public static int cuParamSeti(CUfunction hfunc,
                                           int offset,
                                           int value)
```
Deprecated. Deprecated in CUDA
Adds an integer parameter to the function's argument list.
```
 CUresult cuParamSeti (
      CUfunction hfunc,
      int  offset,
      unsigned int  value )
 
```
Adds an integer parameter to the function's argument list. Deprecated Sets an integer parameter that will be specified the next time the kernel corresponding to hfunc will be invoked. offset is a byte offset.

Note:
Note that this function may also return error codes from previous, asynchronous launches.
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

See Also:

cuFuncSetBlockShape(jcuda.driver.CUfunction, int, int, int), cuFuncSetSharedSize(jcuda.driver.CUfunction, int), cuFuncGetAttribute(int[], int, jcuda.driver.CUfunction), cuParamSetSize(jcuda.driver.CUfunction, int), cuParamSetf(jcuda.driver.CUfunction, int, float), cuParamSetv(jcuda.driver.CUfunction, int, jcuda.Pointer, int), cuLaunch(jcuda.driver.CUfunction), cuLaunchGrid(jcuda.driver.CUfunction, int, int), cuLaunchGridAsync(jcuda.driver.CUfunction, int, int, jcuda.driver.CUstream), cuLaunchKernel(jcuda.driver.CUfunction, int, int, int, int, int, int, int, jcuda.driver.CUstream, jcuda.Pointer, jcuda.Pointer)

cuParamSetf
```
@Deprecated
public static int cuParamSetf(CUfunction hfunc,
                                           int offset,
                                           float value)
```
Deprecated. Deprecated in CUDA
Adds a floating-point parameter to the function's argument list.
```
 CUresult cuParamSetf (
      CUfunction hfunc,
      int  offset,
      float  value )
 
```
Adds a floating-point parameter to the function's argument list. Deprecated Sets a floating-point parameter that will be specified the next time the kernel corresponding to hfunc will be invoked. offset is a byte offset.

Note:
Note that this function may also return error codes from previous, asynchronous launches.
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

See Also:

cuFuncSetBlockShape(jcuda.driver.CUfunction, int, int, int), cuFuncSetSharedSize(jcuda.driver.CUfunction, int), cuFuncGetAttribute(int[], int, jcuda.driver.CUfunction), cuParamSetSize(jcuda.driver.CUfunction, int), cuParamSeti(jcuda.driver.CUfunction, int, int), cuParamSetv(jcuda.driver.CUfunction, int, jcuda.Pointer, int), cuLaunch(jcuda.driver.CUfunction), cuLaunchGrid(jcuda.driver.CUfunction, int, int), cuLaunchGridAsync(jcuda.driver.CUfunction, int, int, jcuda.driver.CUstream), cuLaunchKernel(jcuda.driver.CUfunction, int, int, int, int, int, int, int, jcuda.driver.CUstream, jcuda.Pointer, jcuda.Pointer)

cuParamSetv
```
@Deprecated
public static int cuParamSetv(CUfunction hfunc,
                                           int offset,
                                           Pointer ptr,
                                           int numbytes)
```
Deprecated. Deprecated in CUDA
Adds arbitrary data to the function's argument list.
```
 CUresult cuParamSetv (
      CUfunction hfunc,
      int  offset,
      void* ptr,
      unsigned int  numbytes )
 
```
Adds arbitrary data to the function's argument list. Deprecated Copies an arbitrary amount of data (specified in numbytes) from ptr into the parameter space of the kernel corresponding to hfunc. offset is a byte offset.

Note:
Note that this function may also return error codes from previous, asynchronous launches.
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

See Also:

cuFuncSetBlockShape(jcuda.driver.CUfunction, int, int, int), cuFuncSetSharedSize(jcuda.driver.CUfunction, int), cuFuncGetAttribute(int[], int, jcuda.driver.CUfunction), cuParamSetSize(jcuda.driver.CUfunction, int), cuParamSetf(jcuda.driver.CUfunction, int, float), cuParamSeti(jcuda.driver.CUfunction, int, int), cuLaunch(jcuda.driver.CUfunction), cuLaunchGrid(jcuda.driver.CUfunction, int, int), cuLaunchGridAsync(jcuda.driver.CUfunction, int, int, jcuda.driver.CUstream), cuLaunchKernel(jcuda.driver.CUfunction, int, int, int, int, int, int, int, jcuda.driver.CUstream, jcuda.Pointer, jcuda.Pointer)

cuParamSetTexRef
```
@Deprecated
public static int cuParamSetTexRef(CUfunction hfunc,
                                                int texunit,
                                                CUtexref hTexRef)
```
Deprecated. Deprecated in CUDA
Adds a texture-reference to the function's argument list.
```
 CUresult cuParamSetTexRef (
      CUfunction hfunc,
      int  texunit,
      CUtexref hTexRef )
 
```
Adds a texture-reference to the function's argument list. Deprecated Makes the CUDA array or linear memory bound to the texture reference hTexRef available to a device program as a texture. In this version of CUDA, the texture-reference must be obtained via cuModuleGetTexRef() and the texunit parameter must be set to CU_PARAM_TR_DEFAULT.

Note:
Note that this function may also return error codes from previous, asynchronous launches.
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

cuGraphCreate
```
public static int cuGraphCreate(CUgraph phGraph,
                                int flags)
```
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

See Also:

JCudaDriver#cuGraphAddEmptyNode JCudaDriver#cuGraphAddKernelNode JCudaDriver#cuGraphAddHostNode JCudaDriver#cuGraphAddMemcpyNode JCudaDriver#cuGraphAddMemsetNode JCudaDriver#cuGraphInstantiate JCudaDriver#cuGraphDestroy JCudaDriver#cuGraphGetNodes JCudaDriver#cuGraphGetRootNodes JCudaDriver#cuGraphGetEdges JCudaDriver#cuGraphClone

cuGraphAddKernelNode
```
public static int cuGraphAddKernelNode(CUgraphNode phGraphNode,
                                       CUgraph hGraph,
                                       CUgraphNode[] dependencies,
                                       long numDependencies,
                                       CUDA_KERNEL_NODE_PARAMS nodeParams)
```
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.
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

See Also:

JCudaDriver#cuGraphKernelNodeGetParams JCudaDriver#cuGraphKernelNodeSetParams JCudaDriver#cuGraphCreate JCudaDriver#cuGraphDestroyNode JCudaDriver#cuGraphAddChildGraphNode JCudaDriver#cuGraphAddEmptyNode JCudaDriver#cuGraphAddHostNode JCudaDriver#cuGraphAddMemcpyNode JCudaDriver#cuGraphAddMemsetNode

cuGraphKernelNodeGetParams
```
public static int cuGraphKernelNodeGetParams(CUgraphNode hNode,
                                             CUDA_KERNEL_NODE_PARAMS nodeParams)
```
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

See Also:

JCudaDriver#cuGraphAddKernelNode JCudaDriver#cuGraphKernelNodeSetParams

cuGraphKernelNodeSetParams
```
public static int cuGraphKernelNodeSetParams(CUgraphNode hNode,
                                             CUDA_KERNEL_NODE_PARAMS nodeParams)
```
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

See Also:

JCudaDriver#cuGraphAddKernelNode JCudaDriver#cuGraphKernelNodeGetParams

cuGraphAddMemcpyNode
```
public static int cuGraphAddMemcpyNode(CUgraphNode phGraphNode,
                                       CUgraph hGraph,
                                       CUgraphNode[] dependencies,
                                       long numDependencies,
                                       CUDA_MEMCPY3D copyParams,
                                       CUcontext ctx)
```
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

See Also:

JCudaDriver#cuGraphMemcpyNodeGetParams JCudaDriver#cuGraphMemcpyNodeSetParams JCudaDriver#cuGraphCreate JCudaDriver#cuGraphDestroyNode JCudaDriver#cuGraphAddChildGraphNode JCudaDriver#cuGraphAddEmptyNode JCudaDriver#cuGraphAddKernelNode JCudaDriver#cuGraphAddHostNode JCudaDriver#cuGraphAddMemsetNode

cuGraphMemcpyNodeGetParams
```
public static int cuGraphMemcpyNodeGetParams(CUgraphNode hNode,
                                             CUDA_MEMCPY3D nodeParams)
```
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

See Also:

JCudaDriver#cuGraphAddMemcpyNode JCudaDriver#cuGraphMemcpyNodeSetParams

cuGraphMemcpyNodeSetParams
```
public static int cuGraphMemcpyNodeSetParams(CUgraphNode hNode,
                                             CUDA_MEMCPY3D nodeParams)
```
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,

See Also:

JCudaDriver#cuGraphAddMemcpyNode JCudaDriver#cuGraphMemcpyNodeGetParams

cuGraphAddMemsetNode
```
public static int cuGraphAddMemsetNode(CUgraphNode phGraphNode,
                                       CUgraph hGraph,
                                       CUgraphNode[] dependencies,
                                       long numDependencies,
                                       CUDA_MEMSET_NODE_PARAMS memsetParams,
                                       CUcontext ctx)
```
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

See Also:

JCudaDriver#cuGraphMemsetNodeGetParams JCudaDriver#cuGraphMemsetNodeSetParams JCudaDriver#cuGraphCreate JCudaDriver#cuGraphDestroyNode JCudaDriver#cuGraphAddChildGraphNode JCudaDriver#cuGraphAddEmptyNode JCudaDriver#cuGraphAddKernelNode JCudaDriver#cuGraphAddHostNode JCudaDriver#cuGraphAddMemcpyNode

cuGraphMemsetNodeGetParams
```
public static int cuGraphMemsetNodeGetParams(CUgraphNode hNode,
                                             CUDA_MEMSET_NODE_PARAMS nodeParams)
```
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

See Also:

JCudaDriver#cuGraphAddMemsetNode JCudaDriver#cuGraphMemsetNodeSetParams

cuGraphMemsetNodeSetParams
```
public static int cuGraphMemsetNodeSetParams(CUgraphNode hNode,
                                             CUDA_MEMSET_NODE_PARAMS nodeParams)
```
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

See Also:

JCudaDriver#cuGraphAddMemsetNode JCudaDriver#cuGraphMemsetNodeGetParams

cuGraphAddHostNode
```
public static int cuGraphAddHostNode(CUgraphNode phGraphNode,
                                     CUgraph hGraph,
                                     CUgraphNode[] dependencies,
                                     long numDependencies,
                                     CUDA_HOST_NODE_PARAMS nodeParams)
```
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.

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_INVALID_VALUE

See Also:

JCudaDriver#cuGraphHostNodeGetParams JCudaDriver#cuGraphHostNodeSetParams JCudaDriver#cuGraphCreate JCudaDriver#cuGraphDestroyNode JCudaDriver#cuGraphAddChildGraphNode JCudaDriver#cuGraphAddEmptyNode JCudaDriver#cuGraphAddKernelNode JCudaDriver#cuGraphAddMemcpyNode JCudaDriver#cuGraphAddMemsetNode

cuGraphHostNodeGetParams
```
public static int cuGraphHostNodeGetParams(CUgraphNode hNode,
                                           CUDA_HOST_NODE_PARAMS nodeParams)
```
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

See Also:

JCudaDriver#cuGraphAddHostNode JCudaDriver#cuGraphHostNodeSetParams

cuGraphHostNodeSetParams
```
public static int cuGraphHostNodeSetParams(CUgraphNode hNode,
                                           CUDA_HOST_NODE_PARAMS nodeParams)
```
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

See Also:

JCudaDriver#cuGraphAddHostNode JCudaDriver#cuGraphHostNodeGetParams

cuGraphAddChildGraphNode
```
public static int cuGraphAddChildGraphNode(CUgraphNode phGraphNode,
                                           CUgraph hGraph,
                                           CUgraphNode[] dependencies,
                                           long numDependencies,
                                           CUgraph childGraph)
```
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,

See Also:

JCudaDriver#cuGraphCreate JCudaDriver#cuGraphDestroyNode JCudaDriver#cuGraphAddEmptyNode JCudaDriver#cuGraphAddKernelNode JCudaDriver#cuGraphAddHostNode JCudaDriver#cuGraphAddMemcpyNode JCudaDriver#cuGraphAddMemsetNode JCudaDriver#cuGraphClone

cuGraphChildGraphNodeGetGraph
```
public static int cuGraphChildGraphNodeGetGraph(CUgraphNode hNode,
                                                CUgraph phGraph)
```
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,

See Also:

JCudaDriver#cuGraphNodeFindInClone

cuGraphAddEmptyNode
```
public static int cuGraphAddEmptyNode(CUgraphNode phGraphNode,
                                      CUgraph hGraph,
                                      CUgraphNode[] dependencies,
                                      long numDependencies)
```
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,

See Also:

JCudaDriver#cuGraphDestroyNode JCudaDriver#cuGraphAddChildGraphNode JCudaDriver#cuGraphAddKernelNode JCudaDriver#cuGraphAddHostNode JCudaDriver#cuGraphAddMemcpyNode JCudaDriver#cuGraphAddMemsetNode

cuGraphClone
```
public static int cuGraphClone(CUgraph phGraphClone,
                               CUgraph originalGraph)
```
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

See Also:

JCudaDriver#cuGraphNodeFindInClone

cuGraphNodeFindInClone
```
public static int cuGraphNodeFindInClone(CUgraphNode phNode,
                                         CUgraphNode hOriginalNode,
                                         CUgraph hClonedGraph)
```
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,

See Also:

cuGraphClone(jcuda.driver.CUgraph, jcuda.driver.CUgraph)

cuGraphNodeGetType
```
public static int cuGraphNodeGetType(CUgraphNode hNode,
                                     int[] type)
```
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

See Also:

JCudaDriver#cuGraphGetRootNodes JCudaDriver#cuGraphChildGraphNodeGetGraph JCudaDriver#cuGraphKernelNodeGetParams JCudaDriver#cuGraphKernelNodeSetParams JCudaDriver#cuGraphHostNodeGetParams JCudaDriver#cuGraphHostNodeSetParams JCudaDriver#cuGraphMemcpyNodeGetParams JCudaDriver#cuGraphMemcpyNodeSetParams JCudaDriver#cuGraphMemsetNodeGetParams JCudaDriver#cuGraphMemsetNodeSetParams

cuGraphGetNodes
```
public static int cuGraphGetNodes(CUgraph hGraph,
                                  CUgraphNode[] nodes,
                                  long[] numNodes)
```
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

See Also:

JCudaDriver#cuGraphGetRootNodes JCudaDriver#cuGraphGetEdges JCudaDriver#cuGraphNodeGetType JCudaDriver#cuGraphNodeGetDependencies JCudaDriver#cuGraphNodeGetDependentNodes

cuGraphGetRootNodes
```
public static int cuGraphGetRootNodes(CUgraph hGraph,
                                      CUgraphNode[] rootNodes,
                                      long[] numRootNodes)
```
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

See Also:

JCudaDriver#cuGraphGetNodes JCudaDriver#cuGraphGetEdges JCudaDriver#cuGraphNodeGetType JCudaDriver#cuGraphNodeGetDependencies JCudaDriver#cuGraphNodeGetDependentNodes

cuGraphGetEdges
```
public static int cuGraphGetEdges(CUgraph hGraph,
                                  CUgraphNode[] from,
                                  CUgraphNode[] to,
                                  long[] numEdges)
```
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

See Also:

JCudaDriver#cuGraphGetRootNodes JCudaDriver#cuGraphAddDependencies JCudaDriver#cuGraphRemoveDependencies JCudaDriver#cuGraphNodeGetDependencies JCudaDriver#cuGraphNodeGetDependentNodes

cuGraphNodeGetDependencies
```
public static int cuGraphNodeGetDependencies(CUgraphNode hNode,
                                             CUgraphNode[] dependencies,
                                             long[] numDependencies)
```
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

See Also:

JCudaDriver#cuGraphGetNodes JCudaDriver#cuGraphGetRootNodes JCudaDriver#cuGraphGetEdges JCudaDriver#cuGraphAddDependencies JCudaDriver#cuGraphRemoveDependencies

cuGraphNodeGetDependentNodes
```
public static int cuGraphNodeGetDependentNodes(CUgraphNode hNode,
                                               CUgraphNode[] dependentNodes,
                                               long[] numDependentNodes)
```
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

See Also:

JCudaDriver#cuGraphGetNodes JCudaDriver#cuGraphGetRootNodes JCudaDriver#cuGraphGetEdges JCudaDriver#cuGraphAddDependencies JCudaDriver#cuGraphRemoveDependencies

cuGraphAddDependencies
```
public static int cuGraphAddDependencies(CUgraph hGraph,
                                         CUgraphNode[] from,
                                         CUgraphNode[] to,
                                         long numDependencies)
```
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

See Also:

JCudaDriver#cuGraphGetEdges JCudaDriver#cuGraphNodeGetDependencies JCudaDriver#cuGraphNodeGetDependentNodes

cuGraphRemoveDependencies
```
public static int cuGraphRemoveDependencies(CUgraph hGraph,
                                            CUgraphNode[] from,
                                            CUgraphNode[] to,
                                            long numDependencies)
```
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

See Also:

JCudaDriver#cuGraphGetEdges JCudaDriver#cuGraphNodeGetDependencies JCudaDriver#cuGraphNodeGetDependentNodes

cuGraphDestroyNode
```
public static int cuGraphDestroyNode(CUgraphNode hNode)
```
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

See Also:

JCudaDriver#cuGraphAddEmptyNode JCudaDriver#cuGraphAddKernelNode JCudaDriver#cuGraphAddHostNode JCudaDriver#cuGraphAddMemcpyNode JCudaDriver#cuGraphAddMemsetNode

cuGraphInstantiate
```
public static int cuGraphInstantiate(CUgraphExec phGraphExec,
                                     CUgraph hGraph,
                                     CUgraphNode phErrorNode,
                                     byte[] logBuffer,
                                     long bufferSize)
```
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

See Also:

JCudaDriver#cuGraphLaunch JCudaDriver#cuGraphExecDestroy

cuGraphExecKernelNodeSetParams
```
public static int cuGraphExecKernelNodeSetParams(CUgraphExec hGraphExec,
                                                 CUgraphNode hNode,
                                                 CUDA_KERNEL_NODE_PARAMS nodeParams)
```
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 take effect at the next launch 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,

See Also:

JCudaDriver#cuGraphAddKernelNode,, JCudaDriver#cuGraphKernelNodeSetParams,, cuGraphInstantiate(jcuda.driver.CUgraphExec, jcuda.driver.CUgraph, jcuda.driver.CUgraphNode, byte[], long)

cuGraphExecMemcpyNodeSetParams
```
public static int cuGraphExecMemcpyNodeSetParams(CUgraphExec hGraphExec,
                                                 CUgraphNode hNode,
                                                 CUDA_MEMCPY3D copyParams,
                                                 CUcontext ctx)
```
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

See Also:

JCudaDriver#cuGraphInstantiate,, cuGraphExecKernelNodeSetParams(jcuda.driver.CUgraphExec, jcuda.driver.CUgraphNode, jcuda.driver.CUDA_KERNEL_NODE_PARAMS), cuGraphExecMemsetNodeSetParams(jcuda.driver.CUgraphExec, jcuda.driver.CUgraphNode, jcuda.driver.CUDA_MEMSET_NODE_PARAMS, jcuda.driver.CUcontext), cuGraphExecHostNodeSetParams(jcuda.driver.CUgraphExec, jcuda.driver.CUgraphNode, jcuda.driver.CUDA_HOST_NODE_PARAMS)

cuGraphExecMemsetNodeSetParams
```
public static int cuGraphExecMemsetNodeSetParams(CUgraphExec hGraphExec,
                                                 CUgraphNode hNode,
                                                 CUDA_MEMSET_NODE_PARAMS memsetParams,
                                                 CUcontext ctx)
```
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

See Also:

cuGraphInstantiate(jcuda.driver.CUgraphExec, jcuda.driver.CUgraph, jcuda.driver.CUgraphNode, byte[], long), cuGraphExecKernelNodeSetParams(jcuda.driver.CUgraphExec, jcuda.driver.CUgraphNode, jcuda.driver.CUDA_KERNEL_NODE_PARAMS), cuGraphExecMemcpyNodeSetParams(jcuda.driver.CUgraphExec, jcuda.driver.CUgraphNode, jcuda.driver.CUDA_MEMCPY3D, jcuda.driver.CUcontext), cuGraphExecHostNodeSetParams(jcuda.driver.CUgraphExec, jcuda.driver.CUgraphNode, jcuda.driver.CUDA_HOST_NODE_PARAMS)

cuGraphExecHostNodeSetParams
```
public static int cuGraphExecHostNodeSetParams(CUgraphExec hGraphExec,
                                               CUgraphNode hNode,
                                               CUDA_HOST_NODE_PARAMS nodeParams)
```
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

See Also:

cuGraphInstantiate(jcuda.driver.CUgraphExec, jcuda.driver.CUgraph, jcuda.driver.CUgraphNode, byte[], long), cuGraphExecKernelNodeSetParams(jcuda.driver.CUgraphExec, jcuda.driver.CUgraphNode, jcuda.driver.CUDA_KERNEL_NODE_PARAMS), cuGraphExecMemcpyNodeSetParams(jcuda.driver.CUgraphExec, jcuda.driver.CUgraphNode, jcuda.driver.CUDA_MEMCPY3D, jcuda.driver.CUcontext), cuGraphExecMemsetNodeSetParams(jcuda.driver.CUgraphExec, jcuda.driver.CUgraphNode, jcuda.driver.CUDA_MEMSET_NODE_PARAMS, jcuda.driver.CUcontext)

cuGraphLaunch
```
public static int cuGraphLaunch(CUgraphExec hGraphExec,
                                CUstream hStream)
```
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

See Also:

JCudaDriver#cuGraphExecDestroy

cuGraphExecDestroy
```
public static int cuGraphExecDestroy(CUgraphExec hGraphExec)
```
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

See Also:

JCudaDriver#cuGraphLaunch

cuGraphDestroy
```
public static int cuGraphDestroy(CUgraph hGraph)
```
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

See Also:

cuGraphCreate(jcuda.driver.CUgraph, int)

cuGraphExecUpdate

public static int cuGraphExecUpdate(CUgraphExec hGraphExec,
                                    CUgraph hGraph,
                                    CUgraphNode hErrorNode_out,
                                    int[] updateResult_out)

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
See Also:: cuGraphInstantiate(jcuda.driver.CUgraphExec, jcuda.driver.CUgraph, jcuda.driver.CUgraphNode, byte[], long)

cuGraphKernelNodeCopyAttributes
```
public static int cuGraphKernelNodeCopyAttributes(CUgraphNode dst,
                                                  CUgraphNode src)
```
Copies attributes from source node to destination node. Copies attributes from source node src to destination node dst. Both node must have the same context.

Parameters:

dst - Destination node

src - Source node For list of attributes see ::CUkernelNodeAttrID

Returns:

CUDA_SUCCESS, UDA_ERROR_INVALID_VALUE

See Also:

CUaccessPolicyWindow

cuGraphKernelNodeGetAttribute
```
public static int cuGraphKernelNodeGetAttribute(CUgraphNode hNode,
                                                int attr,
                                                CUkernelNodeAttrValue value_out)
```
Queries node attribute. Queries attribute attr from node hNode and stores it in corresponding member of value_out.

Parameters:

hNode -

attr -

value_out -

Returns:

CUDA_SUCCESS, UDA_ERROR_INVALID_VALUE, CUDA_ERROR_INVALID_HANDLE

See Also:

CUaccessPolicyWindow

cuGraphKernelNodeSetAttribute

public static int cuGraphKernelNodeSetAttribute(CUgraphNode hNode,
                                                int attr,
                                                CUkernelNodeAttrValue value)

Sets node attribute. Sets attribute attr on node hNode from corresponding attribute of value.

Parameters:: hNode -; attr -; value -
Returns:: CUDA_SUCCESS, UDA_ERROR_INVALID_VALUE, CUDA_ERROR_INVALID_HANDLE
See Also:: CUaccessPolicyWindow

cuOccupancyMaxActiveBlocksPerMultiprocessor

public static int cuOccupancyMaxActiveBlocksPerMultiprocessor(int[] numBlocks,
                                                              CUfunction 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.

 \param numBlocks       - Returned occupancy
 \param func            - Kernel for which occupancy is calulated
 \param blockSize       - Block size the kernel is intended to be launched with
 \param dynamicSMemSize - Per-block dynamic shared memory usage intended, in bytes

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

cuOccupancyMaxActiveBlocksPerMultiprocessorWithFlags

public static int cuOccupancyMaxActiveBlocksPerMultiprocessorWithFlags(int[] numBlocks,
                                                                       CUfunction func,
                                                                       int blockSize,
                                                                       long dynamicSMemSize,
                                                                       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.

 \param minGridSize - Returned minimum grid size needed to achieve the maximum occupancy
 \param blockSize   - Returned maximum block size that can achieve the maximum occupancy
 \param func        - Kernel for which launch configuration is calculated
 \param blockSizeToDynamicSMemSize - A function that calculates how much per-block dynamic shared memory \p func uses based on the block size
 \param dynamicSMemSize - Dynamic shared memory usage intended, in bytes
 \param blockSizeLimit  - The maximum block size \p func is designed to handle
 \param flags       - Options

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

 \sa
 ::cudaOccupancyMaxPotentialBlockSizeWithFlags

cuOccupancyAvailableDynamicSMemPerBlock

public static int cuOccupancyAvailableDynamicSMemPerBlock(long[] dynamicSmemSize,
                                                          CUfunction func,
                                                          int numBlocks,
                                                          int blockSize)

 \brief Returns dynamic shared memory available per block when launching \p numBlocks blocks on SM 

 Returns in \p *dynamicSmemSize the maximum size of dynamic shared memory to allow \p numBlocks blocks per SM. 

 \param dynamicSmemSize - Returned maximum dynamic shared memory 
 \param func            - Kernel function for which occupancy is calculated
 \param numBlocks       - Number of blocks to fit on SM 
 \param blockSize       - Size of the blocks

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

 \sa

cuOccupancyMaxPotentialBlockSize

public static int cuOccupancyMaxPotentialBlockSize(int[] minGridSize,
                                                   int[] blockSize,
                                                   CUfunction 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.

 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:

 \code
    // Take block size, returns dynamic shared memory needed
    size_t blockToSmem(int blockSize);
 \endcode

 \param minGridSize - Returned minimum grid size needed to achieve the maximum occupancy
 \param blockSize   - Returned maximum block size that can achieve the maximum occupancy
 \param func        - Kernel for which launch configuration is calulated
 \param blockSizeToDynamicSMemSize - A function that calculates how much per-block dynamic shared memory \p func uses based on the block size
 \param dynamicSMemSize - Dynamic shared memory usage intended, in bytes
 \param blockSizeLimit  - The maximum block size \p func is designed to handle

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

cuOccupancyMaxPotentialBlockSizeWithFlags

public static int cuOccupancyMaxPotentialBlockSizeWithFlags(int[] minGridSize,
                                                            int[] blockSize,
                                                            CUfunction func,
                                                            CUoccupancyB2DSize blockSizeToDynamicSMemSize,
                                                            long dynamicSMemSize,
                                                            int blockSizeLimit,
                                                            int flags)

cuLaunch
```
@Deprecated
public static int cuLaunch(CUfunction f)
```
Deprecated. Deprecated in CUDA
Launches a CUDA function.
```
 CUresult cuLaunch (
      CUfunction f )
 
```
Launches a CUDA function. Deprecated Invokes the kernel 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().

Note:
Note that this function may also return error codes from previous, asynchronous launches.
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

See Also:

cuFuncSetBlockShape(jcuda.driver.CUfunction, int, int, int), cuFuncSetSharedSize(jcuda.driver.CUfunction, int), cuFuncGetAttribute(int[], int, jcuda.driver.CUfunction), cuParamSetSize(jcuda.driver.CUfunction, int), cuParamSetf(jcuda.driver.CUfunction, int, float), cuParamSeti(jcuda.driver.CUfunction, int, int), cuParamSetv(jcuda.driver.CUfunction, int, jcuda.Pointer, int), cuLaunchGrid(jcuda.driver.CUfunction, int, int), cuLaunchGridAsync(jcuda.driver.CUfunction, int, int, jcuda.driver.CUstream), cuLaunchKernel(jcuda.driver.CUfunction, int, int, int, int, int, int, int, jcuda.driver.CUstream, jcuda.Pointer, jcuda.Pointer)

cuLaunchGrid
```
@Deprecated
public static int cuLaunchGrid(CUfunction f,
                                            int grid_width,
                                            int grid_height)
```
Deprecated. Deprecated in CUDA
Launches a CUDA function.
```
 CUresult cuLaunchGrid (
      CUfunction f,
      int  grid_width,
      int  grid_height )
 
```
Launches a CUDA function. Deprecated Invokes the kernel f on a grid_width x grid_height grid of blocks. Each block contains the number of threads specified by a previous call to cuFuncSetBlockShape().

Note:
Note that this function may also return error codes from previous, asynchronous launches.
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

See Also:

cuFuncSetBlockShape(jcuda.driver.CUfunction, int, int, int), cuFuncSetSharedSize(jcuda.driver.CUfunction, int), cuFuncGetAttribute(int[], int, jcuda.driver.CUfunction), cuParamSetSize(jcuda.driver.CUfunction, int), cuParamSetf(jcuda.driver.CUfunction, int, float), cuParamSeti(jcuda.driver.CUfunction, int, int), cuParamSetv(jcuda.driver.CUfunction, int, jcuda.Pointer, int), cuLaunch(jcuda.driver.CUfunction), cuLaunchGridAsync(jcuda.driver.CUfunction, int, int, jcuda.driver.CUstream), cuLaunchKernel(jcuda.driver.CUfunction, int, int, int, int, int, int, int, jcuda.driver.CUstream, jcuda.Pointer, jcuda.Pointer)

cuLaunchGridAsync
```
@Deprecated
public static int cuLaunchGridAsync(CUfunction f,
                                                 int grid_width,
                                                 int grid_height,
                                                 CUstream hStream)
```
Deprecated. Deprecated in CUDA
Launches a CUDA function.
```
 CUresult cuLaunchGridAsync (
      CUfunction f,
      int  grid_width,
      int  grid_height,
      CUstream hStream )
 
```
Launches a CUDA function. Deprecated Invokes the kernel f on a grid_width x grid_height grid of blocks. Each block contains the number of threads specified by a previous call to cuFuncSetBlockShape().

cuLaunchGridAsync() can optionally be associated to a stream by passing a non-zero hStream argument.

Note:
Note that this function may also return error codes from previous, asynchronous launches.
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

See Also:

cuFuncSetBlockShape(jcuda.driver.CUfunction, int, int, int), cuFuncSetSharedSize(jcuda.driver.CUfunction, int), cuFuncGetAttribute(int[], int, jcuda.driver.CUfunction), cuParamSetSize(jcuda.driver.CUfunction, int), cuParamSetf(jcuda.driver.CUfunction, int, float), cuParamSeti(jcuda.driver.CUfunction, int, int), cuParamSetv(jcuda.driver.CUfunction, int, jcuda.Pointer, int), cuLaunch(jcuda.driver.CUfunction), cuLaunchGrid(jcuda.driver.CUfunction, int, int), cuLaunchKernel(jcuda.driver.CUfunction, int, int, int, int, int, int, int, jcuda.driver.CUstream, jcuda.Pointer, jcuda.Pointer)

cuEventCreate
```
public static int cuEventCreate(CUevent phEvent,
                                int Flags)
```
Creates an event.
```
 CUresult cuEventCreate (
      CUevent* phEvent,
      unsigned int  Flags )
 
```
Creates an event. Creates an event *phEvent with the flags specified via 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.
Note:
Note that this function may also return error codes from previous, asynchronous launches.
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

See Also:

cuEventRecord(jcuda.driver.CUevent, jcuda.driver.CUstream), cuEventQuery(jcuda.driver.CUevent), cuEventSynchronize(jcuda.driver.CUevent), cuEventDestroy(jcuda.driver.CUevent), cuEventElapsedTime(float[], jcuda.driver.CUevent, jcuda.driver.CUevent)

cuEventRecord
```
public static int cuEventRecord(CUevent hEvent,
                                CUstream hStream)
```
Records an event.
```
 CUresult cuEventRecord (
      CUevent hEvent,
      CUstream hStream )
 
```
Records an event. Records an event. If hStream is non-zero, the event is recorded after all preceding operations in hStream have been completed; otherwise, it is recorded after all preceding operations in the CUDA context have been completed. Since operation is asynchronous, cuEventQuery and/or cuEventSynchronize() must be used to determine when the event has actually been recorded.

If cuEventRecord() has previously been called on hEvent, then this call will overwrite any existing state in hEvent. Any subsequent calls which examine the status of hEvent will only examine the completion of this most recent call to cuEventRecord().

It is necessary that hEvent and hStream be created on the same context.

Note:
Note that this function may also return error codes from previous, asynchronous launches.
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

See Also:

cuEventCreate(jcuda.driver.CUevent, int), cuEventQuery(jcuda.driver.CUevent), cuEventSynchronize(jcuda.driver.CUevent), cuStreamWaitEvent(jcuda.driver.CUstream, jcuda.driver.CUevent, int), cuEventDestroy(jcuda.driver.CUevent), cuEventElapsedTime(float[], jcuda.driver.CUevent, jcuda.driver.CUevent)

cuEventQuery
```
public static int cuEventQuery(CUevent hEvent)
```
Queries an event's status.
```
 CUresult cuEventQuery (
      CUevent hEvent )
 
```
Queries an event's status. Query the status of all device work preceding the most recent call to cuEventRecord() (in the appropriate compute streams, as specified by the arguments to cuEventRecord()).

If this work has successfully been completed by the device, or if cuEventRecord() has not been called on hEvent, then CUDA_SUCCESS is returned. If this work has not yet been completed by the device then CUDA_ERROR_NOT_READY is returned.

Note:
Note that this function may also return error codes from previous, asynchronous launches.
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

See Also:

cuEventCreate(jcuda.driver.CUevent, int), cuEventRecord(jcuda.driver.CUevent, jcuda.driver.CUstream), cuEventSynchronize(jcuda.driver.CUevent), cuEventDestroy(jcuda.driver.CUevent), cuEventElapsedTime(float[], jcuda.driver.CUevent, jcuda.driver.CUevent)

cuEventSynchronize
```
public static int cuEventSynchronize(CUevent hEvent)
```
Waits for an event to complete.
```
 CUresult cuEventSynchronize (
      CUevent hEvent )
 
```
Waits for an event to complete. Wait until the completion of all device work preceding the most recent call to cuEventRecord() (in the appropriate compute streams, as specified by the arguments to cuEventRecord()).

If cuEventRecord() has not been called on hEvent, CUDA_SUCCESS is returned immediately.

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.

Note:
Note that this function may also return error codes from previous, asynchronous launches.
Parameters:

hEvent - Event to wait for

Returns:

CUDA_SUCCESS, CUDA_ERROR_DEINITIALIZED, CUDA_ERROR_NOT_INITIALIZED, CUDA_ERROR_INVALID_CONTEXT, CUDA_ERROR_INVALID_HANDLE

See Also:

cuEventCreate(jcuda.driver.CUevent, int), cuEventRecord(jcuda.driver.CUevent, jcuda.driver.CUstream), cuEventQuery(jcuda.driver.CUevent), cuEventDestroy(jcuda.driver.CUevent), cuEventElapsedTime(float[], jcuda.driver.CUevent, jcuda.driver.CUevent)

cuEventDestroy
```
public static int cuEventDestroy(CUevent hEvent)
```
Destroys an event.
```
 CUresult cuEventDestroy (
      CUevent hEvent )
 
```
Destroys an event. Destroys the event specified by hEvent.

In case hEvent has been recorded but has not yet been completed when cuEventDestroy() is called, the function will return immediately and the resources associated with hEvent will be released automatically once the device has completed hEvent.

Note:
Note that this function may also return error codes from previous, asynchronous launches.
Parameters:

hEvent - Event to destroy

Returns:

CUDA_SUCCESS, CUDA_ERROR_DEINITIALIZED, CUDA_ERROR_NOT_INITIALIZED, CUDA_ERROR_INVALID_CONTEXT, CUDA_ERROR_INVALID_HANDLE

See Also:

cuEventCreate(jcuda.driver.CUevent, int), cuEventRecord(jcuda.driver.CUevent, jcuda.driver.CUstream), cuEventQuery(jcuda.driver.CUevent), cuEventSynchronize(jcuda.driver.CUevent), cuEventElapsedTime(float[], jcuda.driver.CUevent, jcuda.driver.CUevent)

cuEventElapsedTime
```
public static int cuEventElapsedTime(float[] pMilliseconds,
                                     CUevent hStart,
                                     CUevent hEnd)
```
Computes the elapsed time between two events.
```
 CUresult cuEventElapsedTime (
      float* pMilliseconds,
      CUevent hStart,
      CUevent hEnd )
 
```
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.

Note:
Note that this function may also return error codes from previous, asynchronous launches.
Parameters:

pMilliseconds - Time between hStart and 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

See Also:

cuEventCreate(jcuda.driver.CUevent, int), cuEventRecord(jcuda.driver.CUevent, jcuda.driver.CUstream), cuEventQuery(jcuda.driver.CUevent), cuEventSynchronize(jcuda.driver.CUevent), cuEventDestroy(jcuda.driver.CUevent)

cuStreamWaitValue32
```
public static int cuStreamWaitValue32(CUstream stream,
                                      CUdeviceptr addr,
                                      int value,
                                      int flags)
```
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 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).

On Windows, the device must be using TCC, or the operation is not supported. See cuDeviceGetAttributes().

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

See Also:

cuStreamWriteValue32(jcuda.driver.CUstream, jcuda.driver.CUdeviceptr, int, int), cuStreamBatchMemOp(jcuda.driver.CUstream, int, jcuda.driver.CUstreamBatchMemOpParams[], int), cuMemHostRegister(jcuda.Pointer, long, int), cuStreamWaitEvent(jcuda.driver.CUstream, jcuda.driver.CUevent, int)

cuStreamWriteValue32
```
public static int cuStreamWriteValue32(CUstream stream,
                                       CUdeviceptr addr,
                                       int value,
                                       int flags)
```
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).

On Windows, the device must be using TCC, or the operation is not supported. See cuDeviceGetAttribute().

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

See Also:

cuStreamWaitValue32(jcuda.driver.CUstream, jcuda.driver.CUdeviceptr, int, int), cuStreamBatchMemOp(jcuda.driver.CUstream, int, jcuda.driver.CUstreamBatchMemOpParams[], int), cuMemHostRegister(jcuda.Pointer, long, int), cuEventRecord(jcuda.driver.CUevent, jcuda.driver.CUstream)

cuStreamWaitValue64
```
public static int cuStreamWaitValue64(CUstream stream,
                                      CUdeviceptr addr,
                                      long value,
                                      int flags)
```
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 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).

On Windows, the device must be using TCC, or the operation is not supported. See cuDeviceGetAttributes().

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

See Also:

cuStreamWriteValue64(jcuda.driver.CUstream, jcuda.driver.CUdeviceptr, long, int), cuStreamBatchMemOp(jcuda.driver.CUstream, int, jcuda.driver.CUstreamBatchMemOpParams[], int), cuMemHostRegister(jcuda.Pointer, long, int), cuStreamWaitEvent(jcuda.driver.CUstream, jcuda.driver.CUevent, int)

cuStreamWriteValue64
```
public static int cuStreamWriteValue64(CUstream stream,
                                       CUdeviceptr addr,
                                       long value,
                                       int flags)
```
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).

On Windows, the device must be using TCC, or the operation is not supported. See cuDeviceGetAttribute().

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

See Also:

cuStreamWaitValue64(jcuda.driver.CUstream, jcuda.driver.CUdeviceptr, long, int), cuStreamBatchMemOp(jcuda.driver.CUstream, int, jcuda.driver.CUstreamBatchMemOpParams[], int), cuMemHostRegister(jcuda.Pointer, long, int), cuEventRecord(jcuda.driver.CUevent, jcuda.driver.CUstream)

cuStreamBatchMemOp
```
public static int cuStreamBatchMemOp(CUstream stream,
                                     int count,
                                     CUstreamBatchMemOpParams[] paramArray,
                                     int flags)
```
NOTE: This function is not yet supported in JCuda, and will throw an UnsupportedOperationException!

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() and cuStreamWriteValue32() for details of specific operations.

On Windows, the device must be using TCC, or this call is not supported. See cuDeviceGetAttribute().

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

See Also:

cuStreamWaitValue32(jcuda.driver.CUstream, jcuda.driver.CUdeviceptr, int, int), cuStreamWriteValue32(jcuda.driver.CUstream, jcuda.driver.CUdeviceptr, int, int), cuMemHostRegister(jcuda.Pointer, long, int)

cuPointerGetAttribute
```
public static int cuPointerGetAttribute(Pointer data,
                                        int attribute,
                                        CUdeviceptr ptr)
```
Returns information about a pointer.
```
 CUresult cuPointerGetAttribute (
      void* data,
      CUpointer_attribute attribute,
      CUdeviceptr ptr )
 
```
Returns information about a pointer. The supported attributes are:
- CU_POINTER_ATTRIBUTE_CONTEXT:
Returns in *data the CUcontext in which ptr was allocated or registered. The type of data must be CUcontext *.

If 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 *data the physical memory type of the memory that ptr addresses as a CUmemorytype enumerated value. The type of data must be unsigned int.

If ptr addresses device memory then *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 ptr.

If ptr addresses host memory then *data is set to CU_MEMORYTYPE_HOST.

If 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 *data the device pointer value through which ptr may be accessed by kernels running in the current CUcontext. The type of data must be CUdeviceptr *.

If there exists no device pointer value through which kernels running in the current CUcontext may access 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 *data will equal the input value ptr.
- CU_POINTER_ATTRIBUTE_HOST_POINTER:
Returns in *data the host pointer value through which ptr may be accessed by by the host program. The type of data must be void **. If there exists no host pointer value through which the host program may directly access ptr then CUDA_ERROR_INVALID_VALUE is returned.

Except in the exceptional disjoint addressing cases discussed below, the value returned in *data will equal the input value ptr.
- CU_POINTER_ATTRIBUTE_P2P_TOKENS:
Returns in *data two tokens for use with the nv-p2p.h Linux kernel interface. data must be a struct of type CUDA_POINTER_ATTRIBUTE_P2P_TOKENS.

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.

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.
Note:
Note that this function may also return error codes from previous, asynchronous launches.
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

See Also:

cuMemAlloc(jcuda.driver.CUdeviceptr, long), cuMemFree(jcuda.driver.CUdeviceptr), cuMemAllocHost(jcuda.Pointer, long), cuMemFreeHost(jcuda.Pointer), cuMemHostAlloc(jcuda.Pointer, long, int), cuMemHostRegister(jcuda.Pointer, long, int), cuMemHostUnregister(jcuda.Pointer)

cuMemPrefetchAsync
```
public static int cuMemPrefetchAsync(CUdeviceptr devPtr,
                                     long count,
                                     CUdevice dstDevice,
                                     CUstream hStream)
```
Prefetches memory to the specified destination device

Prefetches memory to the specified destination device. devPtr is the base device pointer of the memory to be prefetched and dstDevice is the destination device. count specifies the number of bytes to copy. hStream is the stream in which the operation is enqueued.

Passing in CU_DEVICE_CPU for dstDevice will prefetch the data to CPU memory.

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 belonging to other memory regions to make room. If there's no memory that can be evicted, then the Unified Memory driver will prefetch less than what was requested.

In the normal case, any mappings to the previous location of the migrated pages are removed and mappings for the new location are only setup on the dstDevice. The application can exercise finer control on these mappings using ::cudaMemAdvise.

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

See Also:

cuMemcpy(jcuda.driver.CUdeviceptr, jcuda.driver.CUdeviceptr, long), cuMemcpyPeer(jcuda.driver.CUdeviceptr, jcuda.driver.CUcontext, jcuda.driver.CUdeviceptr, jcuda.driver.CUcontext, long), cuMemcpyAsync(jcuda.driver.CUdeviceptr, jcuda.driver.CUdeviceptr, long, jcuda.driver.CUstream), cuMemcpy3DPeerAsync(jcuda.driver.CUDA_MEMCPY3D_PEER, jcuda.driver.CUstream), cuMemAdvise(jcuda.driver.CUdeviceptr, long, int, jcuda.driver.CUdevice)

cuMemAdvise
```
public static int cuMemAdvise(CUdeviceptr devPtr,
                              long count,
                              int advice,
                              CUdevice device)
```
Advise about the usage of a given memory range

Advise the Unified Memory subsystem about the usage pattern for the memory range starting at devPtr with a size of count bytes.

The 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. This allows the driver to create read-only copies of the data in a processor's memory when that processor accesses it. Similarly, if cuMemPrefetchAsync is called on this region, it will create a read-only copy of the data on the destination processor. When a processor writes to this data, all copies of the corresponding page are invalidated except for the one where the write occurred. The device argument is ignored for this advice.
- CU_MEM_ADVISE_UNSET_READ_MOSTLY: Undoes the effect of ::CU_MEM_ADVISE_SET_READ_MOSTLY. Any read duplicated copies of the data will be freed no later than the next write access to that data.
- CU_MEM_ADVISE_SET_PREFERRED_LOCATION: This advice sets the preferred location for the data to be the memory belonging to device. Passing in CU_DEVICE_CPU for device sets the preferred location as CPU memory. 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 the 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 thrash detection and resolution logic in the Unified Memory driver. Normally, if a page is detected to be constantly thrashing between CPU and GPU memory say, the page will eventually be pinned to CPU memory by the Unified Memory driver. But if the preferred location is set as GPU memory, then the page will continue to thrash indefinitely. When the Unified Memory driver has to evict pages from a certain location on account of that memory being oversubscribed, the preferred location will be used to decide the destination to which a page should be evicted to. If ::CU_MEM_ADVISE_SET_READ_MOSTLY is also set on this memory region or any subset of it, the preferred location will be ignored for that subset.
- 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 device. This 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 useful 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 other 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 CPU memory because the CPU typically cannot access GPU 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 CPU memory.
- CU_MEM_ADVISE_UNSET_ACCESSED_BY: Undoes the effect of CU_MEM_ADVISE_SET_ACCESSED_BY. The current set of mappings may be removed at any time causing accesses to result in page faults.
Passing in ::CU_DEVICE_CPU for device will set the advice for the CPU.

Note that this function is asynchronous with respect to the host and all work on other devices.
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

See Also:

cuMemcpy(jcuda.driver.CUdeviceptr, jcuda.driver.CUdeviceptr, long), cuMemcpyPeer(jcuda.driver.CUdeviceptr, jcuda.driver.CUcontext, jcuda.driver.CUdeviceptr, jcuda.driver.CUcontext, long), cuMemcpyAsync(jcuda.driver.CUdeviceptr, jcuda.driver.CUdeviceptr, long, jcuda.driver.CUstream), cuMemcpy3DPeerAsync(jcuda.driver.CUDA_MEMCPY3D_PEER, jcuda.driver.CUstream), cuMemPrefetchAsync(jcuda.driver.CUdeviceptr, long, jcuda.driver.CUdevice, jcuda.driver.CUstream)

cuMemRangeGetAttribute
```
public static int cuMemRangeGetAttribute(Pointer data,
                                         long dataSize,
                                         int attribute,
                                         CUdeviceptr devPtr,
                                         long count)
```
Query an attribute of a given memory range.
Query an attribute about the memory range starting at devPtr with a size of count bytes. The memory range must refer to managed memory allocated via cuMemAllocManaged or declared via __managed__ variables.

The attribute parameter can take the following values:
- CU_MEM_RANGE_ATTRIBUTE_READ_MOSTLY: If this attribute is specified, data will be interpreted as a 32-bit integer, and 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.
- CU_MEM_RANGE_ATTRIBUTE_PREFERRED_LOCATION: If this attribute is specified, data will be interpreted as a 32-bit integer, and 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 CU_DEVICE_CPU if all pages in the memory range have the CPU as their preferred location, or it will be CU_DEVICE_INVALID 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.
- CU_MEM_RANGE_ATTRIBUTE_ACCESSED_BY: If this attribute is specified, data will be interpreted as an array of 32-bit integers, and dataSize must be a non-zero multiple of 4. The result returned will be a list of device ids that had CU_MEM_ADVISE_SET_ACCESSED_BY 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 data is larger than the number of devices that have that advice set for that memory range, CU_DEVICE_INVALID will be returned in all the extra space provided. For ex., if dataSize is 12 (i.e. data has 3 elements) and only device 0 has the advice set, then the result returned will be { 0, CU_DEVICE_INVALID, CU_DEVICE_INVALID }. If 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.
- CU_MEM_RANGE_ATTRIBUTE_LAST_PREFETCH_LOCATION: If this attribute is specified, data will be interpreted as a 32-bit integer, and dataSize must be 4. The result returned will be the last location to which all pages in the memory range were prefetched explicitly via cuMemPrefetchAsync. This will either be a GPU id or CU_DEVICE_CPU 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, CU_DEVICE_INVALID 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:

CUDA_SUCCESS, CUDA_ERROR_INVALID_VALUE, CUDA_ERROR_INVALID_DEVICE

See Also:

cuMemRangeGetAttributes(jcuda.Pointer[], long[], int[], long, jcuda.driver.CUdeviceptr, long), cuMemPrefetchAsync(jcuda.driver.CUdeviceptr, long, jcuda.driver.CUdevice, jcuda.driver.CUstream), cuMemAdvise(jcuda.driver.CUdeviceptr, long, int, jcuda.driver.CUdevice)

cuMemRangeGetAttributes
```
public static int cuMemRangeGetAttributes(Pointer[] data,
                                          long[] dataSizes,
                                          int[] attributes,
                                          long numAttributes,
                                          CUdeviceptr devPtr,
                                          long count)
```
Query attributes of a given memory range.

Query attributes of the memory range starting at devPtr with a size of count bytes. The memory range must refer to managed memory allocated via cuMemAllocManaged or declared via __managed__ variables. The attributes array will be interpreted to have numAttributes entries. The dataSizes array will also be interpreted to have numAttributes entries. The results of the query will be stored in data.

The list of supported attributes are given below. Please refer to cuMemRangeGetAttribute(jcuda.Pointer, long, int, jcuda.driver.CUdeviceptr, long) for attribute descriptions and restrictions.
- CU_MEM_RANGE_ATTRIBUTE_READ_MOSTLY
- CU_MEM_RANGE_ATTRIBUTE_PREFERRED_LOCATION
- CU_MEM_RANGE_ATTRIBUTE_ACCESSED_BY
- CU_MEM_RANGE_ATTRIBUTE_LAST_PREFETCH_LOCATION
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:

CUDA_SUCCESS, CUDA_ERROR_DEINITIALIZED, CUDA_ERROR_INVALID_CONTEXT, CUDA_ERROR_INVALID_VALUE, CUDA_ERROR_INVALID_DEVICE

cuPointerSetAttribute
```
public static int cuPointerSetAttribute(Pointer value,
                                        int attribute,
                                        CUdeviceptr ptr)
```
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 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. 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

See Also:

JCudaDriver#cuPointerGetAttribute,, JCudaDriver#cuPointerGetAttributes,, JCudaDriver#cuMemAlloc,, JCudaDriver#cuMemFree,, JCudaDriver#cuMemAllocHost,, JCudaDriver#cuMemFreeHost,, JCudaDriver#cuMemHostAlloc,, JCudaDriver#cuMemHostRegister,, cuMemHostUnregister(jcuda.Pointer)

cuPointerGetAttributes
```
public static int cuPointerGetAttributes(int numAttributes,
                                         int[] attributes,
                                         Pointer data,
                                         CUdeviceptr ptr)
```
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
Unlike ::cuPointerGetAttribute, this function will not return an error when the ptr encountered is not a valid CUDA pointer. Instead, the attributes are assigned default NULL values and CUDA_SUCCESS is returned.

If ptr was not allocated by, mapped by, or registered with a ::CUcontext which uses UVA (Unified Virtual Addressing), ::CUDA_ERROR_INVALID_CONTEXT is returned.
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

Returns:

CUDA_SUCCESS, CUDA_ERROR_DEINITIALIZED, CUDA_ERROR_INVALID_CONTEXT, CUDA_ERROR_INVALID_VALUE, CUDA_ERROR_INVALID_DEVICE

See Also:

JCudaDriver#cuPointerGetAttribute,, cuPointerSetAttribute(jcuda.Pointer, int, jcuda.driver.CUdeviceptr)

cuStreamCreate
```
public static int cuStreamCreate(CUstream phStream,
                                 int Flags)
```
Create a stream.
```
 CUresult cuStreamCreate (
      CUstream* phStream,
      unsigned int  Flags )
 
```
Create a stream. Creates a stream and returns a handle in phStream. The Flags argument determines behaviors of the stream. Valid values for 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.
Note:
Note that this function may also return error codes from previous, asynchronous launches.
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

See Also:

cuStreamDestroy(jcuda.driver.CUstream), cuStreamWaitEvent(jcuda.driver.CUstream, jcuda.driver.CUevent, int), cuStreamQuery(jcuda.driver.CUstream), cuStreamSynchronize(jcuda.driver.CUstream), cuStreamAddCallback(jcuda.driver.CUstream, jcuda.driver.CUstreamCallback, java.lang.Object, int)

cuStreamCreateWithPriority
```
public static int cuStreamCreateWithPriority(CUstream phStream,
                                             int flags,
                                             int priority)
```
Create a stream with the given priority Creates a stream with the specified priority and returns a handle in 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. 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. 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.

Returns:

CUDA_SUCCESS, CUDA_ERROR_DEINITIALIZED, CUDA_ERROR_NOT_INITIALIZED, CUDA_ERROR_INVALID_CONTEXT, CUDA_ERROR_INVALID_VALUE, CUDA_ERROR_OUT_OF_MEMORY

See Also:

cuStreamDestroy(jcuda.driver.CUstream), cuStreamCreate(jcuda.driver.CUstream, int), cuStreamGetPriority(jcuda.driver.CUstream, int[]), cuCtxGetStreamPriorityRange(int[], int[]), cuStreamGetFlags(jcuda.driver.CUstream, int[]), cuStreamWaitEvent(jcuda.driver.CUstream, jcuda.driver.CUevent, int), cuStreamQuery(jcuda.driver.CUstream), cuStreamSynchronize(jcuda.driver.CUstream), cuStreamAddCallback(jcuda.driver.CUstream, jcuda.driver.CUstreamCallback, java.lang.Object, int), JCudaDriver#cudaStreamCreateWithPriority

cuStreamGetPriority
```
public static int cuStreamGetPriority(CUstream hStream,
                                      int[] priority)
```
Query the priority of a given stream. Query the priority of a stream created using ::cuStreamCreate or ::cuStreamCreateWithPriority and return the priority in 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

See Also:

cuStreamDestroy(jcuda.driver.CUstream), cuStreamCreate(jcuda.driver.CUstream, int), cuStreamCreateWithPriority(jcuda.driver.CUstream, int, int), cuCtxGetStreamPriorityRange(int[], int[]), cuStreamGetFlags(jcuda.driver.CUstream, int[]), JCudaDriver#cudaStreamGetPriority

cuStreamGetFlags
```
public static int cuStreamGetFlags(CUstream hStream,
                                   int[] flags)
```
Query the flags of a given stream. Query the flags of a stream created using ::cuStreamCreate or ::cuStreamCreateWithPriority and return the flags in 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 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

See Also:

cuStreamDestroy(jcuda.driver.CUstream), cuStreamCreate(jcuda.driver.CUstream, int), cuStreamGetPriority(jcuda.driver.CUstream, int[]), JCudaDriver#cudaStreamGetFlags

cuStreamGetCtx
```
public static int cuStreamGetCtx(CUstream hStream,
                                 CUcontext pctx)
```
Query the context associated with a stream. Returns the CUDA context that the stream is associated with. The stream handle 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,

See Also:

cuStreamDestroy(jcuda.driver.CUstream), cuStreamCreateWithPriority(jcuda.driver.CUstream, int, int), cuStreamGetPriority(jcuda.driver.CUstream, int[]), cuStreamGetFlags(jcuda.driver.CUstream, int[]), cuStreamWaitEvent(jcuda.driver.CUstream, jcuda.driver.CUevent, int), cuStreamQuery(jcuda.driver.CUstream), cuStreamSynchronize(jcuda.driver.CUstream), cuStreamAddCallback(jcuda.driver.CUstream, jcuda.driver.CUstreamCallback, java.lang.Object, int), JCudaDriver#cudaStreamCreate, JCudaDriver#cudaStreamCreateWithFlags

cuStreamWaitEvent
```
public static int cuStreamWaitEvent(CUstream hStream,
                                    CUevent hEvent,
                                    int Flags)
```
Make a compute stream wait on an event.
```
 CUresult cuStreamWaitEvent (
      CUstream hStream,
      CUevent hEvent,
      unsigned int  Flags )
 
```
Make a compute stream wait on an event. Makes all future work submitted to hStream wait until hEvent reports completion before beginning execution. This synchronization will be performed efficiently on the device. The event hEvent may be from a different context than hStream, in which case this function will perform cross-device synchronization.

The stream hStream will wait only for the completion of the most recent host call to cuEventRecord() on hEvent. Once this call has returned, any functions (including cuEventRecord() and cuEventDestroy()) may be called on hEvent again, and subsequent calls will not have any effect on hStream.

If hStream is 0 (the NULL stream) any future work submitted in any stream will wait for hEvent to complete before beginning execution. This effectively creates a barrier for all future work submitted to the context.

If cuEventRecord() has not been called on hEvent, this call acts as if the record has already completed, and so is a functional no-op.

Note:
Note that this function may also return error codes from previous, asynchronous launches.
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,

See Also:

cuStreamCreate(jcuda.driver.CUstream, int), cuEventRecord(jcuda.driver.CUevent, jcuda.driver.CUstream), cuStreamQuery(jcuda.driver.CUstream), cuStreamSynchronize(jcuda.driver.CUstream), cuStreamAddCallback(jcuda.driver.CUstream, jcuda.driver.CUstreamCallback, java.lang.Object, int), cuStreamDestroy(jcuda.driver.CUstream)

cuStreamAddCallback
```
public static int cuStreamAddCallback(CUstream hStream,
                                      CUstreamCallback callback,
                                      Object userData,
                                      int flags)
```
Add a callback to a compute stream. 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.
```
 CUresult cuStreamAddCallback (
      CUstream hStream,
      CUstreamCallback callback,
      void* userData,
      unsigned int  flags )
 
```
Add a callback to a compute stream. 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.

This API requires compute capability 1.1 or greater. See cuDeviceGetAttribute or cuDeviceGetProperties to query compute capability. Attempting to use this API with earlier compute versions will return CUDA_ERROR_NOT_SUPPORTED.

Note:
Note that this function may also return error codes from previous, asynchronous launches.
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

See Also:

cuStreamCreate(jcuda.driver.CUstream, int), cuStreamQuery(jcuda.driver.CUstream), cuStreamSynchronize(jcuda.driver.CUstream), cuStreamWaitEvent(jcuda.driver.CUstream, jcuda.driver.CUevent, int), cuStreamDestroy(jcuda.driver.CUstream)

cuStreamBeginCapture
```
public static int cuStreamBeginCapture(CUstream hStream,
                                       int mode)
```
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.

Parameters:

hStream - - Stream in which to initiate capture 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

See Also:

JCudaDriver#cuStreamIsCapturing JCudaDriver#cuStreamEndCapture

cuThreadExchangeStreamCaptureMode
```
public static int cuThreadExchangeStreamCaptureMode(int[] mode)
```
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:
- 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.
- 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.
- 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

See Also:

cuStreamBeginCapture(jcuda.driver.CUstream, int)

cuStreamEndCapture
```
public static int cuStreamEndCapture(CUstream hStream,
                                     CUgraph phGraph)
```
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

See Also:

JCudaDriver#cuStreamBeginCapture JCudaDriver#cuStreamIsCapturing

cuStreamIsCapturing
```
public static int cuStreamIsCapturing(CUstream hStream,
                                      int[] captureStatus)
```
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

See Also:

JCudaDriver#cuStreamBeginCapture JCudaDriver#cuStreamEndCapture

cuStreamGetCaptureInfo
```
public static int cuStreamGetCaptureInfo(CUstream hStream,
                                         int[] captureStatus,
                                         long[] id)
```
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

See Also:

JCudaDriver#cuStreamBeginCapture,, cuStreamIsCapturing(jcuda.driver.CUstream, int[])

cuStreamAttachMemAsync
```
public static int cuStreamAttachMemAsync(CUstream hStream,
                                         CUdeviceptr dptr,
                                         long length,
                                         int flags)
```
Attach memory to a stream asynchronously. Enqueues an operation in hStream to specify stream association of length bytes of memory starting from 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. 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, 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, length must be non-zero.

The stream association is specified using 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 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 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 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 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

See Also:

JCudaDriver#cuStreamQuery JCudaDriver#cuStreamSynchronize JCudaDriver#cuStreamWaitEvent JCudaDriver#cuStreamDestroy JCudaDriver#cuMemAllocManaged JCudaDriver#cudaStreamAttachMemAsync

cuStreamQuery
```
public static int cuStreamQuery(CUstream hStream)
```
Determine status of a compute stream.
```
 CUresult cuStreamQuery (
      CUstream hStream )
 
```
Determine status of a compute stream. Returns CUDA_SUCCESS if all operations in the stream specified by hStream have completed, or CUDA_ERROR_NOT_READY if not.

Note:
Note that this function may also return error codes from previous, asynchronous launches.
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

See Also:

cuStreamCreate(jcuda.driver.CUstream, int), cuStreamWaitEvent(jcuda.driver.CUstream, jcuda.driver.CUevent, int), cuStreamDestroy(jcuda.driver.CUstream), cuStreamSynchronize(jcuda.driver.CUstream), cuStreamAddCallback(jcuda.driver.CUstream, jcuda.driver.CUstreamCallback, java.lang.Object, int)

cuStreamSynchronize
```
public static int cuStreamSynchronize(CUstream hStream)
```
Wait until a stream's tasks are completed.
```
 CUresult cuStreamSynchronize (
      CUstream hStream )
 
```
Wait until a stream's tasks are completed. Waits until the device has completed all operations in the stream specified by 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.

Note:
Note that this function may also return error codes from previous, asynchronous launches.
Parameters:

hStream - Stream to wait for

Returns:

CUDA_SUCCESS, CUDA_ERROR_DEINITIALIZED, CUDA_ERROR_NOT_INITIALIZED, CUDA_ERROR_INVALID_CONTEXT, CUDA_ERROR_INVALID_HANDLE

See Also:

cuStreamCreate(jcuda.driver.CUstream, int), cuStreamDestroy(jcuda.driver.CUstream), cuStreamWaitEvent(jcuda.driver.CUstream, jcuda.driver.CUevent, int), cuStreamQuery(jcuda.driver.CUstream), cuStreamAddCallback(jcuda.driver.CUstream, jcuda.driver.CUstreamCallback, java.lang.Object, int)

cuStreamDestroy
```
public static int cuStreamDestroy(CUstream hStream)
```
Destroys a stream.
```
 CUresult cuStreamDestroy (
      CUstream hStream )
 
```
Destroys a stream. Destroys the stream specified by hStream.

In case the device is still doing work in the stream hStream when cuStreamDestroy() is called, the function will return immediately and the resources associated with hStream will be released automatically once the device has completed all work in hStream.

Note:
Note that this function may also return error codes from previous, asynchronous launches.
Parameters:

hStream - Stream to destroy

Returns:

CUDA_SUCCESS, CUDA_ERROR_DEINITIALIZED, CUDA_ERROR_NOT_INITIALIZED, CUDA_ERROR_INVALID_CONTEXT, CUDA_ERROR_INVALID_VALUE

See Also:

cuStreamCreate(jcuda.driver.CUstream, int), cuStreamWaitEvent(jcuda.driver.CUstream, jcuda.driver.CUevent, int), cuStreamQuery(jcuda.driver.CUstream), cuStreamSynchronize(jcuda.driver.CUstream), cuStreamAddCallback(jcuda.driver.CUstream, jcuda.driver.CUstreamCallback, java.lang.Object, int)

cuStreamCopyAttributes
```
public static int cuStreamCopyAttributes(CUstream dst,
                                         CUstream src)
```
Copies attributes from source stream to destination stream Copies attributes from source stream \p src to destination stream \p dst. Both streams must have the same context.

Parameters:

dst - Destination stream

src - Source stream For list of attributes see ::CUstreamAttrID

Returns:

CUDA_SUCCESS, CUDA_ERROR_INVALID_VALUE

See Also:

CUaccessPolicyWindow

cuStreamGetAttribute
```
public static int cuStreamGetAttribute(CUstream hStream,
                                       int attr,
                                       CUstreamAttrValue value_out)
```
Queries stream attribute. Queries attribute attr from hStream and stores it in corresponding member of value_out.

Parameters:

hStream -

attr -

value_out -

Returns:

CUDA_SUCCESS, CUDA_ERROR_INVALID_VALUE, CUDA_ERROR_INVALID_HANDLE

See Also:

CUaccessPolicyWindow

cuStreamSetAttribute
```
public static int cuStreamSetAttribute(CUstream hStream,
                                       int attr,
                                       CUstreamAttrValue value)
```
Sets stream attribute. Sets attribute attr on hStream from corresponding attribute of value. The updated attribute will be applied to subsequent work submitted to the stream. It will not affect previously submitted work.

Parameters:

hStream -

attr -

value -

Returns:

CUDA_SUCCESS, CUDA_ERROR_INVALID_VALUE, CUDA_ERROR_INVALID_HANDLE

See Also:

CUaccessPolicyWindow

cuGLInit
```
@Deprecated
public static int cuGLInit()
```
Deprecated. Deprecated as of CUDA 3.0
Initializes OpenGL interoperability.
```
 CUresult cuGLInit (
      void )
 
```
Initializes OpenGL interoperability. DeprecatedThis function is deprecated as of Cuda 3.0.Initializes OpenGL interoperability. This function is deprecated and calling it is no longer required. It may fail if the needed OpenGL driver facilities are not available.

Note:
Note that this function may also return error codes from previous, asynchronous launches.
Returns:

CUDA_SUCCESS, CUDA_ERROR_DEINITIALIZED, CUDA_ERROR_NOT_INITIALIZED, CUDA_ERROR_INVALID_CONTEXT, CUDA_ERROR_UNKNOWN

See Also:

cuGLMapBufferObject(jcuda.driver.CUdeviceptr, long[], int), cuGLRegisterBufferObject(int), cuGLUnmapBufferObject(int), cuGLUnregisterBufferObject(int), cuGLMapBufferObjectAsync(jcuda.driver.CUdeviceptr, long[], int, jcuda.driver.CUstream), cuGLUnmapBufferObjectAsync(int, jcuda.driver.CUstream), cuGLSetBufferObjectMapFlags(int, int)

cuGLCtxCreate
```
@Deprecated
public static int cuGLCtxCreate(CUcontext pCtx,
                                             int Flags,
                                             CUdevice device)
```
Deprecated. Deprecated as of CUDA 5.0
Create a CUDA context for interoperability with OpenGL.
```
 CUresult cuGLCtxCreate (
      CUcontext* pCtx,
      unsigned int  Flags,
      CUdevice device )
 
```
Create a CUDA context for interoperability with OpenGL. DeprecatedThis function is deprecated as of Cuda 5.0.This function is deprecated and should no longer be used. It is no longer necessary to associate a CUDA context with an OpenGL context in order to achieve maximum interoperability performance.

Note:
Note that this function may also return error codes from previous, asynchronous launches.
Parameters:

pCtx - Returned CUDA context

Flags - Options for CUDA context creation

device - Device on which to create the context

Returns:

CUDA_SUCCESS, CUDA_ERROR_DEINITIALIZED, CUDA_ERROR_NOT_INITIALIZED, CUDA_ERROR_INVALID_CONTEXT, CUDA_ERROR_INVALID_VALUE, CUDA_ERROR_OUT_OF_MEMORY

See Also:

cuCtxCreate(jcuda.driver.CUcontext, int, jcuda.driver.CUdevice), cuGLInit(), cuGLMapBufferObject(jcuda.driver.CUdeviceptr, long[], int), cuGLRegisterBufferObject(int), cuGLUnmapBufferObject(int), cuGLUnregisterBufferObject(int), cuGLMapBufferObjectAsync(jcuda.driver.CUdeviceptr, long[], int, jcuda.driver.CUstream), cuGLUnmapBufferObjectAsync(int, jcuda.driver.CUstream), cuGLSetBufferObjectMapFlags(int, int)

cuGLGetDevices
```
public static int cuGLGetDevices(int[] pCudaDeviceCount,
                                 CUdevice[] pCudaDevices,
                                 int cudaDeviceCount,
                                 int CUGLDeviceList_deviceList)
```
Gets the CUDA devices associated with the current OpenGL context.
```
 CUresult cuGLGetDevices (
      unsigned int* pCudaDeviceCount,
      CUdevice* pCudaDevices,
      unsigned int  cudaDeviceCount,
      CUGLDeviceList deviceList )
 
```
Gets the CUDA devices associated with the current OpenGL context. Returns in *pCudaDeviceCount the number of CUDA-compatible devices corresponding to the current OpenGL context. Also returns in *pCudaDevices at most cudaDeviceCount of the CUDA-compatible devices corresponding to the current OpenGL context. If any of the GPUs being used by the current OpenGL context are not CUDA capable then the call will return CUDA_ERROR_NO_DEVICE.

The deviceList argument may be any of the following:
- CU_GL_DEVICE_LIST_ALL: Query all devices used by the current OpenGL context.
- CU_GL_DEVICE_LIST_CURRENT_FRAME: Query the devices used by the current OpenGL context to render the current frame (in SLI).
- CU_GL_DEVICE_LIST_NEXT_FRAME: Query the devices used by the current OpenGL context to render the next frame (in SLI). Note that this is a prediction, it can't be guaranteed that this is correct in all cases.
Note:
Note that this function may also return error codes from previous, asynchronous launches.
Parameters:

pCudaDeviceCount - Returned number of CUDA devices.

pCudaDevices - Returned CUDA devices.

cudaDeviceCount - The size of the output device array pCudaDevices.

deviceList - The set of devices to return.

Returns:

CUDA_SUCCESS, CUDA_ERROR_NO_DEVICE, CUDA_ERROR_INVALID_VALUECUDA_ERROR_INVALID_CONTEXT

cuGraphicsGLRegisterBuffer
```
public static int cuGraphicsGLRegisterBuffer(CUgraphicsResource pCudaResource,
                                             int buffer,
                                             int Flags)
```
Registers an OpenGL buffer object.
```
 CUresult cuGraphicsGLRegisterBuffer (
      CUgraphicsResource* pCudaResource,
      GLuint buffer,
      unsigned int  Flags )
 
```
Registers an OpenGL buffer object. Registers the buffer object specified by buffer for access by CUDA. A handle to the registered object is returned as pCudaResource. The register flags Flags specify the intended usage, as follows:
- CU_GRAPHICS_REGISTER_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. This is the default value.
- CU_GRAPHICS_REGISTER_FLAGS_READ_ONLY: Specifies that CUDA will not write to this resource.
- CU_GRAPHICS_REGISTER_FLAGS_WRITE_DISCARD: Specifies that CUDA 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.
Note:
Note that this function may also return error codes from previous, asynchronous launches.
Parameters:

pCudaResource - Pointer to the returned object handle

buffer - name of buffer object to be registered

Flags - Register flags

Returns:

CUDA_SUCCESS, CUDA_ERROR_INVALID_HANDLE, CUDA_ERROR_ALREADY_MAPPED, CUDA_ERROR_INVALID_CONTEXT,

See Also:

cuGraphicsUnregisterResource(jcuda.driver.CUgraphicsResource), cuGraphicsMapResources(int, jcuda.driver.CUgraphicsResource[], jcuda.driver.CUstream), cuGraphicsResourceGetMappedPointer(jcuda.driver.CUdeviceptr, long[], jcuda.driver.CUgraphicsResource)

cuGraphicsGLRegisterImage
```
public static int cuGraphicsGLRegisterImage(CUgraphicsResource pCudaResource,
                                            int image,
                                            int target,
                                            int Flags)
```
Register an OpenGL texture or renderbuffer object.
```
 CUresult cuGraphicsGLRegisterImage (
      CUgraphicsResource* pCudaResource,
      GLuint image,
      GLenum target,
      unsigned int  Flags )
 
```
Register an OpenGL texture or renderbuffer object. Registers the texture or renderbuffer object specified by image for access by CUDA. A handle to the registered object is returned as pCudaResource.

target must match the type of the object, and must be one of GL_TEXTURE_2D, GL_TEXTURE_RECTANGLE, GL_TEXTURE_CUBE_MAP, GL_TEXTURE_3D, GL_TEXTURE_2D_ARRAY, or GL_RENDERBUFFER.

The register flags Flags specify the intended usage, as follows:
- CU_GRAPHICS_REGISTER_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. This is the default value.
- CU_GRAPHICS_REGISTER_FLAGS_READ_ONLY: Specifies that CUDA will not write to this resource.
- CU_GRAPHICS_REGISTER_FLAGS_WRITE_DISCARD: Specifies that CUDA 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.
- CU_GRAPHICS_REGISTER_FLAGS_SURFACE_LDST: Specifies that CUDA will bind this resource to a surface reference.
- CU_GRAPHICS_REGISTER_FLAGS_TEXTURE_GATHER: Specifies that CUDA will perform texture gather operations on this resource.
The following image formats are supported. For brevity's sake, the list is abbreviated. For ex., {GL_R, GL_RG} X {8, 16} would expand to the following 4 formats {GL_R8, GL_R16, GL_RG8, GL_RG16} :
- GL_RED, GL_RG, GL_RGBA, GL_LUMINANCE, GL_ALPHA, GL_LUMINANCE_ALPHA, GL_INTENSITY
- {GL_R, GL_RG, GL_RGBA} X {8, 16, 16F, 32F, 8UI, 16UI, 32UI, 8I, 16I, 32I}
- {GL_LUMINANCE, GL_ALPHA, GL_LUMINANCE_ALPHA, GL_INTENSITY} X {8, 16, 16F_ARB, 32F_ARB, 8UI_EXT, 16UI_EXT, 32UI_EXT, 8I_EXT, 16I_EXT, 32I_EXT}
The following image classes are currently disallowed:
- Textures with borders
- Multisampled renderbuffers
Note:
Note that this function may also return error codes from previous, asynchronous launches.
Parameters:

pCudaResource - Pointer to the returned object handle

image - name of texture or renderbuffer object to be registered

target - Identifies the type of object specified by image

Flags - Register flags

Returns:

CUDA_SUCCESS, CUDA_ERROR_INVALID_HANDLE, CUDA_ERROR_ALREADY_MAPPED, CUDA_ERROR_INVALID_CONTEXT,

See Also:

cuGraphicsUnregisterResource(jcuda.driver.CUgraphicsResource), cuGraphicsMapResources(int, jcuda.driver.CUgraphicsResource[], jcuda.driver.CUstream), cuGraphicsSubResourceGetMappedArray(jcuda.driver.CUarray, jcuda.driver.CUgraphicsResource, int, int)

cuGLRegisterBufferObject
```
@Deprecated
public static int cuGLRegisterBufferObject(int bufferobj)
```
Deprecated. Deprecated as of CUDA 3.0
Registers an OpenGL buffer object.
```
 CUresult cuGLRegisterBufferObject (
      GLuint buffer )
 
```
Registers an OpenGL buffer object. DeprecatedThis function is deprecated as of Cuda 3.0.Registers the buffer object specified by buffer for access by CUDA. This function must be called before CUDA can map the buffer object. There must be a valid OpenGL context bound to the current thread when this function is called, and the buffer name is resolved by that context.

Note:
Note that this function may also return error codes from previous, asynchronous launches.
Parameters:

buffer - The name of the buffer object to register.

Returns:

CUDA_SUCCESS, CUDA_ERROR_DEINITIALIZED, CUDA_ERROR_NOT_INITIALIZED, CUDA_ERROR_INVALID_CONTEXT, CUDA_ERROR_ALREADY_MAPPED

See Also:

cuGraphicsGLRegisterBuffer(jcuda.driver.CUgraphicsResource, int, int)

cuGLMapBufferObject
```
@Deprecated
public static int cuGLMapBufferObject(CUdeviceptr dptr,
                                                   long[] size,
                                                   int bufferobj)
```
Deprecated. Deprecated as of CUDA 3.0
Maps an OpenGL buffer object.
```
 CUresult cuGLMapBufferObject (
      CUdeviceptr* dptr,
      size_t* size,
      GLuint buffer )
 
```
Maps an OpenGL buffer object. DeprecatedThis function is deprecated as of Cuda 3.0.Maps the buffer object specified by buffer into the address space of the current CUDA context and returns in *dptr and *size the base pointer and size of the resulting mapping.

There must be a valid OpenGL context bound to the current thread when this function is called. This must be the same context, or a member of the same shareGroup, as the context that was bound when the buffer was registered.

All streams in the current CUDA context are synchronized with the current GL context.

Note:
Note that this function may also return error codes from previous, asynchronous launches.
Parameters:

dptr - Returned mapped base pointer

size - Returned size of mapping

buffer - The name of the buffer object to map

Returns:

CUDA_SUCCESS, CUDA_ERROR_DEINITIALIZED, CUDA_ERROR_NOT_INITIALIZED, CUDA_ERROR_INVALID_CONTEXT, CUDA_ERROR_INVALID_VALUE, CUDA_ERROR_MAP_FAILED

See Also:

cuGraphicsMapResources(int, jcuda.driver.CUgraphicsResource[], jcuda.driver.CUstream)

cuGLUnmapBufferObject
```
@Deprecated
public static int cuGLUnmapBufferObject(int bufferobj)
```
Deprecated. Deprecated as of CUDA 3.0
Unmaps an OpenGL buffer object.
```
 CUresult cuGLUnmapBufferObject (
      GLuint buffer )
 
```
Unmaps an OpenGL buffer object. DeprecatedThis function is deprecated as of Cuda 3.0.Unmaps the buffer object specified by buffer for access by CUDA.

There must be a valid OpenGL context bound to the current thread when this function is called. This must be the same context, or a member of the same shareGroup, as the context that was bound when the buffer was registered.

All streams in the current CUDA context are synchronized with the current GL context.

Note:
Note that this function may also return error codes from previous, asynchronous launches.
Parameters:

buffer - Buffer object to unmap

Returns:

CUDA_SUCCESS, CUDA_ERROR_DEINITIALIZED, CUDA_ERROR_NOT_INITIALIZED, CUDA_ERROR_INVALID_CONTEXT, CUDA_ERROR_INVALID_VALUE

See Also:

cuGraphicsUnmapResources(int, jcuda.driver.CUgraphicsResource[], jcuda.driver.CUstream)

cuGLUnregisterBufferObject
```
@Deprecated
public static int cuGLUnregisterBufferObject(int bufferobj)
```
Deprecated. Deprecated as of CUDA 3.0
Unregister an OpenGL buffer object.
```
 CUresult cuGLUnregisterBufferObject (
      GLuint buffer )
 
```
Unregister an OpenGL buffer object. DeprecatedThis function is deprecated as of Cuda 3.0.Unregisters the buffer object specified by buffer. This releases any resources associated with the registered buffer. After this call, the buffer may no longer be mapped for access by CUDA.

There must be a valid OpenGL context bound to the current thread when this function is called. This must be the same context, or a member of the same shareGroup, as the context that was bound when the buffer was registered.

Note:
Note that this function may also return error codes from previous, asynchronous launches.
Parameters:

buffer - Name of the buffer object to unregister

Returns:

CUDA_SUCCESS, CUDA_ERROR_DEINITIALIZED, CUDA_ERROR_NOT_INITIALIZED, CUDA_ERROR_INVALID_CONTEXT, CUDA_ERROR_INVALID_VALUE

See Also:

cuGraphicsUnregisterResource(jcuda.driver.CUgraphicsResource)

cuGLSetBufferObjectMapFlags
```
@Deprecated
public static int cuGLSetBufferObjectMapFlags(int buffer,
                                                           int Flags)
```
Deprecated. Deprecated as of CUDA 3.0
Set the map flags for an OpenGL buffer object.
```
 CUresult cuGLSetBufferObjectMapFlags (
      GLuint buffer,
      unsigned int  Flags )
 
```
Set the map flags for an OpenGL buffer object. DeprecatedThis function is deprecated as of Cuda 3.0.Sets the map flags for the buffer object specified by buffer.

Changes to Flags will take effect the next time buffer is mapped. The Flags argument may be any of the following:
- CU_GL_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_GL_MAP_RESOURCE_FLAGS_READ_ONLY: Specifies that CUDA kernels which access this resource will not write to this resource.
- CU_GL_MAP_RESOURCE_FLAGS_WRITE_DISCARD: 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 buffer has not been registered for use with CUDA, then CUDA_ERROR_INVALID_HANDLE is returned. If buffer is presently mapped for access by CUDA, then CUDA_ERROR_ALREADY_MAPPED is returned.

There must be a valid OpenGL context bound to the current thread when this function is called. This must be the same context, or a member of the same shareGroup, as the context that was bound when the buffer was registered.

Note:
Note that this function may also return error codes from previous, asynchronous launches.
Parameters:

buffer - Buffer object to unmap

Flags - Map flags

Returns:

CUDA_SUCCESS, CUDA_ERROR_NOT_INITIALIZED, CUDA_ERROR_INVALID_HANDLE, CUDA_ERROR_ALREADY_MAPPED, CUDA_ERROR_INVALID_CONTEXT,

See Also:

cuGraphicsResourceSetMapFlags(jcuda.driver.CUgraphicsResource, int)

cuGLMapBufferObjectAsync
```
@Deprecated
public static int cuGLMapBufferObjectAsync(CUdeviceptr dptr,
                                                        long[] size,
                                                        int buffer,
                                                        CUstream hStream)
```
Deprecated. Deprecated as of CUDA 3.0
Maps an OpenGL buffer object.
```
 CUresult cuGLMapBufferObjectAsync (
      CUdeviceptr* dptr,
      size_t* size,
      GLuint buffer,
      CUstream hStream )
 
```
Maps an OpenGL buffer object. DeprecatedThis function is deprecated as of Cuda 3.0.Maps the buffer object specified by buffer into the address space of the current CUDA context and returns in *dptr and *size the base pointer and size of the resulting mapping.

There must be a valid OpenGL context bound to the current thread when this function is called. This must be the same context, or a member of the same shareGroup, as the context that was bound when the buffer was registered.

Stream hStream in the current CUDA context is synchronized with the current GL context.

Note:
Note that this function may also return error codes from previous, asynchronous launches.
Parameters:

dptr - Returned mapped base pointer

size - Returned size of mapping

buffer - The name of the buffer object to map

hStream - Stream to synchronize

Returns:

CUDA_SUCCESS, CUDA_ERROR_DEINITIALIZED, CUDA_ERROR_NOT_INITIALIZED, CUDA_ERROR_INVALID_CONTEXT, CUDA_ERROR_INVALID_VALUE, CUDA_ERROR_MAP_FAILED

See Also:

cuGraphicsMapResources(int, jcuda.driver.CUgraphicsResource[], jcuda.driver.CUstream)

cuGLUnmapBufferObjectAsync
```
@Deprecated
public static int cuGLUnmapBufferObjectAsync(int buffer,
                                                          CUstream hStream)
```
Deprecated. Deprecated as of CUDA 3.0
Unmaps an OpenGL buffer object.
```
 CUresult cuGLUnmapBufferObjectAsync (
      GLuint buffer,
      CUstream hStream )
 
```
Unmaps an OpenGL buffer object. DeprecatedThis function is deprecated as of Cuda 3.0.Unmaps the buffer object specified by buffer for access by CUDA.

There must be a valid OpenGL context bound to the current thread when this function is called. This must be the same context, or a member of the same shareGroup, as the context that was bound when the buffer was registered.

Stream hStream in the current CUDA context is synchronized with the current GL context.

Note:
Note that this function may also return error codes from previous, asynchronous launches.
Parameters:

buffer - Name of the buffer object to unmap

hStream - Stream to synchronize

Returns:

CUDA_SUCCESS, CUDA_ERROR_DEINITIALIZED, CUDA_ERROR_NOT_INITIALIZED, CUDA_ERROR_INVALID_CONTEXT, CUDA_ERROR_INVALID_VALUE

See Also:

cuGraphicsUnmapResources(int, jcuda.driver.CUgraphicsResource[], jcuda.driver.CUstream)

cuGraphicsUnregisterResource
```
public static int cuGraphicsUnregisterResource(CUgraphicsResource resource)
```
Unregisters a graphics resource for access by CUDA.
```
 CUresult cuGraphicsUnregisterResource (
      CUgraphicsResource resource )
 
```
Unregisters a graphics resource for access by CUDA. Unregisters the graphics resource resource so it is not accessible by CUDA unless registered again.

If resource is invalid then CUDA_ERROR_INVALID_HANDLE is returned.

Note:
Note that this function may also return error codes from previous, asynchronous launches.
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

See Also:

cuGraphicsGLRegisterBuffer(jcuda.driver.CUgraphicsResource, int, int), cuGraphicsGLRegisterImage(jcuda.driver.CUgraphicsResource, int, int, int)

cuGraphicsSubResourceGetMappedArray
```
public static int cuGraphicsSubResourceGetMappedArray(CUarray pArray,
                                                      CUgraphicsResource resource,
                                                      int arrayIndex,
                                                      int mipLevel)
```
Get an array through which to access a subresource of a mapped graphics resource.
```
 CUresult cuGraphicsSubResourceGetMappedArray (
      CUarray* pArray,
      CUgraphicsResource resource,
      unsigned int  arrayIndex,
      unsigned int  mipLevel )
 
```
Get an array through which to access a subresource of a mapped graphics resource. Returns in *pArray an array through which the subresource of the mapped graphics resource resource which corresponds to array index arrayIndex and mipmap level mipLevel may be accessed. The value set in *pArray may change every time that resource is mapped.

If resource is not a texture then it cannot be accessed via an array and CUDA_ERROR_NOT_MAPPED_AS_ARRAY is returned. If arrayIndex is not a valid array index for resource then CUDA_ERROR_INVALID_VALUE is returned. If mipLevel is not a valid mipmap level for resource then CUDA_ERROR_INVALID_VALUE is returned. If resource is not mapped then CUDA_ERROR_NOT_MAPPED is returned.

Note:
Note that this function may also return error codes from previous, asynchronous launches.
Parameters:

pArray - Returned array through which a subresource of 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_MAPPEDCUDA_ERROR_NOT_MAPPED_AS_ARRAY

See Also:

cuGraphicsResourceGetMappedPointer(jcuda.driver.CUdeviceptr, long[], jcuda.driver.CUgraphicsResource)

cuGraphicsResourceGetMappedMipmappedArray
```
public static int cuGraphicsResourceGetMappedMipmappedArray(CUmipmappedArray pMipmappedArray,
                                                            CUgraphicsResource resource)
```
Get a mipmapped array through which to access a mapped graphics resource.
```
 CUresult cuGraphicsResourceGetMappedMipmappedArray (
      CUmipmappedArray* pMipmappedArray,
      CUgraphicsResource resource )
 
```
Get a mipmapped array through which to access a mapped graphics resource. Returns in *pMipmappedArray a mipmapped array through which the mapped graphics resource resource. The value set in *pMipmappedArray may change every time that resource is mapped.

If resource is not a texture then it cannot be accessed via a mipmapped array and CUDA_ERROR_NOT_MAPPED_AS_ARRAY is returned. If resource is not mapped then CUDA_ERROR_NOT_MAPPED is returned.

Note:
Note that this function may also return error codes from previous, asynchronous launches.
Parameters:

pMipmappedArray - Returned mipmapped array through which 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_MAPPEDCUDA_ERROR_NOT_MAPPED_AS_ARRAY

See Also:

cuGraphicsResourceGetMappedPointer(jcuda.driver.CUdeviceptr, long[], jcuda.driver.CUgraphicsResource)

cuGraphicsResourceGetMappedPointer
```
public static int cuGraphicsResourceGetMappedPointer(CUdeviceptr pDevPtr,
                                                     long[] pSize,
                                                     CUgraphicsResource resource)
```
Get a device pointer through which to access a mapped graphics resource.
```
 CUresult cuGraphicsResourceGetMappedPointer (
      CUdeviceptr* pDevPtr,
      size_t* pSize,
      CUgraphicsResource resource )
 
```
Get a device pointer through which to access a mapped graphics resource. Returns in *pDevPtr a pointer through which the mapped graphics resource resource may be accessed. Returns in pSize the size of the memory in bytes which may be accessed from that pointer. The value set in pPointer may change every time that resource is mapped.

If resource is not a buffer then it cannot be accessed via a pointer and CUDA_ERROR_NOT_MAPPED_AS_POINTER is returned. If resource is not mapped then CUDA_ERROR_NOT_MAPPED is returned. *

Note:
Note that this function may also return error codes from previous, asynchronous launches.
Parameters:

pDevPtr - Returned pointer through which resource may be accessed

pSize - Returned size of the buffer accessible starting at *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_MAPPEDCUDA_ERROR_NOT_MAPPED_AS_POINTER

See Also:

cuGraphicsMapResources(int, jcuda.driver.CUgraphicsResource[], jcuda.driver.CUstream), cuGraphicsSubResourceGetMappedArray(jcuda.driver.CUarray, jcuda.driver.CUgraphicsResource, int, int)

cuGraphicsResourceSetMapFlags
```
public static int cuGraphicsResourceSetMapFlags(CUgraphicsResource resource,
                                                int flags)
```
Set usage flags for mapping a graphics resource.
```
 CUresult cuGraphicsResourceSetMapFlags (
      CUgraphicsResource resource,
      unsigned int  flags )
 
```
Set usage flags for mapping a graphics resource. Set flags for mapping the graphics resource resource.

Changes to flags will take effect the next time resource is mapped. The 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 resource is presently mapped for access by CUDA then CUDA_ERROR_ALREADY_MAPPED is returned. If flags is not one of the above values then CUDA_ERROR_INVALID_VALUE is returned.

Note:
Note that this function may also return error codes from previous, asynchronous launches.
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

See Also:

cuGraphicsMapResources(int, jcuda.driver.CUgraphicsResource[], jcuda.driver.CUstream)

cuGraphicsMapResources
```
public static int cuGraphicsMapResources(int count,
                                         CUgraphicsResource[] resources,
                                         CUstream hStream)
```
Map graphics resources for access by CUDA.
```
 CUresult cuGraphicsMapResources (
      unsigned int  count,
      CUgraphicsResource* resources,
      CUstream hStream )
 
```
Map graphics resources for access by CUDA. Maps the count graphics resources in resources for access by CUDA.

The resources in resources may be accessed by CUDA until they are unmapped. The graphics API from which 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 stream begins.

If resources includes any duplicate entries then CUDA_ERROR_INVALID_HANDLE is returned. If any of resources are presently mapped for access by CUDA then CUDA_ERROR_ALREADY_MAPPED is returned.

Note:
Note that this function may also return error codes from previous, asynchronous launches.
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

See Also:

cuGraphicsResourceGetMappedPointer(jcuda.driver.CUdeviceptr, long[], jcuda.driver.CUgraphicsResource), cuGraphicsSubResourceGetMappedArray(jcuda.driver.CUarray, jcuda.driver.CUgraphicsResource, int, int), cuGraphicsUnmapResources(int, jcuda.driver.CUgraphicsResource[], jcuda.driver.CUstream)

cuGraphicsUnmapResources
```
public static int cuGraphicsUnmapResources(int count,
                                           CUgraphicsResource[] resources,
                                           CUstream hStream)
```
Unmap graphics resources.
```
 CUresult cuGraphicsUnmapResources (
      unsigned int  count,
      CUgraphicsResource* resources,
      CUstream hStream )
 
```
Unmap graphics resources. Unmaps the count graphics resources in resources.

Once unmapped, the resources in resources may not be accessed by CUDA until they are mapped again.

This function provides the synchronization guarantee that any CUDA work issued in stream before cuGraphicsUnmapResources() will complete before any subsequently issued graphics work begins.

If resources includes any duplicate entries then CUDA_ERROR_INVALID_HANDLE is returned. If any of resources are not presently mapped for access by CUDA then CUDA_ERROR_NOT_MAPPED is returned.

Note:
Note that this function may also return error codes from previous, asynchronous launches.
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

See Also:

cuGraphicsMapResources(int, jcuda.driver.CUgraphicsResource[], jcuda.driver.CUstream)

cuFuncGetModule
```
public static int cuFuncGetModule(CUmodule hmod,
                                  CUfunction hfunc)
```
Returns a module handle Returns in *hmod the handle of the module that function hfunc is located in. The lifetime of the module corresponds to the lifetime of the context it was loaded in or until the module is explicitly unloaded. The CUDA runtime manages its own modules loaded into the primary context. If the handle returned by this API refers to a module loaded by the CUDA runtime, calling ::cuModuleUnload() on that module will result in undefined behavior.

Parameters:

hmod - - Returned module handle

hfunc - - Function to retrieve module for

Returns:

CUDA_SUCCESS, CUDA_ERROR_DEINITIALIZED, CUDA_ERROR_NOT_INITIALIZED, CUDA_ERROR_INVALID_CONTEXT, CUDA_ERROR_INVALID_VALUE, CUDA_ERROR_NOT_FOUND

cuCtxSetLimit
```
public static int cuCtxSetLimit(int limit,
                                long value)
```
Set resource limits.
```
 CUresult cuCtxSetLimit (
      CUlimit limit,
      size_t value )
 
```
Set resource limits. Setting limit to 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. This limit is only applicable to devices of compute capability 2.0 and higher. Attempting to set this limit on devices of compute capability less than 2.0 will result in the error CUDA_ERROR_UNSUPPORTED_LIMIT being returned.
- 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. This limit is only applicable to devices of compute capability 2.0 and higher. Attempting to set this limit on devices of compute capability less than 2.0 will result in the error CUDA_ERROR_UNSUPPORTED_LIMIT being 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. This limit is only applicable to devices of compute capability 2.0 and higher. Attempting to set this limit on devices of compute capability less than 2.0 will result in the error CUDA_ERROR_UNSUPPORTED_LIMIT being 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.
Note:
Note that this function may also return error codes from previous, asynchronous launches.
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

See Also:

cuCtxCreate(jcuda.driver.CUcontext, int, jcuda.driver.CUdevice), cuCtxDestroy(jcuda.driver.CUcontext), cuCtxGetApiVersion(jcuda.driver.CUcontext, int[]), cuCtxGetCacheConfig(int[]), cuCtxGetDevice(jcuda.driver.CUdevice), cuCtxGetLimit(long[], int), cuCtxPopCurrent(jcuda.driver.CUcontext), cuCtxPushCurrent(jcuda.driver.CUcontext), cuCtxSetCacheConfig(int), cuCtxSynchronize()

cuCtxGetCacheConfig
```
public static int cuCtxGetCacheConfig(int[] pconfig)
```
Returns the preferred cache configuration for the current context.
```
 CUresult cuCtxGetCacheConfig (
      CUfunc_cache* pconfig )
 
```
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 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 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
Note:
Note that this function may also return error codes from previous, asynchronous launches.
Parameters:

pconfig - Returned cache configuration

Returns:

CUDA_SUCCESS, CUDA_ERROR_DEINITIALIZED, CUDA_ERROR_NOT_INITIALIZED, CUDA_ERROR_INVALID_CONTEXT, CUDA_ERROR_INVALID_VALUE

See Also:

cuCtxCreate(jcuda.driver.CUcontext, int, jcuda.driver.CUdevice), cuCtxDestroy(jcuda.driver.CUcontext), cuCtxGetApiVersion(jcuda.driver.CUcontext, int[]), cuCtxGetDevice(jcuda.driver.CUdevice), cuCtxGetLimit(long[], int), cuCtxPopCurrent(jcuda.driver.CUcontext), cuCtxPushCurrent(jcuda.driver.CUcontext), cuCtxSetCacheConfig(int), cuCtxSetLimit(int, long), cuCtxSynchronize(), cuFuncSetCacheConfig(jcuda.driver.CUfunction, int)

cuCtxSetCacheConfig
```
public static int cuCtxSetCacheConfig(int config)
```
Sets the preferred cache configuration for the current context.
```
 CUresult cuCtxSetCacheConfig (
      CUfunc_cache config )
 
```
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 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
Note:
Note that this function may also return error codes from previous, asynchronous launches.
Parameters:

config - Requested cache configuration

Returns:

CUDA_SUCCESS, CUDA_ERROR_DEINITIALIZED, CUDA_ERROR_NOT_INITIALIZED, CUDA_ERROR_INVALID_CONTEXT, CUDA_ERROR_INVALID_VALUE

See Also:

cuCtxCreate(jcuda.driver.CUcontext, int, jcuda.driver.CUdevice), cuCtxDestroy(jcuda.driver.CUcontext), cuCtxGetApiVersion(jcuda.driver.CUcontext, int[]), cuCtxGetCacheConfig(int[]), cuCtxGetDevice(jcuda.driver.CUdevice), cuCtxGetLimit(long[], int), cuCtxPopCurrent(jcuda.driver.CUcontext), cuCtxPushCurrent(jcuda.driver.CUcontext), cuCtxSetLimit(int, long), cuCtxSynchronize(), cuFuncSetCacheConfig(jcuda.driver.CUfunction, int)

cuCtxGetSharedMemConfig
```
public static int cuCtxGetSharedMemConfig(int[] pConfig)
```
Returns the current shared memory configuration for the current context.
```
 CUresult cuCtxGetSharedMemConfig (
      CUsharedconfig* pConfig )
 
```
Returns the current shared memory configuration for the current context. This function will return in 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.
Note:
Note that this function may also return error codes from previous, asynchronous launches.
Parameters:

pConfig - returned shared memory configuration

Returns:

CUDA_SUCCESS, CUDA_ERROR_DEINITIALIZED, CUDA_ERROR_NOT_INITIALIZED, CUDA_ERROR_INVALID_CONTEXT, CUDA_ERROR_INVALID_VALUE

See Also:

cuCtxCreate(jcuda.driver.CUcontext, int, jcuda.driver.CUdevice), cuCtxDestroy(jcuda.driver.CUcontext), cuCtxGetApiVersion(jcuda.driver.CUcontext, int[]), cuCtxGetCacheConfig(int[]), cuCtxGetDevice(jcuda.driver.CUdevice), cuCtxGetLimit(long[], int), cuCtxPopCurrent(jcuda.driver.CUcontext), cuCtxPushCurrent(jcuda.driver.CUcontext), cuCtxSetLimit(int, long), cuCtxSynchronize(), cuCtxGetSharedMemConfig(int[]), cuFuncSetCacheConfig(jcuda.driver.CUfunction, int)

cuCtxSetSharedMemConfig
```
public static int cuCtxSetSharedMemConfig(int config)
```
Sets the shared memory configuration for the current context.
```
 CUresult cuCtxSetSharedMemConfig (
      CUsharedconfig config )
 
```
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.
Note:
Note that this function may also return error codes from previous, asynchronous launches.
Parameters:

config - requested shared memory configuration

Returns:

CUDA_SUCCESS, CUDA_ERROR_DEINITIALIZED, CUDA_ERROR_NOT_INITIALIZED, CUDA_ERROR_INVALID_CONTEXT, CUDA_ERROR_INVALID_VALUE

See Also:

cuCtxCreate(jcuda.driver.CUcontext, int, jcuda.driver.CUdevice), cuCtxDestroy(jcuda.driver.CUcontext), cuCtxGetApiVersion(jcuda.driver.CUcontext, int[]), cuCtxGetCacheConfig(int[]), cuCtxGetDevice(jcuda.driver.CUdevice), cuCtxGetLimit(long[], int), cuCtxPopCurrent(jcuda.driver.CUcontext), cuCtxPushCurrent(jcuda.driver.CUcontext), cuCtxSetLimit(int, long), cuCtxSynchronize(), cuCtxGetSharedMemConfig(int[]), cuFuncSetCacheConfig(jcuda.driver.CUfunction, int)

cuCtxGetApiVersion
```
public static int cuCtxGetApiVersion(CUcontext ctx,
                                     int[] version)
```
Gets the context's API version.
```
 CUresult cuCtxGetApiVersion (
      CUcontext ctx,
      unsigned int* version )
 
```
Gets the context's API version. Returns a version number in 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 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.

Note:
Note that this function may also return error codes from previous, asynchronous launches.
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_UNKNOWN

See Also:

cuCtxCreate(jcuda.driver.CUcontext, int, jcuda.driver.CUdevice), cuCtxDestroy(jcuda.driver.CUcontext), cuCtxGetDevice(jcuda.driver.CUdevice), cuCtxGetLimit(long[], int), cuCtxPopCurrent(jcuda.driver.CUcontext), cuCtxPushCurrent(jcuda.driver.CUcontext), cuCtxSetCacheConfig(int), cuCtxSetLimit(int, long), cuCtxSynchronize()

cuCtxGetStreamPriorityRange
```
public static int cuCtxGetStreamPriorityRange(int[] leastPriority,
                                              int[] greatestPriority)
```
Returns numerical values that correspond to the least and greatest stream priorities.

Returns in *leastPriority and *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 [*greatestPriority, *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 *leastPriority or *greatestPriority respectively. See ::cuStreamCreateWithPriority for details on creating a priority stream.
A NULL may be passed in for *leastPriority or *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

See Also:

cuStreamCreateWithPriority(jcuda.driver.CUstream, int, int), JCudaDriver#cuStreamGetPriority,, JCudaDriver#cuCtxGetDevice,, JCudaDriver#cuCtxSetLimit,, cuCtxSynchronize()

cuCtxResetPersistingL2Cache
```
public static int cuCtxResetPersistingL2Cache()
```
Resets all persisting lines in cache to normal status. ::cuCtxResetPersistingL2Cache Resets all persisting lines in cache to normal status. Takes effect on function return.

Returns:

CUDA_SUCCESS, CUDA_ERROR_NOT_SUPPORTED

See Also:

CUaccessPolicyWindow

cuLaunchKernel

public static int cuLaunchKernel(CUfunction f,
                                 int gridDimX,
                                 int gridDimY,
                                 int gridDimZ,
                                 int blockDimX,
                                 int blockDimY,
                                 int blockDimZ,
                                 int sharedMemBytes,
                                 CUstream hStream,
                                 Pointer kernelParams,
                                 Pointer extra)

Launches a CUDA function.

CUresult cuLaunchKernel	(	CUfunction	f,
		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,
		void **	extra
	)

Invokes the kernel f on a gridDimX x gridDimY x gridDimZ grid of blocks. Each block contains blockDimX x blockDimY x blockDimZ threads.

sharedMemBytes sets the amount of dynamic shared memory that will be available to each thread block.

cuLaunchKernel() can optionally be associated to a stream by passing a non-zero hStream argument.

Kernel parameters to f can be specified in one of two ways:

1) Kernel parameters can be specified via kernelParams. If f has N parameters, then kernelParams needs to be an array of N pointers. Each of kernelParams[0] through 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 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 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 extra parameter exists to allow cuLaunchKernel to take additional less commonly used arguments. 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 extra array;
CU_LAUNCH_PARAM_BUFFER_POINTER, which specifies that the next value in extra will be a pointer to a buffer containing all the kernel parameters for launching kernel f;
CU_LAUNCH_PARAM_BUFFER_SIZE, which specifies that the next value in 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 kernelParams and extra (i.e. both kernelParams and 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 f is launched via cuLaunchKernel(), the previous block shape, shared size and parameter info associated with f is overwritten.

Note that to use cuLaunchKernel(), the kernel 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.

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
See Also:: cuCtxGetCacheConfig(int[]), cuCtxSetCacheConfig(int), cuFuncSetCacheConfig(jcuda.driver.CUfunction, int), cuFuncGetAttribute(int[], int, jcuda.driver.CUfunction)

cuLaunchCooperativeKernel
```
public static int cuLaunchCooperativeKernel(CUfunction f,
                                            int gridDimX,
                                            int gridDimY,
                                            int gridDimZ,
                                            int blockDimX,
                                            int blockDimY,
                                            int blockDimZ,
                                            int sharedMemBytes,
                                            CUstream hStream,
                                            Pointer kernelParams)
```
Launches a CUDA function where thread blocks can cooperate and synchronize as they execute.
```
 CUresult cuLaunchCooperativeKernel (
      CUfunction f,
      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 )
 
```
Launches a CUDA function where thread blocks can cooperate and synchronize as they execute.
Description

Invokes the kernel f on a gridDimX x gridDimY x gridDimZ grid of blocks. Each block contains blockDimX x blockDimY x blockDimZ threads.

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 kernelParams. If f has N parameters, then kernelParams needs to be an array of N pointers. Each of kernelParams[0] through 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 f is launched via cuLaunchCooperativeKernel(), the previous block shape, shared size and parameter info associated with f is overwritten.

Note that to use cuLaunchCooperativeKernel(), the kernel 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.
Note:
- This function uses standard default stream semantics.
- Note that this function may also return error codes from previous, asynchronous launches.
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

See Also:

cuCtxGetCacheConfig(int[]), cuCtxSetCacheConfig(int), cuFuncSetCacheConfig(jcuda.driver.CUfunction, int), cuFuncGetAttribute(int[], int, jcuda.driver.CUfunction), cuLaunchCooperativeKernelMultiDevice(jcuda.driver.CUDA_LAUNCH_PARAMS[], int, int), JCudaDriver#cudaLaunchCooperativeKernel

cuLaunchCooperativeKernelMultiDevice
```
public static int cuLaunchCooperativeKernelMultiDevice(CUDA_LAUNCH_PARAMS[] launchParamsList,
                                                       int numDevices,
                                                       int flags)
```
Launches CUDA functions on multiple devices where thread blocks can cooperate and synchronize as they execute.
```
 CUresult cuLaunchCooperativeKernelMultiDevice (
      CUDA_LAUNCH_PARAMS* launchParamsList,
      unsigned int  numDevices,
      unsigned int  flags )
 
```
Launches CUDA functions on multiple devices where thread blocks can cooperate and synchronize as they execute.
Description

Invokes kernels as specified in the 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 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 launchParamsList.

When kernels are launched via cuLaunchCooperativeKernelMultiDevice(), the previous block shape, shared size and parameter info associated with each CUDA_LAUNCH_PARAMS::function in 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.
Note:
- This function uses standard default stream semantics.
- Note that this function may also return error codes from previous, asynchronous launches.
Parameters:

launchParamsList - List of launch parameters, one per device

numDevices - Size of the 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

See Also:

cuCtxGetCacheConfig(int[]), cuCtxSetCacheConfig(int), cuFuncSetCacheConfig(jcuda.driver.CUfunction, int), cuFuncGetAttribute(int[], int, jcuda.driver.CUfunction), cuLaunchCooperativeKernel(jcuda.driver.CUfunction, int, int, int, int, int, int, int, jcuda.driver.CUstream, jcuda.Pointer), JCudaDriver#cudaLaunchCooperativeKernelMultiDevice

cuLaunchHostFunc
```
public static int cuLaunchHostFunc(CUstream hStream,
                                   CUhostFn fn,
                                   Object userData)
```
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

See Also:

JCudaDriver#cuStreamQuery JCudaDriver#cuStreamSynchronize JCudaDriver#cuStreamWaitEvent JCudaDriver#cuStreamDestroy JCudaDriver#cuMemAllocManaged JCudaDriver#cuStreamAttachMemAsync JCudaDriver#cuStreamAddCallback

cuCtxGetLimit
```
public static int cuCtxGetLimit(long[] pvalue,
                                int limit)
```
Returns resource limits.
```
 CUresult cuCtxGetLimit (
      size_t* pvalue,
      CUlimit limit )
 
```
Returns resource limits. Returns in *pvalue the current size of 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
Note:
Note that this function may also return error codes from previous, asynchronous launches.
Parameters:

pvalue - Returned size of limit

limit - Limit to query

Returns:

CUDA_SUCCESS, CUDA_ERROR_INVALID_VALUE, CUDA_ERROR_UNSUPPORTED_LIMIT

See Also:

cuCtxCreate(jcuda.driver.CUcontext, int, jcuda.driver.CUdevice), cuCtxDestroy(jcuda.driver.CUcontext), cuCtxGetApiVersion(jcuda.driver.CUcontext, int[]), cuCtxGetCacheConfig(int[]), cuCtxGetDevice(jcuda.driver.CUdevice), cuCtxPopCurrent(jcuda.driver.CUcontext), cuCtxPushCurrent(jcuda.driver.CUcontext), cuCtxSetCacheConfig(int), cuCtxSetLimit(int, long), cuCtxSynchronize()

cuProfilerInitialize
```
public static int cuProfilerInitialize(String configFile,
                                       String outputFile,
                                       int outputMode)
```
Deprecated. Deprecated as of CUDA 11.0
Initialize the profiling.
```
 CUresult cuProfilerInitialize (
      const char* configFile,
      const char* outputFile,
      CUoutput_mode outputMode )
 
```
Initialize the profiling. Using this API user can initialize the CUDA profiler by specifying the configuration file, output file and output file format. This API is generally used to profile different set of counters by looping the kernel launch. The configFile parameter can be used to select profiling options including profiler counters. Refer to the "Compute Command Line Profiler User Guide" for supported profiler options and counters.

Limitation: The CUDA profiler cannot be initialized with this API if another profiling tool is already active, as indicated by the CUDA_ERROR_PROFILER_DISABLED return code.

Typical usage of the profiling APIs is as follows:

for each set of counters/options { cuProfilerInitialize(); //Initialize profiling, set the counters or options in the config file ... cuProfilerStart(); // code to be profiled cuProfilerStop(); ... cuProfilerStart(); // code to be profiled cuProfilerStop(); ... }

Note:
Note that this function may also return error codes from previous, asynchronous launches.
Parameters:

configFile - Name of the config file that lists the counters/options for profiling.

outputFile - Name of the outputFile where the profiling results will be stored.

outputMode - outputMode, can be CU_OUT_KEY_VALUE_PAIR or CU_OUT_CSV.

Returns:

CUDA_SUCCESS, CUDA_ERROR_INVALID_CONTEXT, CUDA_ERROR_INVALID_VALUE, CUDA_ERROR_PROFILER_DISABLED

See Also:

cuProfilerStart(), cuProfilerStop()

cuProfilerStart
```
public static int cuProfilerStart()
```
Enable profiling.
```
 CUresult cuProfilerStart (
      void )
 
```
Enable profiling. Enables profile collection by the active profiling tool. If profiling is already enabled, then cuProfilerStart() has no effect.

cuProfilerStart and cuProfilerStop APIs are used to programmatically control the profiling granularity by allowing profiling to be done only on selective pieces of code.

Note:
Note that this function may also return error codes from previous, asynchronous launches.
Returns:

CUDA_SUCCESS, CUDA_ERROR_INVALID_CONTEXT

See Also:

cuProfilerInitialize(java.lang.String, java.lang.String, int), cuProfilerStop()

cuProfilerStop
```
public static int cuProfilerStop()
```
Disable profiling.
```
 CUresult cuProfilerStop (
      void )
 
```
Disable profiling. Disables profile collection by the active profiling tool. If profiling is already disabled, then cuProfilerStop() has no effect.

cuProfilerStart and cuProfilerStop APIs are used to programmatically control the profiling granularity by allowing profiling to be done only on selective pieces of code.

Note:
Note that this function may also return error codes from previous, asynchronous launches.
Returns:

CUDA_SUCCESS, CUDA_ERROR_INVALID_CONTEXT

See Also:

cuProfilerInitialize(java.lang.String, java.lang.String, int), cuProfilerStart()

Class JCudaDriver

Field Summary

Method Summary

Methods inherited from class java.lang.Object

Field Detail

CUDA_VERSION

CU_MEMHOSTALLOC_PORTABLE

CU_MEMHOSTALLOC_DEVICEMAP

CU_MEMHOSTALLOC_WRITECOMBINED

CU_MEMHOSTREGISTER_PORTABLE

CU_MEMHOSTREGISTER_DEVICEMAP

CU_MEMPEERREGISTER_DEVICEMAP

CU_MEMHOSTREGISTER_IOMEMORY

CUDA_COOPERATIVE_LAUNCH_MULTI_DEVICE_NO_PRE_LAUNCH_SYNC

CUDA_COOPERATIVE_LAUNCH_MULTI_DEVICE_NO_POST_LAUNCH_SYNC

CUDA_ARRAY3D_LAYERED

CUDA_ARRAY3D_2DARRAY

CUDA_ARRAY3D_SURFACE_LDST

CUDA_ARRAY3D_CUBEMAP

CUDA_ARRAY3D_TEXTURE_GATHER

CUDA_ARRAY3D_DEPTH_TEXTURE

CUDA_ARRAY3D_COLOR_ATTACHMENT

CU_PARAM_TR_DEFAULT

CU_TRSA_OVERRIDE_FORMAT

CU_TRSF_READ_AS_INTEGER

CU_TRSF_NORMALIZED_COORDINATES

CU_TRSF_SRGB

CU_STREAM_CALLBACK_NONBLOCKING

CU_STREAM_CALLBACK_BLOCKING

CU_TRSF_DISABLE_TRILINEAR_OPTIMIZATION

CU_LAUNCH_PARAM_END

CU_LAUNCH_PARAM_BUFFER_POINTER

CU_LAUNCH_PARAM_BUFFER_SIZE

CU_DEVICE_CPU

CU_DEVICE_INVALID

CU_STREAM_LEGACY

CU_STREAM_PER_THREAD

Method Detail

setLogLevel

setExceptionsEnabled

align

cuModuleLoadDataJIT

cuModuleLoadDataEx

cuModuleLoadData

cuGetErrorString

cuGetErrorName

cuInit

cuDeviceGet

cuDeviceGetCount

cuDeviceGetName

cuDeviceGetUuid

cuDeviceGetLuid

cuDeviceGetLuidNative

cuDeviceComputeCapability

cuDevicePrimaryCtxRetain

cuDevicePrimaryCtxRelease

cuDevicePrimaryCtxSetFlags

cuDeviceTotalMem

cuDeviceGetProperties

cuDeviceGetAttribute

cuDriverGetVersion

cuCtxCreate

cuCtxDestroy

cuCtxAttach

cuCtxDetach

cuCtxPushCurrent

cuCtxPopCurrent

cuCtxSetCurrent

cuCtxGetCurrent

cuCtxGetDevice

cuCtxGetFlags

cuCtxSynchronize

cuModuleLoad

cuModuleLoadData

cuModuleLoadDataEx

cuModuleLoadFatBinary

cuModuleUnload

cuModuleGetFunction

cuModuleGetGlobal

cuModuleGetTexRef