public class JCudaDriver extends Object
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
|
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.
|
public static final int CUDA_VERSION
public static final int CU_MEMHOSTALLOC_PORTABLE
cuMemHostAlloc(jcuda.Pointer, long, int)
public static final int CU_MEMHOSTALLOC_DEVICEMAP
cuMemHostAlloc(jcuda.Pointer, long, int)
public static final int CU_MEMHOSTALLOC_WRITECOMBINED
cuMemHostAlloc(jcuda.Pointer, long, int)
public static final int CU_MEMHOSTREGISTER_PORTABLE
public static final int CU_MEMHOSTREGISTER_DEVICEMAP
@Deprecated public static final int CU_MEMPEERREGISTER_DEVICEMAP
public static final int CU_MEMHOSTREGISTER_IOMEMORY
public static final int CUDA_COOPERATIVE_LAUNCH_MULTI_DEVICE_NO_PRE_LAUNCH_SYNC
public static final int CUDA_COOPERATIVE_LAUNCH_MULTI_DEVICE_NO_POST_LAUNCH_SYNC
public static final int CUDA_ARRAY3D_LAYERED
@Deprecated public static final int CUDA_ARRAY3D_2DARRAY
public static final int CUDA_ARRAY3D_SURFACE_LDST
public static final int CUDA_ARRAY3D_CUBEMAP
public static final int CUDA_ARRAY3D_TEXTURE_GATHER
public static final int CUDA_ARRAY3D_DEPTH_TEXTURE
public static final int CUDA_ARRAY3D_COLOR_ATTACHMENT
public static final int CU_PARAM_TR_DEFAULT
public static final int CU_TRSA_OVERRIDE_FORMAT
public static final int CU_TRSF_READ_AS_INTEGER
public static final int CU_TRSF_NORMALIZED_COORDINATES
public static final int CU_TRSF_SRGB
@Deprecated public static final int CU_STREAM_CALLBACK_NONBLOCKING
cuStreamAddCallback(CUstream, CUstreamCallback, Object, int)
@Deprecated public static final int CU_STREAM_CALLBACK_BLOCKING
cuStreamAddCallback(CUstream, CUstreamCallback, Object, int)
public static final int CU_TRSF_DISABLE_TRILINEAR_OPTIMIZATION
public static final Pointer CU_LAUNCH_PARAM_END
public static final Pointer CU_LAUNCH_PARAM_BUFFER_POINTER
public static final Pointer CU_LAUNCH_PARAM_BUFFER_SIZE
public static final CUdevice CU_DEVICE_CPU
public static final CUdevice CU_DEVICE_INVALID
public static final CUstream CU_STREAM_LEGACY
public static final CUstream CU_STREAM_PER_THREAD
public static void setLogLevel(LogLevel logLevel)
logLevel
- The log level to use.public static void setExceptionsEnabled(boolean enabled)
enabled
- Whether exceptions are enabled@Deprecated public static int align(int value, int alignment)
value
- The address valuealignment
- The desired alignmentpublic static int cuModuleLoadDataJIT(CUmodule module, Pointer pointer, JITOptions jitOptions)
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. public static int cuModuleLoadDataEx(CUmodule phMod, String string, int numOptions, int[] options, Pointer optionValues)
cuModuleLoadDataEx(CUmodule, Pointer, int, int[], Pointer)
which allows passing in the image data as a string.module
- Returned moduleimage
- Module data to loadnumOptions
- Number of optionsoptions
- Options for JIToptionValues
- Option values for JITcuModuleLoadDataEx
cuModuleLoadDataEx(CUmodule, Pointer, int, int[], Pointer)
public static int cuModuleLoadData(CUmodule module, String string)
cuModuleLoadData(CUmodule, byte[])
that converts the given string into a zero-terminated byte array.module
- The modulestring
- The data. May not be null
.cuModuleLoadData
cuModuleLoadData(CUmodule, byte[])
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.
error
- - Error code to convert to stringpStr
- - Address of the string pointer.CUresult
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.
error
- - Error code to convert to stringpStr
- - Address of the string pointer.CUresult
public static int cuInit(int Flags)
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 that this function may also return error codes from previous, asynchronous launches.
Flags
- Initialization flag for CUDA.public static int cuDeviceGet(CUdevice device, int ordinal)
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 that this function may also return error codes from previous, asynchronous launches.
device
- Returned device handleordinal
- Device number to get handle forcuDeviceGetAttribute(int[], int, jcuda.driver.CUdevice)
,
cuDeviceGetCount(int[])
,
cuDeviceGetName(byte[], int, jcuda.driver.CUdevice)
,
cuDeviceTotalMem(long[], jcuda.driver.CUdevice)
public static int cuDeviceGetCount(int[] count)
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 that this function may also return error codes from previous, asynchronous launches.
count
- Returned number of compute-capable devicescuDeviceGetAttribute(int[], int, jcuda.driver.CUdevice)
,
cuDeviceGetName(byte[], int, jcuda.driver.CUdevice)
,
cuDeviceGet(jcuda.driver.CUdevice, int)
,
cuDeviceTotalMem(long[], jcuda.driver.CUdevice)
public static int cuDeviceGetName(byte[] name, int len, CUdevice dev)
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 that this function may also return error codes from previous, asynchronous launches.
name
- Returned identifier string for the devicelen
- Maximum length of string to store in namedev
- Device to get identifier string forcuDeviceGetAttribute(int[], int, jcuda.driver.CUdevice)
,
cuDeviceGetCount(int[])
,
cuDeviceGet(jcuda.driver.CUdevice, int)
,
cuDeviceTotalMem(long[], jcuda.driver.CUdevice)
public static int cuDeviceGetUuid(CUuuid uuid, CUdevice dev)
uuid
- Returned UUIDdev
- Device to get identifier string forJCudaDriver#cuDeviceGetCount
JCudaDriver#cuDeviceGetName
JCudaDriver#cuDeviceGet
JCudaDriver#cuDeviceTotalMem
JCudaDriver#cudaGetDeviceProperties
public static int cuDeviceGetLuid(byte[] luid, int[] deviceNodeMask, CUdevice dev)
luid
- - Returned LUIDdeviceNodeMask
- - Returned device node maskdev
- - Device to get identifier string forJCudaDriver#cuDeviceGetCount
JCudaDriver#cuDeviceGetName
JCudaDriver#cuDeviceGet
JCudaDriver#cuDeviceTotalMem
JCudaDriver#cudaGetDeviceProperties
public static int cuDeviceGetLuidNative(byte[] luid, int[] deviceNodeMask, CUdevice dev)
@Deprecated public static int cuDeviceComputeCapability(int[] major, int[] minor, CUdevice dev)
cuDeviceGetAttribute(int[], int, CUdevice)
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 that this function may also return error codes from previous, asynchronous launches.
major
- Major revision numberminor
- Minor revision numberdev
- Device handlecuDeviceGetAttribute(int[], int, jcuda.driver.CUdevice)
,
cuDeviceGetCount(int[])
,
cuDeviceGetName(byte[], int, jcuda.driver.CUdevice)
,
cuDeviceGet(jcuda.driver.CUdevice, int)
,
cuDeviceTotalMem(long[], jcuda.driver.CUdevice)
public static int cuDevicePrimaryCtxRelease(CUdevice dev)
public static int cuDevicePrimaryCtxSetFlags(CUdevice dev, int flags)
public static int cuDeviceTotalMem(long[] bytes, CUdevice dev)
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 that this function may also return error codes from previous, asynchronous launches.
bytes
- Returned memory available on device in bytesdev
- Device handlecuDeviceGetAttribute(int[], int, jcuda.driver.CUdevice)
,
cuDeviceGetCount(int[])
,
cuDeviceGetName(byte[], int, jcuda.driver.CUdevice)
,
cuDeviceGet(jcuda.driver.CUdevice, int)
@Deprecated public static int cuDeviceGetProperties(CUdevprop prop, CUdevice dev)
cuDeviceGetAttribute(int[], int, CUdevice)
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 that this function may also return error codes from previous, asynchronous launches.
prop
- Returned properties of devicedev
- Device to get properties forcuDeviceGetAttribute(int[], int, jcuda.driver.CUdevice)
,
cuDeviceGetCount(int[])
,
cuDeviceGetName(byte[], int, jcuda.driver.CUdevice)
,
cuDeviceGet(jcuda.driver.CUdevice, int)
,
cuDeviceTotalMem(long[], jcuda.driver.CUdevice)
public static int cuDeviceGetAttribute(int[] pi, int attrib, CUdevice dev)
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_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 that this function may also return error codes from previous, asynchronous launches.
pi
- Returned device attribute valueattrib
- Device attribute to querydev
- Device handlecuDeviceGetCount(int[])
,
cuDeviceGetName(byte[], int, jcuda.driver.CUdevice)
,
cuDeviceGet(jcuda.driver.CUdevice, int)
,
cuDeviceTotalMem(long[], jcuda.driver.CUdevice)
public static int cuDriverGetVersion(int[] driverVersion)
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 that this function may also return error codes from previous, asynchronous launches.
driverVersion
- Returns the CUDA driver versionpublic static int cuCtxCreate(CUcontext pctx, int flags, CUdevice dev)
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 that this function may also return error codes from previous, asynchronous launches.
pctx
- Returned context handle of the new contextflags
- Context creation flagsdev
- Device to create context oncuCtxDestroy(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()
public static int cuCtxDestroy(CUcontext ctx)
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 that this function may also return error codes from previous, asynchronous launches.
ctx
- Context to destroycuCtxCreate(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()
@Deprecated public static int cuCtxAttach(CUcontext pctx, int flags)
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 that this function may also return error codes from previous, asynchronous launches.
pctx
- Returned context handle of the current contextflags
- Context attach flags (must be 0)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()
@Deprecated public static int cuCtxDetach(CUcontext ctx)
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 that this function may also return error codes from previous, asynchronous launches.
ctx
- Context to destroycuCtxCreate(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()
public static int cuCtxPushCurrent(CUcontext ctx)
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 that this function may also return error codes from previous, asynchronous launches.
ctx
- Context to pushcuCtxCreate(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()
public static int cuCtxPopCurrent(CUcontext pctx)
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 that this function may also return error codes from previous, asynchronous launches.
pctx
- Returned new context handlecuCtxCreate(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()
public static int cuCtxSetCurrent(CUcontext ctx)
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 that this function may also return error codes from previous, asynchronous launches.
ctx
- Context to bind to the calling CPU threadcuCtxGetCurrent(jcuda.driver.CUcontext)
,
cuCtxCreate(jcuda.driver.CUcontext, int, jcuda.driver.CUdevice)
,
cuCtxDestroy(jcuda.driver.CUcontext)
public static int cuCtxGetCurrent(CUcontext pctx)
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 that this function may also return error codes from previous, asynchronous launches.
pctx
- Returned context handlecuCtxSetCurrent(jcuda.driver.CUcontext)
,
cuCtxCreate(jcuda.driver.CUcontext, int, jcuda.driver.CUdevice)
,
cuCtxDestroy(jcuda.driver.CUcontext)
public static int cuCtxGetDevice(CUdevice device)
CUresult cuCtxGetDevice ( CUdevice* device )
Returns the device ID for the current context. Returns in *device the ordinal of the current context's device.
Note that this function may also return error codes from previous, asynchronous launches.
device
- Returned device ID for the current contextcuCtxCreate(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()
public static int cuCtxGetFlags(int[] flags)
public static int cuCtxSynchronize()
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 that this function may also return error codes from previous, asynchronous launches.
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)
public static int cuModuleLoad(CUmodule module, String fname)
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 that this function may also return error codes from previous, asynchronous launches.
module
- Returned modulefname
- Filename of module to loadcuModuleGetFunction(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)
public static int cuModuleLoadData(CUmodule module, byte[] image)
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 that this function may also return error codes from previous, asynchronous launches.
module
- Returned moduleimage
- Module data to loadcuModuleGetFunction(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)
public static int cuModuleLoadDataEx(CUmodule phMod, Pointer p, int numOptions, int[] options, Pointer optionValues)
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_TARGET_COMPUTE_10
CU_TARGET_COMPUTE_11
CU_TARGET_COMPUTE_12
CU_TARGET_COMPUTE_13
CU_TARGET_COMPUTE_20
CU_PREFER_PTX
CU_PREFER_BINARY
Note that this function may also return error codes from previous, asynchronous launches.
module
- Returned moduleimage
- Module data to loadnumOptions
- Number of optionsoptions
- Options for JIToptionValues
- Option values for JITcuModuleGetFunction(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)
public static int cuModuleLoadFatBinary(CUmodule module, byte[] fatCubin)
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 that this function may also return error codes from previous, asynchronous launches.
module
- Returned modulefatCubin
- Fat binary to loadcuModuleGetFunction(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)
public static int cuModuleUnload(CUmodule hmod)
CUresult cuModuleUnload ( CUmodule hmod )
Unloads a module. Unloads a module hmod from the current context.
Note that this function may also return error codes from previous, asynchronous launches.
hmod
- Module to unloadcuModuleGetFunction(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[])
public static int cuModuleGetFunction(CUfunction hfunc, CUmodule hmod, String name)
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 that this function may also return error codes from previous, asynchronous launches.
hfunc
- Returned function handlehmod
- Module to retrieve function fromname
- Name of function to retrievecuModuleGetGlobal(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)
public static int cuModuleGetGlobal(CUdeviceptr dptr, long[] bytes, CUmodule hmod, String name)
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 that this function may also return error codes from previous, asynchronous launches.
dptr
- Returned global device pointerbytes
- Returned global size in byteshmod
- Module to retrieve global fromname
- Name of global to retrievecuModuleGetFunction(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)
public static int cuModuleGetTexRef(CUtexref pTexRef, CUmodule hmod, String name)
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 that this function may also return error codes from previous, asynchronous launches.
pTexRef
- Returned texture referencehmod
- Module to retrieve texture reference fromname
- Name of texture reference to retrievecuModuleGetFunction(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)
public static int cuModuleGetSurfRef(CUsurfref pSurfRef, CUmodule hmod, String name)
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 that this function may also return error codes from previous, asynchronous launches.
pSurfRef
- Returned surface referencehmod
- Module to retrieve surface reference fromname
- Name of surface reference to retrievecuModuleGetFunction(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)
public static int cuLinkCreate(JITOptions jitOptions, CUlinkState stateOut)
public static int cuLinkAddData(CUlinkState state, int type, Pointer data, long size, String name, JITOptions jitOptions)
public static int cuLinkAddFile(CUlinkState state, int type, String path, JITOptions jitOptions)
public static int cuLinkComplete(CUlinkState state, Pointer cubinOut, long[] sizeOut)
public static int cuLinkDestroy(CUlinkState state)
public static int cuMemGetInfo(long[] free, long[] total)
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 that this function may also return error codes from previous, asynchronous launches.
free
- Returned free memory in bytestotal
- Returned total memory in bytescuArray3DCreate(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)
public static int cuMemHostAlloc(Pointer pp, long bytes, int Flags)
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 that this function may also return error codes from previous, asynchronous launches.
pp
- Returned host pointer to page-locked memorybytesize
- Requested allocation size in bytesFlags
- Flags for allocation requestcuArray3DCreate(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)
public static int cuMemHostGetDevicePointer(CUdeviceptr ret, Pointer p, int Flags)
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 that this function may also return error codes from previous, asynchronous launches.
pdptr
- Returned device pointerp
- Host pointerFlags
- Options (must be 0)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)
public static int cuMemHostGetFlags(int[] pFlags, Pointer p)
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 that this function may also return error codes from previous, asynchronous launches.
pFlags
- Returned flags wordp
- Host pointercuMemAllocHost(jcuda.Pointer, long)
,
cuMemHostAlloc(jcuda.Pointer, long, int)
public static int cuDeviceGetByPCIBusId(CUdevice dev, String pciBusId)
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 that this function may also return error codes from previous, asynchronous launches.
dev
- Returned device handlepciBusId
- 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 valuescuDeviceGet(jcuda.driver.CUdevice, int)
,
cuDeviceGetAttribute(int[], int, jcuda.driver.CUdevice)
,
cuDeviceGetPCIBusId(java.lang.String[], int, jcuda.driver.CUdevice)
public static int cuMemAllocManaged(CUdeviceptr dptr, long bytesize, int flags)
CUresult cuMemAllocManaged ( CUdeviceptr* dptr, size_t bytesize, unsigned int flags )
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 that this function may also return error codes from previous, asynchronous launches.
dptr
- The device pointerbytesize
- The size in bytesflags
- The flagscuArray3DCreate(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)
public static int cuDeviceGetPCIBusId(String[] pciBusId, int len, CUdevice dev)
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 that this function may also return error codes from previous, asynchronous launches.
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 namedev
- Device to get identifier string forcuDeviceGet(jcuda.driver.CUdevice, int)
,
cuDeviceGetAttribute(int[], int, jcuda.driver.CUdevice)
,
cuDeviceGetByPCIBusId(jcuda.driver.CUdevice, java.lang.String)
public static int cuIpcGetEventHandle(CUipcEventHandle pHandle, CUevent 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.
pHandle
- Pointer to a user allocated CUipcEventHandle in which to return the opaque event handleevent
- Event allocated with CU_EVENT_INTERPROCESS and CU_EVENT_DISABLE_TIMING flags.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)
public static int cuIpcOpenEventHandle(CUevent phEvent, CUipcEventHandle handle)
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.
phEvent
- Returns the imported eventhandle
- Interprocess handle to opencuEventCreate(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)
public static int cuIpcGetMemHandle(CUipcMemHandle pHandle, CUdeviceptr dptr)
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.
pHandle
- Pointer to user allocated CUipcMemHandle to return the handle in.dptr
- Base pointer to previously allocated device memorycuMemAlloc(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)
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.
pdptr
- Returned device pointerhandle
- CUipcMemHandle to openFlags
- Flags for this operation. Must be specified as CU_IPC_MEM_LAZY_ENABLE_PEER_ACCESScuMemAlloc(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)
public static int cuIpcCloseMemHandle(CUdeviceptr dptr)
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.
dptr
- Device pointer returned by cuIpcOpenMemHandlecuMemAlloc(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)
public static int cuMemHostRegister(Pointer p, long bytesize, int Flags)
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 that this function may also return error codes from previous, asynchronous launches.
p
- Host pointer to memory to page-lockbytesize
- Size in bytes of the address range to page-lockFlags
- Flags for allocation requestcuMemHostUnregister(jcuda.Pointer)
,
cuMemHostGetFlags(int[], jcuda.Pointer)
,
cuMemHostGetDevicePointer(jcuda.driver.CUdeviceptr, jcuda.Pointer, int)
public static int cuMemHostUnregister(Pointer p)
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 that this function may also return error codes from previous, asynchronous launches.
p
- Host pointer to memory to unregistercuMemHostRegister(jcuda.Pointer, long, int)
public static int cuMemcpy(CUdeviceptr dst, CUdeviceptr src, long ByteCount)
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 that this function may also return error codes from previous, asynchronous launches.
dst
- Destination unified virtual address space pointersrc
- Source unified virtual address space pointerByteCount
- Size of memory copy in bytescuArray3DCreate(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)
public static int cuMemcpyPeer(CUdeviceptr dstDevice, CUcontext dstContext, CUdeviceptr srcDevice, CUcontext srcContext, long ByteCount)
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 that this function may also return error codes from previous, asynchronous launches.
dstDevice
- Destination device pointerdstContext
- Destination contextsrcDevice
- Source device pointersrcContext
- Source contextByteCount
- Size of memory copy in bytescuMemcpyDtoD(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)
public static int cuMemAlloc(CUdeviceptr dptr, long bytesize)
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 that this function may also return error codes from previous, asynchronous launches.
dptr
- Returned device pointerbytesize
- Requested allocation size in bytescuArray3DCreate(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)
public static int cuMemAllocPitch(CUdeviceptr dptr, long[] pPitch, long WidthInBytes, long Height, int ElementSizeBytes)
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 that this function may also return error codes from previous, asynchronous launches.
dptr
- Returned device pointerpPitch
- Returned pitch of allocation in bytesWidthInBytes
- Requested allocation width in bytesHeight
- Requested allocation height in rowsElementSizeBytes
- Size of largest reads/writes for rangecuArray3DCreate(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)
public static int cuMemFree(CUdeviceptr dptr)
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 that this function may also return error codes from previous, asynchronous launches.
dptr
- Pointer to memory to freecuArray3DCreate(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)
public static int cuMemGetAddressRange(CUdeviceptr pbase, long[] psize, CUdeviceptr dptr)
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 that this function may also return error codes from previous, asynchronous launches.
pbase
- Returned base addresspsize
- Returned size of device memory allocationdptr
- Device pointer to querycuArray3DCreate(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)
public static int cuMemAllocHost(Pointer pointer, long bytesize)
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 that this function may also return error codes from previous, asynchronous launches.
pp
- Returned host pointer to page-locked memorybytesize
- Requested allocation size in bytescuArray3DCreate(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)
public static int cuMemFreeHost(Pointer p)
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 that this function may also return error codes from previous, asynchronous launches.
p
- Pointer to memory to freecuArray3DCreate(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)
public static int cuMemcpyHtoD(CUdeviceptr dstDevice, Pointer srcHost, long ByteCount)
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 that this function may also return error codes from previous, asynchronous launches.
dstDevice
- Destination device pointersrcHost
- Source host pointerByteCount
- Size of memory copy in bytescuArray3DCreate(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)
public static int cuMemcpyDtoH(Pointer dstHost, CUdeviceptr srcDevice, long ByteCount)
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 that this function may also return error codes from previous, asynchronous launches.
dstHost
- Destination host pointersrcDevice
- Source device pointerByteCount
- Size of memory copy in bytescuArray3DCreate(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)
public static int cuMemcpyDtoD(CUdeviceptr dstDevice, CUdeviceptr srcDevice, long ByteCount)
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 that this function may also return error codes from previous, asynchronous launches.
dstDevice
- Destination device pointersrcDevice
- Source device pointerByteCount
- Size of memory copy in bytescuArray3DCreate(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)
public static int cuMemcpyDtoA(CUarray dstArray, long dstIndex, CUdeviceptr srcDevice, long ByteCount)
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 that this function may also return error codes from previous, asynchronous launches.
dstArray
- Destination arraydstOffset
- Offset in bytes of destination arraysrcDevice
- Source device pointerByteCount
- Size of memory copy in bytescuArray3DCreate(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)
public static int cuMemcpyAtoD(CUdeviceptr dstDevice, CUarray hSrc, long SrcIndex, long ByteCount)
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 that this function may also return error codes from previous, asynchronous launches.
dstDevice
- Destination device pointersrcArray
- Source arraysrcOffset
- Offset in bytes of source arrayByteCount
- Size of memory copy in bytescuArray3DCreate(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)
public static int cuMemcpyHtoA(CUarray dstArray, long dstIndex, Pointer pSrc, long ByteCount)
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 that this function may also return error codes from previous, asynchronous launches.
dstArray
- Destination arraydstOffset
- Offset in bytes of destination arraysrcHost
- Source host pointerByteCount
- Size of memory copy in bytescuArray3DCreate(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)
public static int cuMemcpyAtoH(Pointer dstHost, CUarray srcArray, long srcIndex, long ByteCount)
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 that this function may also return error codes from previous, asynchronous launches.
dstHost
- Destination device pointersrcArray
- Source arraysrcOffset
- Offset in bytes of source arrayByteCount
- Size of memory copy in bytescuArray3DCreate(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)
public static int cuMemcpyAtoA(CUarray dstArray, long dstIndex, CUarray srcArray, long srcIndex, long ByteCount)
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 that this function may also return error codes from previous, asynchronous launches.
dstArray
- Destination arraydstOffset
- Offset in bytes of destination arraysrcArray
- Source arraysrcOffset
- Offset in bytes of source arrayByteCount
- Size of memory copy in bytescuArray3DCreate(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)
public static int cuMemcpy2D(CUDA_MEMCPY2D pCopy)
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 that this function may also return error codes from previous, asynchronous launches.
pCopy
- Parameters for the memory copycuArray3DCreate(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)
public static int cuMemcpy2DUnaligned(CUDA_MEMCPY2D pCopy)
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 that this function may also return error codes from previous, asynchronous launches.
pCopy
- Parameters for the memory copycuArray3DCreate(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)
public static int cuMemcpy3D(CUDA_MEMCPY3D pCopy)
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 that this function may also return error codes from previous, asynchronous launches.
pCopy
- Parameters for the memory copycuArray3DCreate(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)
public static int cuMemcpy3DPeer(CUDA_MEMCPY3D_PEER pCopy)
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 that this function may also return error codes from previous, asynchronous launches.
pCopy
- Parameters for the memory copycuMemcpyDtoD(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)
public static int cuMemcpyAsync(CUdeviceptr dst, CUdeviceptr src, long ByteCount, CUstream hStream)
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 that this function may also return error codes from previous, asynchronous launches.
dst
- Destination unified virtual address space pointersrc
- Source unified virtual address space pointerByteCount
- Size of memory copy in byteshStream
- Stream identifiercuArray3DCreate(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)
public static int cuMemcpyPeerAsync(CUdeviceptr dstDevice, CUcontext dstContext, CUdeviceptr srcDevice, CUcontext srcContext, long ByteCount, CUstream hStream)
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 that this function may also return error codes from previous, asynchronous launches.
dstDevice
- Destination device pointerdstContext
- Destination contextsrcDevice
- Source device pointersrcContext
- Source contextByteCount
- Size of memory copy in byteshStream
- Stream identifiercuMemcpyDtoD(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)
public static int cuMemcpyHtoDAsync(CUdeviceptr dstDevice, Pointer srcHost, long ByteCount, CUstream hStream)
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 that this function may also return error codes from previous, asynchronous launches.
dstDevice
- Destination device pointersrcHost
- Source host pointerByteCount
- Size of memory copy in byteshStream
- Stream identifiercuArray3DCreate(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)
public static int cuMemcpyDtoHAsync(Pointer dstHost, CUdeviceptr srcDevice, long ByteCount, CUstream hStream)
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 that this function may also return error codes from previous, asynchronous launches.
dstHost
- Destination host pointersrcDevice
- Source device pointerByteCount
- Size of memory copy in byteshStream
- Stream identifiercuArray3DCreate(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)
public static int cuMemcpyDtoDAsync(CUdeviceptr dstDevice, CUdeviceptr srcDevice, long ByteCount, CUstream hStream)
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 that this function may also return error codes from previous, asynchronous launches.
dstDevice
- Destination device pointersrcDevice
- Source device pointerByteCount
- Size of memory copy in byteshStream
- Stream identifiercuArray3DCreate(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)
public static int cuMemcpyHtoAAsync(CUarray dstArray, long dstIndex, Pointer pSrc, long ByteCount, CUstream hStream)
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 that this function may also return error codes from previous, asynchronous launches.
dstArray
- Destination arraydstOffset
- Offset in bytes of destination arraysrcHost
- Source host pointerByteCount
- Size of memory copy in byteshStream
- Stream identifiercuArray3DCreate(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)
public static int cuMemcpyAtoHAsync(Pointer dstHost, CUarray srcArray, long srcIndex, long ByteCount, CUstream hStream)
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 that this function may also return error codes from previous, asynchronous launches.
dstHost
- Destination pointersrcArray
- Source arraysrcOffset
- Offset in bytes of source arrayByteCount
- Size of memory copy in byteshStream
- Stream identifiercuArray3DCreate(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)
public static int cuMemcpy2DAsync(CUDA_MEMCPY2D pCopy, CUstream hStream)
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 that this function may also return error codes from previous, asynchronous launches.
pCopy
- Parameters for the memory copyhStream
- Stream identifiercuArray3DCreate(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)
public static int cuMemcpy3DAsync(CUDA_MEMCPY3D pCopy, CUstream hStream)
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 that this function may also return error codes from previous, asynchronous launches.
pCopy
- Parameters for the memory copyhStream
- Stream identifiercuArray3DCreate(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)
public static int cuMemcpy3DPeerAsync(CUDA_MEMCPY3D_PEER pCopy, CUstream hStream)
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 that this function may also return error codes from previous, asynchronous launches.
pCopy
- Parameters for the memory copyhStream
- Stream identifiercuMemcpyDtoD(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)
public static int cuMemsetD8(CUdeviceptr dstDevice, byte uc, long N)
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 that this function may also return error codes from previous, asynchronous launches.
dstDevice
- Destination device pointeruc
- Value to setN
- Number of elementscuArray3DCreate(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)
public static int cuMemsetD16(CUdeviceptr dstDevice, short us, long N)
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 that this function may also return error codes from previous, asynchronous launches.
dstDevice
- Destination device pointerus
- Value to setN
- Number of elementscuArray3DCreate(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)
public static int cuMemsetD32(CUdeviceptr dstDevice, int ui, long N)
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 that this function may also return error codes from previous, asynchronous launches.
dstDevice
- Destination device pointerui
- Value to setN
- Number of elementscuArray3DCreate(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)
public static int cuMemsetD2D8(CUdeviceptr dstDevice, long dstPitch, byte uc, long Width, long Height)
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 that this function may also return error codes from previous, asynchronous launches.
dstDevice
- Destination device pointerdstPitch
- Pitch of destination device pointeruc
- Value to setWidth
- Width of rowHeight
- Number of rowscuArray3DCreate(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)
public static int cuMemsetD2D16(CUdeviceptr dstDevice, long dstPitch, short us, long Width, long Height)
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 that this function may also return error codes from previous, asynchronous launches.
dstDevice
- Destination device pointerdstPitch
- Pitch of destination device pointerus
- Value to setWidth
- Width of rowHeight
- Number of rowscuArray3DCreate(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)
public static int cuMemsetD2D32(CUdeviceptr dstDevice, long dstPitch, int ui, long Width, long Height)
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 that this function may also return error codes from previous, asynchronous launches.
dstDevice
- Destination device pointerdstPitch
- Pitch of destination device pointerui
- Value to setWidth
- Width of rowHeight
- Number of rowscuArray3DCreate(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)
public static int cuMemsetD8Async(CUdeviceptr dstDevice, byte uc, long N, CUstream hStream)
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 that this function may also return error codes from previous, asynchronous launches.
dstDevice
- Destination device pointeruc
- Value to setN
- Number of elementshStream
- Stream identifiercuArray3DCreate(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)
public static int cuMemsetD16Async(CUdeviceptr dstDevice, short us, long N, CUstream hStream)
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 that this function may also return error codes from previous, asynchronous launches.
dstDevice
- Destination device pointerus
- Value to setN
- Number of elementshStream
- Stream identifiercuArray3DCreate(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)
public static int cuMemsetD32Async(CUdeviceptr dstDevice, int ui, long N, CUstream hStream)
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 that this function may also return error codes from previous, asynchronous launches.
dstDevice
- Destination device pointerui
- Value to setN
- Number of elementshStream
- Stream identifiercuArray3DCreate(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)
public static int cuMemsetD2D8Async(CUdeviceptr dstDevice, long dstPitch, byte uc, long Width, long Height, CUstream hStream)
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 that this function may also return error codes from previous, asynchronous launches.
dstDevice
- Destination device pointerdstPitch
- Pitch of destination device pointeruc
- Value to setWidth
- Width of rowHeight
- Number of rowshStream
- Stream identifiercuArray3DCreate(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)
public static int cuMemsetD2D16Async(CUdeviceptr dstDevice, long dstPitch, short us, long Width, long Height, CUstream hStream)
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 that this function may also return error codes from previous, asynchronous launches.
dstDevice
- Destination device pointerdstPitch
- Pitch of destination device pointerus
- Value to setWidth
- Width of rowHeight
- Number of rowshStream
- Stream identifiercuArray3DCreate(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)
public static int cuMemsetD2D32Async(CUdeviceptr dstDevice, long dstPitch, int ui, long Width, long Height, CUstream hStream)
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 that this function may also return error codes from previous, asynchronous launches.
dstDevice
- Destination device pointerdstPitch
- Pitch of destination device pointerui
- Value to setWidth
- Width of rowHeight
- Number of rowshStream
- Stream identifiercuArray3DCreate(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)
public static int cuFuncGetAttribute(int[] pi, int attrib, CUfunction func)
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 that this function may also return error codes from previous, asynchronous launches.
pi
- Returned attribute valueattrib
- Attribute requestedhfunc
- Function to query attribute ofcuCtxGetCacheConfig(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)
public static int cuFuncSetAttribute(CUfunction hfunc, int attrib, int value)
hfunc
- Function to query attribute ofattrib
- Attribute requestedvalue
- The value to setcuCtxGetCacheConfig(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
@Deprecated public static int cuFuncSetBlockShape(CUfunction hfunc, int x, int y, int z)
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 that this function may also return error codes from previous, asynchronous launches.
hfunc
- Kernel to specify dimensions ofx
- X dimensiony
- Y dimensionz
- Z dimensioncuFuncSetSharedSize(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)
@Deprecated public static int cuFuncSetSharedSize(CUfunction hfunc, int bytes)
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 that this function may also return error codes from previous, asynchronous launches.
hfunc
- Kernel to specify dynamic shared-memory size forbytes
- Dynamic shared-memory size per thread in bytescuFuncSetBlockShape(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)
public static int cuFuncSetCacheConfig(CUfunction hfunc, int config)
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 that this function may also return error codes from previous, asynchronous launches.
hfunc
- Kernel to configure cache forconfig
- Requested cache configurationcuCtxGetCacheConfig(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)
public static int cuFuncSetSharedMemConfig(CUfunction hfunc, int config)
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 that this function may also return error codes from previous, asynchronous launches.
hfunc
- kernel to be given a shared memory configconfig
- requested shared memory configurationcuCtxGetCacheConfig(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)
public static int cuArrayCreate(CUarray pHandle, CUDA_ARRAY_DESCRIPTOR pAllocateArray)
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;
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 that this function may also return error codes from previous, asynchronous launches.
pHandle
- Returned arraypAllocateArray
- Array descriptorcuArray3DCreate(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)
public static int cuArrayGetDescriptor(CUDA_ARRAY_DESCRIPTOR pArrayDescriptor, CUarray hArray)
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 that this function may also return error codes from previous, asynchronous launches.
pArrayDescriptor
- Returned array descriptorhArray
- Array to get descriptor ofcuArray3DCreate(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)
public static int cuArrayDestroy(CUarray hArray)
CUresult cuArrayDestroy ( CUarray hArray )
Destroys a CUDA array. Destroys the CUDA array hArray.
Note that this function may also return error codes from previous, asynchronous launches.
hArray
- Array to destroycuArray3DCreate(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)
public static int cuArray3DCreate(CUarray pHandle, CUDA_ARRAY3D_DESCRIPTOR pAllocateArray)
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:
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.
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;
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 that this function may also return error codes from previous, asynchronous launches.
pHandle
- Returned arraypAllocateArray
- 3D array descriptorcuArray3DGetDescriptor(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)
public static int cuArray3DGetDescriptor(CUDA_ARRAY3D_DESCRIPTOR pArrayDescriptor, CUarray hArray)
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 that this function may also return error codes from previous, asynchronous launches.
pArrayDescriptor
- Returned 3D array descriptorhArray
- 3D array to get descriptor ofcuArray3DCreate(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)
public static int cuMipmappedArrayCreate(CUmipmappedArray pHandle, CUDA_ARRAY3D_DESCRIPTOR pMipmappedArrayDesc, int numMipmapLevels)
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:
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.
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;
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 that this function may also return error codes from previous, asynchronous launches.
pHandle
- Returned mipmapped arraypMipmappedArrayDesc
- mipmapped array descriptornumMipmapLevels
- Number of mipmap levelscuMipmappedArrayDestroy(jcuda.driver.CUmipmappedArray)
,
cuMipmappedArrayGetLevel(jcuda.driver.CUarray, jcuda.driver.CUmipmappedArray, int)
,
cuArrayCreate(jcuda.driver.CUarray, jcuda.driver.CUDA_ARRAY_DESCRIPTOR)
public static int cuMipmappedArrayGetLevel(CUarray pLevelArray, CUmipmappedArray hMipmappedArray, int level)
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 that this function may also return error codes from previous, asynchronous launches.
pLevelArray
- Returned mipmap level CUDA arrayhMipmappedArray
- CUDA mipmapped arraylevel
- Mipmap levelcuMipmappedArrayCreate(jcuda.driver.CUmipmappedArray, jcuda.driver.CUDA_ARRAY3D_DESCRIPTOR, int)
,
cuMipmappedArrayDestroy(jcuda.driver.CUmipmappedArray)
,
cuArrayCreate(jcuda.driver.CUarray, jcuda.driver.CUDA_ARRAY_DESCRIPTOR)
public static int cuMipmappedArrayDestroy(CUmipmappedArray hMipmappedArray)
CUresult cuMipmappedArrayDestroy ( CUmipmappedArray hMipmappedArray )
Destroys a CUDA mipmapped array. Destroys the CUDA mipmapped array hMipmappedArray.
Note that this function may also return error codes from previous, asynchronous launches.
hMipmappedArray
- Mipmapped array to destroycuMipmappedArrayCreate(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)
public static int cuMemAddressReserve(CUdeviceptr ptr, long size, long alignment, CUdeviceptr addr, long flags)
ptr
- Resulting pointer to start of virtual address range allocatedsize
- Size of the reserved virtual address range requestedalignment
- - Alignment of the reserved virtual address range requestedaddr
- Fixed starting address range requestedflags
- Currently unused, must be zerocuMemAddressFree(jcuda.driver.CUdeviceptr, long)
public static int cuMemAddressFree(CUdeviceptr ptr, long size)
ptr
- Starting address of the virtual address range to freesize
- Size of the virtual address region to freecuMemAddressReserve(jcuda.driver.CUdeviceptr, long, long, jcuda.driver.CUdeviceptr, long)
public static int cuMemCreate(CUmemGenericAllocationHandle handle, long size, CUmemAllocationProp prop, long flags)
handle
- Value of handle returned. All operations on this allocation are to be performed using this handle.size
- Size of the allocation requestedprop
- Properties of the allocation to create.flags
- flags for future use, must be zero now.cuMemRelease(jcuda.driver.CUmemGenericAllocationHandle)
,
cuMemExportToShareableHandle(jcuda.Pointer, jcuda.driver.CUmemGenericAllocationHandle, int, long)
,
cuMemImportFromShareableHandle(jcuda.driver.CUmemGenericAllocationHandle, jcuda.Pointer, int)
public static int cuMemRelease(CUmemGenericAllocationHandle handle)
handle
- Value of handle which was returned previously by cuMemCreate.cuMemCreate
public static int cuMemMap(CUdeviceptr ptr, long size, long offset, CUmemGenericAllocationHandle handle, long flags)
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 memoryflags
- flags for future use, must be zero now.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)
public static int cuMemUnmap(CUdeviceptr ptr, long size)
ptr
- Starting address for the virtual address range to unmapsize
- Size of the virtual address range to unmapcuMemCreate(jcuda.driver.CUmemGenericAllocationHandle, long, jcuda.driver.CUmemAllocationProp, long)
,
cuMemAddressReserve(jcuda.driver.CUdeviceptr, long, long, jcuda.driver.CUdeviceptr, long)
public static int cuMemSetAccess(CUdeviceptr ptr, long size, CUmemAccessDesc[] desc, long count)
ptr
- Starting address for the virtual address rangesize
- Length of the virtual address rangedesc
- Array of ::CUmemAccessDesc that describe how to change the
mapping for each location specifiedcount
- Number of ::CUmemAccessDesc in \p desccuMemSetAccess(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)
public static int cuMemGetAccess(long[] flags, CUmemLocation location, CUdeviceptr ptr)
flags
- Flags set for this locationlocation
- Location in which to check the flags forptr
- Address in which to check the access flags forcuMemSetAccess(jcuda.driver.CUdeviceptr, long, jcuda.driver.CUmemAccessDesc[], long)
public static int cuMemExportToShareableHandle(Pointer shareableHandle, CUmemGenericAllocationHandle handle, int handleType, long flags)
shareableHandle
- Pointer to the location in which to store the requested handle typehandle
- CUDA handle for the memory allocationhandleType
- Type of shareable handle requested (defines type and size of the \p shareableHandle output parameter)flags
- Reserved, must be zerocuMemImportFromShareableHandle(jcuda.driver.CUmemGenericAllocationHandle, jcuda.Pointer, int)
public static int cuMemImportFromShareableHandle(CUmemGenericAllocationHandle handle, Pointer osHandle, int shHandleType)
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.cuMemExportToShareableHandle(jcuda.Pointer, jcuda.driver.CUmemGenericAllocationHandle, int, long)
,
cuMemMap(jcuda.driver.CUdeviceptr, long, long, jcuda.driver.CUmemGenericAllocationHandle, long)
,
cuMemRelease(jcuda.driver.CUmemGenericAllocationHandle)
public static int cuMemGetAllocationGranularity(long[] granularity, CUmemAllocationProp prop, int option)
granularity
- Returned granularity.prop
- Property for which to determine the granularity foroption
- Determines which granularity to returncuMemCreate(jcuda.driver.CUmemGenericAllocationHandle, long, jcuda.driver.CUmemAllocationProp, long)
,
cuMemMap(jcuda.driver.CUdeviceptr, long, long, jcuda.driver.CUmemGenericAllocationHandle, long)
public static int cuMemGetAllocationPropertiesFromHandle(CUmemAllocationProp prop, CUmemGenericAllocationHandle handle)
prop
- Pointer to a properties structure which will hold the information about this handlehandle
- Handle which to perform the query oncuMemCreate(jcuda.driver.CUmemGenericAllocationHandle, long, jcuda.driver.CUmemAllocationProp, long)
,
cuMemImportFromShareableHandle(jcuda.driver.CUmemGenericAllocationHandle, jcuda.Pointer, int)
public static int cuMemRetainAllocationHandle(CUmemGenericAllocationHandle handle, Pointer addr)
handle
- CUDA Memory handle for the backing memory allocation.addr
- Memory address to query, that has been mapped previously.cuMemCreate(jcuda.driver.CUmemGenericAllocationHandle, long, jcuda.driver.CUmemAllocationProp, long)
,
cuMemRelease(jcuda.driver.CUmemGenericAllocationHandle)
,
cuMemMap(jcuda.driver.CUdeviceptr, long, long, jcuda.driver.CUmemGenericAllocationHandle, long)
@Deprecated public static int cuTexRefCreate(CUtexref pTexRef)
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.
pTexRef
- Returned texture referencecuTexRefDestroy(jcuda.driver.CUtexref)
@Deprecated public static int cuTexRefDestroy(CUtexref hTexRef)
CUresult cuTexRefDestroy ( CUtexref hTexRef )
Destroys a texture reference. Deprecated Destroys the texture reference specified by hTexRef.
hTexRef
- Texture reference to destroycuTexRefCreate(jcuda.driver.CUtexref)
public static int cuTexRefSetArray(CUtexref hTexRef, CUarray hArray, int Flags)
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.
hTexRef
- Texture reference to bindhArray
- Array to bindFlags
- Options (must be CU_TRSA_OVERRIDE_FORMAT)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)
public static int cuTexRefSetMipmappedArray(CUtexref hTexRef, CUmipmappedArray hMipmappedArray, int Flags)
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.
hTexRef
- Texture reference to bindhMipmappedArray
- Mipmapped array to bindFlags
- Options (must be CU_TRSA_OVERRIDE_FORMAT)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)
public static int cuTexRefSetAddress(long[] ByteOffset, CUtexref hTexRef, CUdeviceptr dptr, long bytes)
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().
ByteOffset
- Returned byte offsethTexRef
- Texture reference to binddptr
- Device pointer to bindbytes
- Size of memory to bind in bytescuTexRefSetAddress2D(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)
public static int cuTexRefSetFormat(CUtexref hTexRef, int fmt, int NumPackedComponents)
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.
hTexRef
- Texture referencefmt
- Format to setNumPackedComponents
- Number of components per array elementcuTexRefSetAddress(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)
public static int cuTexRefSetAddress2D(CUtexref hTexRef, CUDA_ARRAY_DESCRIPTOR desc, CUdeviceptr dptr, long PitchInBytes)
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.
hTexRef
- Texture reference to binddesc
- Descriptor of CUDA arraydptr
- Device pointer to bindPitch
- Line pitch in bytescuTexRefSetAddress(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)
public static int cuTexRefSetAddressMode(CUtexref hTexRef, int dim, int am)
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.
hTexRef
- Texture referencedim
- Dimensionam
- Addressing mode to setcuTexRefSetAddress(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)
public static int cuTexRefSetFilterMode(CUtexref hTexRef, int fm)
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.
hTexRef
- Texture referencefm
- Filtering mode to setcuTexRefSetAddress(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)
public static int cuTexRefSetMipmapFilterMode(CUtexref hTexRef, int fm)
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.
hTexRef
- Texture referencefm
- Filtering mode to setcuTexRefSetAddress(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)
public static int cuTexRefSetMipmapLevelBias(CUtexref hTexRef, float bias)
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.
hTexRef
- Texture referencebias
- Mipmap level biascuTexRefSetAddress(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)
public static int cuTexRefSetMipmapLevelClamp(CUtexref hTexRef, float minMipmapLevelClamp, float maxMipmapLevelClamp)
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.
hTexRef
- Texture referenceminMipmapLevelClamp
- Mipmap min level clampmaxMipmapLevelClamp
- Mipmap max level clampcuTexRefSetAddress(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)
public static int cuTexRefSetMaxAnisotropy(CUtexref hTexRef, int maxAniso)
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.
hTexRef
- Texture referencemaxAniso
- Maximum anisotropycuTexRefSetAddress(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)
public static int cuTexRefSetBorderColor(CUtexref hTexRef, float[] pBorderColor)
hTexRef
- Texture referencepBorderColor
- RGBA colorcuTexRefSetAddressMode(jcuda.driver.CUtexref, int, int)
,
cuTexRefGetAddressMode(int[], jcuda.driver.CUtexref, int)
,
cuTexRefGetBorderColor(float[], jcuda.driver.CUtexref)
public static int cuTexRefSetFlags(CUtexref hTexRef, int Flags)
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;
hTexRef
- Texture referenceFlags
- Optional flags to setcuTexRefSetAddress(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)
public static int cuTexRefGetAddress(CUdeviceptr pdptr, CUtexref hTexRef)
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.
pdptr
- Returned device addresshTexRef
- Texture referencecuTexRefSetAddress(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)
public static int cuTexRefGetArray(CUarray phArray, CUtexref hTexRef)
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.
phArray
- Returned arrayhTexRef
- Texture referencecuTexRefSetAddress(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)
public static int cuTexRefGetMipmappedArray(CUmipmappedArray phMipmappedArray, CUtexref hTexRef)
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.
phMipmappedArray
- Returned mipmapped arrayhTexRef
- Texture referencecuTexRefSetAddress(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)
public static int cuTexRefGetAddressMode(int[] pam, CUtexref hTexRef, int dim)
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.
pam
- Returned addressing modehTexRef
- Texture referencedim
- DimensioncuTexRefSetAddress(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)
public static int cuTexRefGetFilterMode(int[] pfm, CUtexref hTexRef)
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.
pfm
- Returned filtering modehTexRef
- Texture referencecuTexRefSetAddress(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)
public static int cuTexRefGetFormat(int[] pFormat, int[] pNumChannels, CUtexref hTexRef)
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.
pFormat
- Returned formatpNumChannels
- Returned number of componentshTexRef
- Texture referencecuTexRefSetAddress(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)
public static int cuTexRefGetMipmapFilterMode(int[] pfm, CUtexref hTexRef)
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.
pfm
- Returned mipmap filtering modehTexRef
- Texture referencecuTexRefSetAddress(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)
public static int cuTexRefGetMipmapLevelBias(float[] pbias, CUtexref hTexRef)
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.
pbias
- Returned mipmap level biashTexRef
- Texture referencecuTexRefSetAddress(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)
public static int cuTexRefGetMipmapLevelClamp(float[] pminMipmapLevelClamp, float[] pmaxMipmapLevelClamp, CUtexref hTexRef)
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.
pminMipmapLevelClamp
- Returned mipmap min level clamppmaxMipmapLevelClamp
- Returned mipmap max level clamphTexRef
- Texture referencecuTexRefSetAddress(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)
public static int cuTexRefGetMaxAnisotropy(int[] pmaxAniso, CUtexref hTexRef)
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.
pmaxAniso
- Returned maximum anisotropyhTexRef
- Texture referencecuTexRefSetAddress(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)
public static int cuTexRefGetBorderColor(float[] pBorderColor, CUtexref hTexRef)
hTexRef
- Texture referencepBorderColor
- Returned Type and Value of RGBA colorcuTexRefSetAddressMode(jcuda.driver.CUtexref, int, int)
,
cuTexRefSetAddressMode(jcuda.driver.CUtexref, int, int)
,
cuTexRefSetBorderColor(jcuda.driver.CUtexref, float[])
public static int cuTexRefGetFlags(int[] pFlags, CUtexref hTexRef)
CUresult cuTexRefGetFlags ( unsigned int* pFlags, CUtexref hTexRef )