jcuda.runtime
Class JCuda

java.lang.Object
  extended by jcuda.runtime.JCuda

public class JCuda
extends java.lang.Object

Java bindings for the NVidia CUDA runtime API.

Most comments are extracted from the CUDA online documentation


Field Summary
static int cudaArraySurfaceLoadStore
          Must be set in cudaMallocArray in order to bind surfaces to the CUDA array
static int cudaDeviceBlockingSync
          Device flag - Use blocking synchronization
static int cudaDeviceLmemResizeToMax
          Device flag - Keep local memory allocation after launch
static int cudaDeviceMapHost
          Device flag - Support mapped pinned allocations
static int cudaDeviceMask
          Device flags mask
static int cudaDeviceScheduleAuto
          Device flag - Automatic scheduling
static int cudaDeviceScheduleSpin
          Device flag - Spin default scheduling
static int cudaDeviceScheduleYield
          Device flag - Yield default scheduling
static int cudaEventBlockingSync
          Event uses blocking synchronization
static int cudaEventDefault
          Default event flag
static int cudaHostAllocDefault
          Default page-locked allocation flag
static int cudaHostAllocMapped
          Map allocation into device space
static int cudaHostAllocPortable
          Pinned memory accessible by all CUDA contexts
static int cudaHostAllocWriteCombined
          Write-combined memory
static int CUDART_VERSION
          CUDA runtime version
 
Method Summary
static int cudaBindSurfaceToArray(surfaceReference surfref, cudaArray array, cudaChannelFormatDesc desc)
          Binds an array to a surface.
static int cudaBindTexture(long[] offset, textureReference texref, Pointer devPtr, cudaChannelFormatDesc desc, long size)
          Binds a memory area to a texture.
static int cudaBindTexture2D(long[] offset, textureReference texref, Pointer devPtr, cudaChannelFormatDesc desc, long width, long height, long pitch)
          Binds a 2D memory area to a texture.
static int cudaBindTextureToArray(textureReference texref, cudaArray array, cudaChannelFormatDesc desc)
          Binds an array to a texture.
static int cudaChooseDevice(int[] device, cudaDeviceProp prop)
          Select compute-device which best matches criteria.
static int cudaConfigureCall(dim3 gridDim, dim3 blockDim, long sharedMem, cudaStream_t stream)
          Configure a device-launch.
static cudaChannelFormatDesc cudaCreateChannelDesc(int x, int y, int z, int w, int cudaChannelFormatKind_f)
          Returns a channel descriptor using the specified format.
static int cudaDriverGetVersion(int[] driverVersion)
          Returns the CUDA driver version.
static int cudaEventCreate(cudaEvent_t event)
          Creates an event object.
static int cudaEventCreateWithFlags(cudaEvent_t event, int flags)
          Creates an event object with the specified flags.
static int cudaEventDestroy(cudaEvent_t event)
          Destroys an event object.
static int cudaEventElapsedTime(float[] ms, cudaEvent_t start, cudaEvent_t end)
          Computes the elapsed time between events.
static int cudaEventQuery(cudaEvent_t event)
          Query if an event has been recorded.
static int cudaEventRecord(cudaEvent_t event, cudaStream_t stream)
          Records an event.
static int cudaEventSynchronize(cudaEvent_t event)
          Wait for an event to be recorded.
static int cudaFree(Pointer devPtr)
          Frees memory on the device.
static int cudaFreeArray(cudaArray array)
          Frees an array on the device.
static int cudaFreeHost(Pointer ptr)
          Frees page-locked memory.
static int cudaFuncGetAttributes(cudaFuncAttributes attr, java.lang.String func)
          Find out attributes for a given function.
static int cudaGetChannelDesc(cudaChannelFormatDesc desc, cudaArray array)
          Get the channel descriptor of an array.
static int cudaGetDevice(int[] device)
          Returns which device is currently being used.
static int cudaGetDeviceCount(int[] count)
          Returns the number of compute-capable devices.
static int cudaGetDeviceProperties(cudaDeviceProp prop, int device)
          Returns information about the compute-device.
static java.lang.String cudaGetErrorString(int error)
          Returns the message string from an error code.
static int cudaGetLastError()
          Returns the last error from a runtime call.
static int cudaGetSurfaceAlignmentOffset(long[] offset, surfaceReference surfref)
          NOTE: This function occurs in the documentation and the header filed, but is NOT present in the CUDA runtime library, Version 3.1, Build 9.
static int cudaGetSurfaceReference(surfaceReference surfref, java.lang.String symbol)
          Get the surface reference associated with a symbol.
static int cudaGetSymbolAddress(Pointer devPtr, java.lang.String symbol)
          Finds the address associated with a CUDA symbol.
static int cudaGetSymbolSize(long[] size, java.lang.String symbol)
          Finds the size of the object associated with a CUDA symbol.
static int cudaGetTextureAlignmentOffset(long[] offset, textureReference texref)
          Get the alignment offset of a texture.
static int cudaGetTextureReference(textureReference texref, java.lang.String symbol)
          Get the texture reference associated with a symbol.
static int cudaGLMapBufferObject(Pointer devPtr, int bufObj)
          Maps a buffer object for access by CUDA.
static int cudaGLMapBufferObjectAsync(Pointer devPtr, int bufObj, cudaStream_t stream)
          Maps a buffer object for access by CUDA.
static int cudaGLRegisterBufferObject(int bufObj)
          Registers a buffer object for access by CUDA.
static int cudaGLSetBufferObjectMapFlags(int bufObj, int flags)
          Set usage flags for mapping an OpenGL buffer.
static int cudaGLSetGLDevice(int device)
          Sets the CUDA device for use with OpenGL interoperability.
static int cudaGLUnmapBufferObject(int bufObj)
          Unmaps a buffer object for access by CUDA.
static int cudaGLUnmapBufferObjectAsync(int bufObj, cudaStream_t stream)
          Unmaps a buffer object for access by CUDA.
static int cudaGLUnregisterBufferObject(int bufObj)
          Unregisters a buffer object for access by CUDA.
static int cudaGraphicsGLRegisterBuffer(cudaGraphicsResource resource, int buffer, int Flags)
          Registers an OpenGL buffer object.
static int cudaGraphicsGLRegisterImage(cudaGraphicsResource resource, int image, int target, int Flags)
          Register an OpenGL texture or renderbuffer object.
static int cudaGraphicsMapResources(int count, cudaGraphicsResource[] resources, cudaStream_t stream)
          Map graphics resources for access by CUDA.
static int cudaGraphicsResourceGetMappedPointer(Pointer devPtr, long[] size, cudaGraphicsResource resource)
          Get an device pointer through which to access a mapped graphics resource.
static int cudaGraphicsResourceSetMapFlags(cudaGraphicsResource resource, int flags)
          Set usage flags for mapping a graphics resource.
static int cudaGraphicsSubResourceGetMappedArray(cudaArray arrayPtr, cudaGraphicsResource resource, int arrayIndex, int mipLevel)
          Get an array through which to access a subresource of a mapped graphics resource.
static int cudaGraphicsUnmapResources(int count, cudaGraphicsResource[] resources, cudaStream_t stream)
          Unmap graphics resources.
static int cudaGraphicsUnregisterResource(cudaGraphicsResource resource)
          Unregisters a graphics resource for access by CUDA.
static int cudaHostAlloc(Pointer ptr, long size, int flags)
          Allocates page-locked memory on the host.
static int cudaHostGetDevicePointer(Pointer pDevice, Pointer pHost, int flags)
          Passes back device pointer of mapped host memory allocated by cudaHostAlloc().
static int cudaLaunch(java.lang.String symbol)
          Launches a device function.
static int cudaMalloc(Pointer devPtr, long size)
          Allocate memory on the device.
static int cudaMalloc3D(cudaPitchedPtr pitchDevPtr, cudaExtent extent)
          Allocates logical 1D, 2D, or 3D memory objects on the device.
static int cudaMalloc3DArray(cudaArray arrayPtr, cudaChannelFormatDesc desc, cudaExtent extent)
          Calls cudaMalloc3DArray wit the default value '0' as the last parameter
static int cudaMalloc3DArray(cudaArray arrayPtr, cudaChannelFormatDesc desc, cudaExtent extent, int flags)
          Allocate an array on the device.
static int cudaMallocArray(cudaArray array, cudaChannelFormatDesc desc, long width, long height)
          Calls cudaMallocArray wit the default value '0' as the last parameter
static int cudaMallocArray(cudaArray array, cudaChannelFormatDesc desc, long width, long height, int flags)
          Allocate an array on the device.
static int cudaMallocHost(Pointer ptr, long size)
          Allocates page-locked memory on the host.
static int cudaMallocPitch(Pointer devPtr, long[] pitch, long width, long height)
          Allocates pitched memory on the device.
static int cudaMemcpy(Pointer dst, Pointer src, long count, int cudaMemcpyKind_kind)
          Copies data between host and device.
static int cudaMemcpy2D(Pointer dst, long dpitch, Pointer src, long spitch, long width, long height, int cudaMemcpyKind_kind)
          Copies data between host and device.
static int cudaMemcpy2DArrayToArray(cudaArray dst, long wOffsetDst, long hOffsetDst, cudaArray src, long wOffsetSrc, long hOffsetSrc, long width, long height, int cudaMemcpyKind_kind)
          Copies data between host and device.
static int cudaMemcpy2DAsync(Pointer dst, long dpitch, Pointer src, long spitch, long width, long height, int cudaMemcpyKind_kind, cudaStream_t stream)
          Copies data between host and device.
static int cudaMemcpy2DFromArray(Pointer dst, long dpitch, cudaArray src, long wOffset, long hOffset, long width, long height, int cudaMemcpyKind_kind)
          Copies data between host and device.
static int cudaMemcpy2DFromArrayAsync(Pointer dst, long dpitch, cudaArray src, long wOffset, long hOffset, long width, long height, int cudaMemcpyKind_kind, cudaStream_t stream)
          Copies data between host and device.
static int cudaMemcpy2DToArray(cudaArray dst, long wOffset, long hOffset, Pointer src, long spitch, long width, long height, int cudaMemcpyKind_kind)
          Copies data between host and device.
static int cudaMemcpy2DToArrayAsync(cudaArray dst, long wOffset, long hOffset, Pointer src, long spitch, long width, long height, int cudaMemcpyKind_kind, cudaStream_t stream)
          Copies data between host and device.
static int cudaMemcpy3D(cudaMemcpy3DParms p)
          Copies data between 3D objects.
static int cudaMemcpy3DAsync(cudaMemcpy3DParms p, cudaStream_t stream)
          Copies data between 3D objects.
static int cudaMemcpyArrayToArray(cudaArray dst, long wOffsetDst, long hOffsetDst, cudaArray src, long wOffsetSrc, long hOffsetSrc, long count, int cudaMemcpyKind_kind)
          Copies data between host and device.
static int cudaMemcpyAsync(Pointer dst, Pointer src, long count, int cudaMemcpyKind_kind, cudaStream_t stream)
          Copies data between host and device.
static int cudaMemcpyFromArray(Pointer dst, cudaArray src, long wOffset, long hOffset, long count, int cudaMemcpyKind_kind)
          Copies data between host and device.
static int cudaMemcpyFromArrayAsync(Pointer dst, cudaArray src, long wOffset, long hOffset, long count, int cudaMemcpyKind_kind, cudaStream_t stream)
          Copies data between host and device.
static int cudaMemcpyFromSymbol(Pointer dst, java.lang.String symbol, long count, long offset, int cudaMemcpyKind_kind)
          Copies data from the given symbol on the device.
static int cudaMemcpyFromSymbolAsync(Pointer dst, java.lang.String symbol, long count, long offset, int cudaMemcpyKind_kind, cudaStream_t stream)
          Copies data from the given symbol on the device.
static int cudaMemcpyToArray(cudaArray dst, long wOffset, long hOffset, Pointer src, long count, int cudaMemcpyKind_kind)
          Copies data between host and device.
static int cudaMemcpyToArrayAsync(cudaArray dst, long wOffset, long hOffset, Pointer src, long count, int cudaMemcpyKind_kind, cudaStream_t stream)
          Copies data between host and device.
static int cudaMemcpyToSymbol(java.lang.String symbol, Pointer src, long count, long offset, int cudaMemcpyKind_kind)
          Copies data to the given symbol on the device.
static int cudaMemcpyToSymbolAsync(java.lang.String symbol, Pointer src, long count, long offset, int cudaMemcpyKind_kind, cudaStream_t stream)
          Copies data to the given symbol on the device.
static int cudaMemset(Pointer mem, int c, long count)
          Initializes or sets device memory to a value.
static int cudaMemset2D(Pointer mem, long pitch, int c, long width, long height)
          Initializes or sets device memory to a value.
static int cudaMemset3D(cudaPitchedPtr pitchDevPtr, int value, cudaExtent extent)
          Initializes or sets device memory to a value.
static int cudaPeekAtLastError()
          Returns the last error from a runtime call.
static int cudaRuntimeGetVersion(int[] runtimeVersion)
          Returns the CUDA Runtime version.
static int cudaSetDevice(int device)
          Set device to be used for GPU executions.
static int cudaSetDeviceFlags(int flags)
          Sets flags to be used for device executions.
static int cudaSetupArgument(Pointer arg, long size, long offset)
          Configure a device launch.
static int cudaSetValidDevices(int[] device_arr, int len)
          Set a list of devices that can be used for CUDA.
static int cudaStreamCreate(cudaStream_t stream)
          Create an asynchronous stream.
static int cudaStreamDestroy(cudaStream_t stream)
          Destroys and cleans up an asynchronous stream.
static int cudaStreamQuery(cudaStream_t stream)
          Queries an asynchronous stream for completion status.
static int cudaStreamSynchronize(cudaStream_t stream)
          Waits for stream tasks to complete.
static int cudaThreadExit()
          Exit and clean up from CUDA launches.
static int cudaThreadGetLimit(long[] pValue, int limit)
          Returns resource limits.
static int cudaThreadSetLimit(int limit, long value)
          Set resource limits.
static int cudaThreadSynchronize()
          Wait for compute device to finish.
static int cudaUnbindTexture(textureReference texref)
          Unbinds a texture.
static void initialize()
          Initializes the native library.
static void setEmulation(boolean emulation)
          Deprecated. The emulation mode has been deprecated in CUDA 3.0. This function no longer has any effect, and will be removed in the next release.
static void setExceptionsEnabled(boolean enabled)
          Enables or disables exceptions.
static void setLogLevel(LogLevel logLevel)
          Set the specified log level for the JCuda runtime library.
 
Methods inherited from class java.lang.Object
equals, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait
 

Field Detail

CUDART_VERSION

public static final int CUDART_VERSION
CUDA runtime version

See Also:
Constant Field Values

cudaHostAllocDefault

public static final int cudaHostAllocDefault
Default page-locked allocation flag

See Also:
Constant Field Values

cudaHostAllocPortable

public static final int cudaHostAllocPortable
Pinned memory accessible by all CUDA contexts

See Also:
Constant Field Values

cudaHostAllocMapped

public static final int cudaHostAllocMapped
Map allocation into device space

See Also:
Constant Field Values

cudaHostAllocWriteCombined

public static final int cudaHostAllocWriteCombined
Write-combined memory

See Also:
Constant Field Values

cudaEventDefault

public static final int cudaEventDefault
Default event flag

See Also:
Constant Field Values

cudaEventBlockingSync

public static final int cudaEventBlockingSync
Event uses blocking synchronization

See Also:
Constant Field Values

cudaDeviceScheduleAuto

public static final int cudaDeviceScheduleAuto
Device flag - Automatic scheduling

See Also:
Constant Field Values

cudaDeviceScheduleSpin

public static final int cudaDeviceScheduleSpin
Device flag - Spin default scheduling

See Also:
Constant Field Values

cudaDeviceScheduleYield

public static final int cudaDeviceScheduleYield
Device flag - Yield default scheduling

See Also:
Constant Field Values

cudaDeviceBlockingSync

public static final int cudaDeviceBlockingSync
Device flag - Use blocking synchronization

See Also:
Constant Field Values

cudaDeviceMapHost

public static final int cudaDeviceMapHost
Device flag - Support mapped pinned allocations

See Also:
Constant Field Values

cudaDeviceLmemResizeToMax

public static final int cudaDeviceLmemResizeToMax
Device flag - Keep local memory allocation after launch

See Also:
Constant Field Values

cudaDeviceMask

public static final int cudaDeviceMask
Device flags mask

See Also:
Constant Field Values

cudaArraySurfaceLoadStore

public static final int cudaArraySurfaceLoadStore
Must be set in cudaMallocArray in order to bind surfaces to the CUDA array

See Also:
Constant Field Values
Method Detail

setEmulation

public static void setEmulation(boolean emulation)
Deprecated. The emulation mode has been deprecated in CUDA 3.0. This function no longer has any effect, and will be removed in the next release.

Set the flag which indicates whether a call to any function should initialize the JCuda runtime API in emulation mode.


setLogLevel

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

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

Parameters:
logLevel - The log level to use.

setExceptionsEnabled

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

Parameters:
enabled - Whether exceptions are enabled

initialize

public static void initialize()
Initializes the native library. Note that this method does not have to be called explicitly by the user of the library: The library will automatically be initialized with the first function call.


cudaGetDeviceCount

public static int cudaGetDeviceCount(int[] count)
Returns the number of compute-capable devices.
cudaError_t cudaGetDeviceCount ( int *  count  ) 

Returns in *count the number of devices with compute capability greater or equal to 1.0 that are available for execution. If there is no such device, cudaGetDeviceCount() returns 1 and device 0 only supports device emulation mode. Since this device will be able to emulate all hardware features, this device will report major and minor compute capability versions of 9999.

Returns:
cudaSuccess
See Also:
cudaGetDevice(int[]), cudaSetDevice(int), cudaGetDeviceProperties(jcuda.runtime.cudaDeviceProp, int), cudaChooseDevice(int[], jcuda.runtime.cudaDeviceProp)

cudaSetDevice

public static int cudaSetDevice(int device)
Set device to be used for GPU executions.
cudaError_t cudaSetDevice ( int  device  ) 

Records device as the device on which the active host thread executes the device code. If the host thread has already initialized the CUDA runtime by calling non-device management runtime functions or if there exists a CUDA driver context active on the host thread, then this call returns cudaErrorSetOnActiveProcess.

Returns:
cudaSuccess, cudaErrorInvalidDevice, cudaErrorSetOnActiveProcess
See Also:
cudaGetDeviceCount(int[]), cudaGetDevice(int[]), cudaGetDeviceProperties(jcuda.runtime.cudaDeviceProp, int), cudaChooseDevice(int[], jcuda.runtime.cudaDeviceProp)

cudaSetDeviceFlags

public static int cudaSetDeviceFlags(int flags)
Sets flags to be used for device executions.
cudaError_t cudaSetDeviceFlags ( int  flags  ) 

Records flags as the flags to use when the active host thread executes device code. If the host thread has already initialized the CUDA runtime by calling non-device management runtime functions or if there exists a CUDA driver context active on the host thread, then this call returns cudaErrorSetOnActiveProcess.

The two LSBs of the flags parameter can be used to control how the CPU thread interacts with the OS scheduler when waiting for results from the device.

  • cudaDeviceScheduleAuto: The default value if the 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 device, otherwise CUDA will not yield while waiting for results and actively spin on the processor.
  • cudaDeviceScheduleSpin: Instruct CUDA to actively spin when waiting for results from the device. This can decrease latency when waiting for the device, but may lower the performance of CPU threads if they are performing work in parallel with the CUDA thread.
  • cudaDeviceScheduleYield: Instruct CUDA to yield its thread when waiting for results from the device. This can increase latency when waiting for the device, but can increase the performance of CPU threads performing work in parallel with the device.
  • cudaDeviceBlockingSync: Instruct CUDA to block the CPU thread on a synchronization primitive when waiting for the device to finish work.
  • cudaDeviceMapHost: This flag must be set in order to allocate pinned host memory that is accessible to the device. If this flag is not set, cudaHostGetDevicePointer() will always return a failure code.
  • cudaDeviceLmemResizeToMax: Instruct CUDA to not reduce local memory after resizing local memory for a kernel. This can prevent thrashing by local memory allocations when launching many kernels with high local memory usage at the cost of potentially increased memory usage.

Returns:
cudaSuccess, cudaErrorInvalidDevice, cudaErrorSetOnActiveProcess
See Also:
cudaGetDeviceCount(int[]), cudaGetDevice(int[]), cudaGetDeviceProperties(jcuda.runtime.cudaDeviceProp, int), cudaSetDevice(int), cudaSetValidDevices(int[], int), cudaChooseDevice(int[], jcuda.runtime.cudaDeviceProp)

cudaSetValidDevices

public static int cudaSetValidDevices(int[] device_arr,
                                      int len)
Set a list of devices that can be used for CUDA.
cudaError_t cudaSetValidDevices ( int *  device_arr,
int  len  
)

Sets a list of devices for CUDA execution in priority order using device_arr. The parameter len specifies the number of elements in the list. CUDA will try devices from the list sequentially until it finds one that works. If this function is not called, or if it is called with a len of 0, then CUDA will go back to its default behavior of trying devices sequentially from a default list containing all of the available CUDA devices in the system. If a specified device ID in the list does not exist, this function will return cudaErrorInvalidDevice. If len is not 0 and device_arr is NULL or if len is greater than the number of devices in the system, then cudaErrorInvalidValue is returned.

Returns:
cudaSuccess, cudaErrorInvalidValue, cudaErrorInvalidDevice
See Also:
cudaGetDeviceCount(int[]), cudaSetDevice(int), cudaGetDeviceProperties(jcuda.runtime.cudaDeviceProp, int), cudaSetDeviceFlags(int), cudaChooseDevice(int[], jcuda.runtime.cudaDeviceProp)

cudaGetDevice

public static int cudaGetDevice(int[] device)
Returns which device is currently being used.
cudaError_t cudaGetDevice ( int *  device  ) 

Returns in *device the device on which the active host thread executes the device code.

Returns:
cudaSuccess
See Also:
cudaGetDeviceCount(int[]), cudaSetDevice(int), cudaGetDeviceProperties(jcuda.runtime.cudaDeviceProp, int), cudaChooseDevice(int[], jcuda.runtime.cudaDeviceProp)

cudaGetDeviceProperties

public static int cudaGetDeviceProperties(cudaDeviceProp prop,
                                          int device)
Returns information about the compute-device.
cudaError_t cudaGetDeviceProperties ( struct cudaDeviceProp *  prop,
int  device  
)

Returns in *prop the properties of device dev. The cudaDeviceProp structure is defined as:

    struct cudaDeviceProp {
         char name[256];
         size_t totalGlobalMem;
         size_t sharedMemPerBlock;
         int regsPerBlock;
         int warpSize;
         size_t memPitch;
         int maxThreadsPerBlock;
         int maxThreadsDim[3];
         int maxGridSize[3];
         size_t totalConstMem;
         int major;
         int minor;
         int clockRate;
         size_t textureAlignment;
         int deviceOverlap;
         int multiProcessorCount;
         int kernelExecTimeoutEnabled;
         int integrated;
         int canMapHostMemory;
         int computeMode;
         int concurrentKernels;
         int ECCEnabled;
         int pciBusID;
         int pciDeviceID;
     }
 
where:
  • name is an ASCII string identifying the device;
  • totalGlobalMem is the total amount of global memory available on the device in bytes;
  • sharedMemPerBlock is the 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;
  • regsPerBlock is the maximum number of 32-bit registers available to a thread block; this number is shared by all thread blocks simultaneously resident on a multiprocessor;
  • warpSize is the warp size in threads;
  • memPitch is the maximum pitch in bytes allowed by the memory copy functions that involve memory regions allocated through cudaMallocPitch();
  • maxThreadsPerBlock is the maximum number of threads per block;
  • maxThreadsDim[3] contains the maximum size of each dimension of a block;
  • maxGridSize[3] contains the maximum size of each dimension of a grid;
  • clockRate is the clock frequency in kilohertz;
  • totalConstMem is the total amount of constant memory available on the device in bytes;
  • major, minor are the major and minor revision numbers defining the device's compute capability;
  • textureAlignment is the alignment requirement; texture base addresses that are aligned to textureAlignment bytes do not need an offset applied to texture fetches;
  • deviceOverlap is 1 if the device can concurrently copy memory between host and device while executing a kernel, or 0 if not;
  • multiProcessorCount is the number of multiprocessors on the device;
  • kernelExecTimeoutEnabled is 1 if there is a run time limit for kernels executed on the device, or 0 if not.
  • integrated is 1 if the device is an integrated (motherboard) GPU and 0 if it is a discrete (card) component
  • canMapHostMemory is 1 if the device can map host memory into the CUDA address space for use with cudaHostAlloc()/cudaHostGetDevicePointer(), or 0 if not;
  • computeMode is the compute mode that the device is currently in. Available modes are as follows:
    • cudaComputeModeDefault: Default mode - Device is not restricted and multiple threads can use cudaSetDevice() with this device.
    • cudaComputeModeExclusive: Compute-exclusive mode - Only one thread will be able to use cudaSetDevice() with this device.
    • cudaComputeModeProhibited: Compute-prohibited mode - No threads can use cudaSetDevice() with this device. Any errors from calling cudaSetDevice() with an exclusive (and occupied) or prohibited device will only show up after a non-device management runtime function is called. At that time, cudaErrorNoDevice will be returned.
  • concurrentKernels is 1 if the device supports executing multiple kernels within the same context simultaneously, or 0 if not. It is not guaranteed that multiple kernels will be resident on the device concurrently so this feature should not be relied upon for correctness;
  • ECCEnabled is 1 if the device has ECC support turned on, or 0 if not.
  • pciBusID is the PCI bus identifier of the device.
  • pciDeviceID is the PCI device (sometimes called slot) identifier of the device.

Returns:
cudaSuccess, cudaErrorInvalidDevice
See Also:
cudaGetDeviceCount(int[]), cudaGetDevice(int[]), cudaSetDevice(int), cudaChooseDevice(int[], jcuda.runtime.cudaDeviceProp)

cudaChooseDevice

public static int cudaChooseDevice(int[] device,
                                   cudaDeviceProp prop)
Select compute-device which best matches criteria.
cudaError_t cudaChooseDevice ( int *  device,
const struct cudaDeviceProp *  prop  
)

Returns in *device the device which has properties that best match *prop.

Returns:
cudaSuccess, cudaErrorInvalidValue
See Also:
cudaGetDeviceCount(int[]), cudaGetDevice(int[]), cudaSetDevice(int), cudaGetDeviceProperties(jcuda.runtime.cudaDeviceProp, int)

cudaMalloc3D

public static int cudaMalloc3D(cudaPitchedPtr pitchDevPtr,
                               cudaExtent extent)
Allocates logical 1D, 2D, or 3D memory objects on the device.
cudaError_t cudaMalloc3D ( struct cudaPitchedPtr *  pitchedDevPtr,
struct cudaExtent  extent  
)

Allocates at least width * height * depth bytes of linear memory on the device and returns a cudaPitchedPtr in which ptr is a pointer to the allocated memory. The function may pad the allocation to ensure hardware alignment requirements are met. The pitch returned in the pitch field of pitchedDevPtr is the width in bytes of the allocation.

The returned cudaPitchedPtr contains additional fields xsize and ysize, the logical width and height of the allocation, which are equivalent to the width and height extent parameters provided by the programmer during allocation.

For allocations of 2D and 3D objects, it is highly recommended that programmers perform allocations using cudaMalloc3D() or cudaMallocPitch(). Due to alignment restrictions in the hardware, this is especially true if the application will be performing memory copies involving 2D or 3D objects (whether linear memory or CUDA arrays).

Returns:
cudaSuccess, cudaErrorMemoryAllocation
See Also:
cudaMallocPitch(jcuda.Pointer, long[], long, long), cudaFree(jcuda.Pointer), cudaMemcpy3D(jcuda.runtime.cudaMemcpy3DParms), cudaMemset3D(jcuda.runtime.cudaPitchedPtr, int, jcuda.runtime.cudaExtent), cudaMalloc3DArray(jcuda.runtime.cudaArray, jcuda.runtime.cudaChannelFormatDesc, jcuda.runtime.cudaExtent), cudaMallocArray(jcuda.runtime.cudaArray, jcuda.runtime.cudaChannelFormatDesc, long, long), cudaFreeArray(jcuda.runtime.cudaArray), cudaMallocHost(jcuda.Pointer, long), cudaFreeHost(jcuda.Pointer), cudaHostAlloc(jcuda.Pointer, long, int)

cudaMalloc3DArray

public static int cudaMalloc3DArray(cudaArray arrayPtr,
                                    cudaChannelFormatDesc desc,
                                    cudaExtent extent)
Calls cudaMalloc3DArray wit the default value '0' as the last parameter

See Also:
cudaMalloc3DArray(cudaArray, cudaChannelFormatDesc, cudaExtent, int)

cudaMalloc3DArray

public static int cudaMalloc3DArray(cudaArray arrayPtr,
                                    cudaChannelFormatDesc desc,
                                    cudaExtent extent,
                                    int flags)
Allocate an array on the device.
cudaError_t cudaMalloc3DArray ( struct cudaArray **  arrayPtr,
const struct cudaChannelFormatDesc *  desc,
struct cudaExtent  extent,
unsigned int  flags  
)

Allocates a CUDA array according to the cudaChannelFormatDesc structure desc and returns a handle to the new CUDA array in *arrayPtr.

The cudaChannelFormatDesc is defined as:

    struct
 cudaChannelFormatDesc {
         int x, y, z, w;
         enum cudaChannelFormatKind f;
     };
 
where cudaChannelFormatKind is one of cudaChannelFormatKindSigned, cudaChannelFormatKindUnsigned, or cudaChannelFormatKindFloat.

cudaMalloc3DArray() is able to allocate 1D, 2D, or 3D arrays.

  • A 1D array is allocated if the height and depth extent are both zero. For 1D arrays valid extent ranges are {(1, 8192), 0, 0}.
  • A 2D array is allocated if only the depth extent is zero. For 2D arrays valid extent ranges are {(1, 65536), (1, 32768), 0}.
  • A 3D array is allocated if all three extents are non-zero. For 3D arrays valid extent ranges are {(1, 2048), (1, 2048), (1, 2048)}.

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

Returns:
cudaSuccess, cudaErrorMemoryAllocation
See Also:
cudaMalloc3D(jcuda.runtime.cudaPitchedPtr, jcuda.runtime.cudaExtent), cudaMalloc(jcuda.Pointer, long), cudaMallocPitch(jcuda.Pointer, long[], long, long), cudaFree(jcuda.Pointer), cudaFreeArray(jcuda.runtime.cudaArray), cudaMallocHost(jcuda.Pointer, long), cudaFreeHost(jcuda.Pointer), cudaHostAlloc(jcuda.Pointer, long, int)

cudaMemset3D

public static int cudaMemset3D(cudaPitchedPtr pitchDevPtr,
                               int value,
                               cudaExtent extent)
Initializes or sets device memory to a value.
cudaError_t cudaMemset3D ( struct cudaPitchedPtr  pitchedDevPtr,
int  value,
struct cudaExtent  extent  
)

Initializes each element of a 3D array to the specified value value. The object to initialize is defined by pitchedDevPtr. The pitch field of pitchedDevPtr is the width in memory in bytes of the 3D array pointed to by pitchedDevPtr, including any padding added to the end of each row. The xsize field specifies the logical width of each row in bytes, while the ysize field specifies the height of each 2D slice in rows.

The extents of the initialized region are specified as a width in bytes, a height in rows, and a depth in slices.

Extents with width greater than or equal to the xsize of pitchedDevPtr may perform significantly faster than extents narrower than the xsize. Secondarily, extents with height equal to the ysize of pitchedDevPtr will perform faster than when the height is shorter than the ysize.

This function performs fastest when the pitchedDevPtr has been allocated by cudaMalloc3D().

Returns:
cudaSuccess, cudaErrorInvalidValue, cudaErrorInvalidDevicePointer
See Also:
cudaMemset(jcuda.Pointer, int, long), cudaMemset2D(jcuda.Pointer, long, int, long, long), cudaMalloc3D(jcuda.runtime.cudaPitchedPtr, jcuda.runtime.cudaExtent)

cudaMemcpy3D

public static int cudaMemcpy3D(cudaMemcpy3DParms p)
Copies data between 3D objects.
cudaError_t cudaMemcpy3D ( const struct cudaMemcpy3DParms *  p  ) 

struct cudaExtent {
   size_t width;
   size_t height;
   size_t depth;
 };
 struct cudaExtent make_cudaExtent(size_t w, size_t h,
 size_t d);

 struct cudaPos {
   size_t x;
   size_t y;
   size_t z;
 };
 struct cudaPos make_cudaPos(size_t x, size_t y, size_t
 z);

 struct cudaMemcpy3DParms {
   struct cudaArray     *srcArray;
   struct cudaPos        srcPos;
   struct cudaPitchedPtr srcPtr;
   struct cudaArray     *dstArray;
   struct cudaPos        dstPos;
   struct cudaPitchedPtr dstPtr;
   struct cudaExtent     extent;
   enum cudaMemcpyKind   kind;
 };
 

cudaMemcpy3D() copies data betwen two 3D objects. The source and destination objects may be in either host memory, device memory, or a CUDA array. The source, destination, extent, and kind of copy performed is specified by the cudaMemcpy3DParms struct which should be initialized to zero before use:

cudaMemcpy3DParms myParms = {0};
 

The struct passed to cudaMemcpy3D() must specify one of srcArray or srcPtr and one of dstArray or dstPtr. Passing more than one non-zero source or destination will cause cudaMemcpy3D() to return an error.

The srcPos and dstPos fields are optional offsets into the source and destination objects and are defined in units of each object's elements. The element for a host or device pointer is assumed to be unsigned char. For CUDA arrays, positions must be in the range [0, 2048) for any dimension.

The extent field defines the dimensions of the transferred area in elements. If a CUDA array is participating in the copy, the extent is defined in terms of that array's elements. If no CUDA array is participating in the copy then the extents are defined in elements of unsigned char.

The kind field defines the direction of the copy. It must be one of cudaMemcpyHostToHost, cudaMemcpyHostToDevice, cudaMemcpyDeviceToHost, or cudaMemcpyDeviceToDevice.

If the source and destination are both arrays, cudaMemcpy3D() will return an error if they do not have the same element size.

The source and destination object may not overlap. If overlapping source and destination objects are specified, undefined behavior will result.

cudaMemcpy3D() returns an error if the pitch of srcPtr or dstPtr is greater than the maximum allowed. The pitch of a cudaPitchedPtr allocated with cudaMalloc3D() will always be valid.

Returns:
cudaSuccess, cudaErrorInvalidValue, cudaErrorInvalidDevicePointer, cudaErrorInvalidPitchValue, cudaErrorInvalidMemcpyDirection
See Also:
cudaMalloc3D(jcuda.runtime.cudaPitchedPtr, jcuda.runtime.cudaExtent), cudaMalloc3DArray(jcuda.runtime.cudaArray, jcuda.runtime.cudaChannelFormatDesc, jcuda.runtime.cudaExtent), cudaMemset3D(jcuda.runtime.cudaPitchedPtr, int, jcuda.runtime.cudaExtent), cudaMemcpy3DAsync(jcuda.runtime.cudaMemcpy3DParms, jcuda.runtime.cudaStream_t), cudaMemcpy(jcuda.Pointer, jcuda.Pointer, long, int), cudaMemcpy2D(jcuda.Pointer, long, jcuda.Pointer, long, long, long, int), cudaMemcpyToArray(jcuda.runtime.cudaArray, long, long, jcuda.Pointer, long, int), cudaMemcpy2DToArray(jcuda.runtime.cudaArray, long, long, jcuda.Pointer, long, long, long, int), cudaMemcpyFromArray(jcuda.Pointer, jcuda.runtime.cudaArray, long, long, long, int), cudaMemcpy2DFromArray(jcuda.Pointer, long, jcuda.runtime.cudaArray, long, long, long, long, int), cudaMemcpyArrayToArray(jcuda.runtime.cudaArray, long, long, jcuda.runtime.cudaArray, long, long, long, int), cudaMemcpy2DArrayToArray(jcuda.runtime.cudaArray, long, long, jcuda.runtime.cudaArray, long, long, long, long, int), cudaMemcpyToSymbol(java.lang.String, jcuda.Pointer, long, long, int), cudaMemcpyFromSymbol(jcuda.Pointer, java.lang.String, long, long, int), cudaMemcpyAsync(jcuda.Pointer, jcuda.Pointer, long, int, jcuda.runtime.cudaStream_t), cudaMemcpy2DAsync(jcuda.Pointer, long, jcuda.Pointer, long, long, long, int, jcuda.runtime.cudaStream_t), cudaMemcpyToArrayAsync(jcuda.runtime.cudaArray, long, long, jcuda.Pointer, long, int, jcuda.runtime.cudaStream_t), cudaMemcpy2DToArrayAsync(jcuda.runtime.cudaArray, long, long, jcuda.Pointer, long, long, long, int, jcuda.runtime.cudaStream_t), cudaMemcpyFromArrayAsync(jcuda.Pointer, jcuda.runtime.cudaArray, long, long, long, int, jcuda.runtime.cudaStream_t), cudaMemcpy2DFromArrayAsync(jcuda.Pointer, long, jcuda.runtime.cudaArray, long, long, long, long, int, jcuda.runtime.cudaStream_t), cudaMemcpyToSymbolAsync(java.lang.String, jcuda.Pointer, long, long, int, jcuda.runtime.cudaStream_t), cudaMemcpyFromSymbolAsync(jcuda.Pointer, java.lang.String, long, long, int, jcuda.runtime.cudaStream_t)

cudaMemcpy3DAsync

public static int cudaMemcpy3DAsync(cudaMemcpy3DParms p,
                                    cudaStream_t stream)
Copies data between 3D objects.
cudaError_t cudaMemcpy3DAsync ( const struct cudaMemcpy3DParms *  p,
cudaStream_t  stream  
)

struct cudaExtent {
   size_t width;
   size_t height;
   size_t depth;
 };
 struct cudaExtent make_cudaExtent(size_t w, size_t h,
 size_t d);

 struct cudaPos {
   size_t x;
   size_t y;
   size_t z;
 };
 struct cudaPos make_cudaPos(size_t x, size_t y, size_t
 z);

 struct cudaMemcpy3DParms {
   struct cudaArray     *srcArray;
   struct cudaPos        srcPos;
   struct cudaPitchedPtr srcPtr;
   struct cudaArray     *dstArray;
   struct cudaPos        dstPos;
   struct cudaPitchedPtr dstPtr;
   struct cudaExtent     extent;
   enum cudaMemcpyKind   kind;
 };
 

cudaMemcpy3DAsync() copies data betwen two 3D objects. The source and destination objects may be in either host memory, device memory, or a CUDA array. The source, destination, extent, and kind of copy performed is specified by the cudaMemcpy3DParms struct which should be initialized to zero before use:

cudaMemcpy3DParms myParms = {0};
 

The struct passed to cudaMemcpy3DAsync() must specify one of srcArray or srcPtr and one of dstArray or dstPtr. Passing more than one non-zero source or destination will cause cudaMemcpy3DAsync() to return an error.

The srcPos and dstPos fields are optional offsets into the source and destination objects and are defined in units of each object's elements. The element for a host or device pointer is assumed to be unsigned char. For CUDA arrays, positions must be in the range [0, 2048) for any dimension.

The extent field defines the dimensions of the transferred area in elements. If a CUDA array is participating in the copy, the extent is defined in terms of that array's elements. If no CUDA array is participating in the copy then the extents are defined in elements of unsigned char.

The kind field defines the direction of the copy. It must be one of cudaMemcpyHostToHost, cudaMemcpyHostToDevice, cudaMemcpyDeviceToHost, or cudaMemcpyDeviceToDevice.

If the source and destination are both arrays, cudaMemcpy3DAsync() will return an error if they do not have the same element size.

The source and destination object may not overlap. If overlapping source and destination objects are specified, undefined behavior will result.

cudaMemcpy3DAsync() returns an error if the pitch of srcPtr or dstPtr is greater than the maximum allowed. The pitch of a cudaPitchedPtr allocated with cudaMalloc3D() will always be valid.

cudaMemcpy3DAsync() is asynchronous with respect to the host, so the call may return before the copy is complete. It only works on page-locked host memory and returns an error if a pointer to pageable memory is passed as input. The copy can optionally be associated to a stream by passing a non-zero stream argument. If kind is cudaMemcpyHostToDevice or cudaMemcpyDeviceToHost and stream is non-zero, the copy may overlap with operations in other streams.

Returns:
cudaSuccess, cudaErrorInvalidValue, cudaErrorInvalidDevicePointer, cudaErrorInvalidPitchValue, cudaErrorInvalidMemcpyDirection
See Also:
cudaMalloc3D(jcuda.runtime.cudaPitchedPtr, jcuda.runtime.cudaExtent), cudaMalloc3DArray(jcuda.runtime.cudaArray, jcuda.runtime.cudaChannelFormatDesc, jcuda.runtime.cudaExtent), cudaMemset3D(jcuda.runtime.cudaPitchedPtr, int, jcuda.runtime.cudaExtent), cudaMemcpy3D(jcuda.runtime.cudaMemcpy3DParms), cudaMemcpy(jcuda.Pointer, jcuda.Pointer, long, int), cudaMemcpy2D(jcuda.Pointer, long, jcuda.Pointer, long, long, long, int), cudaMemcpyToArray(jcuda.runtime.cudaArray, long, long, jcuda.Pointer, long, int), cudaMemcpy2DToArray(jcuda.runtime.cudaArray, long, long, jcuda.Pointer, long, long, long, int), cudaMemcpyFromArray(jcuda.Pointer, jcuda.runtime.cudaArray, long, long, long, int), cudaMemcpy2DFromArray(jcuda.Pointer, long, jcuda.runtime.cudaArray, long, long, long, long, int), cudaMemcpyArrayToArray(jcuda.runtime.cudaArray, long, long, jcuda.runtime.cudaArray, long, long, long, int), cudaMemcpy2DArrayToArray(jcuda.runtime.cudaArray, long, long, jcuda.runtime.cudaArray, long, long, long, long, int), cudaMemcpyToSymbol(java.lang.String, jcuda.Pointer, long, long, int), cudaMemcpyFromSymbol(jcuda.Pointer, java.lang.String, long, long, int), cudaMemcpyAsync(jcuda.Pointer, jcuda.Pointer, long, int, jcuda.runtime.cudaStream_t), cudaMemcpy2DAsync(jcuda.Pointer, long, jcuda.Pointer, long, long, long, int, jcuda.runtime.cudaStream_t), cudaMemcpyToArrayAsync(jcuda.runtime.cudaArray, long, long, jcuda.Pointer, long, int, jcuda.runtime.cudaStream_t), cudaMemcpy2DToArrayAsync(jcuda.runtime.cudaArray, long, long, jcuda.Pointer, long, long, long, int, jcuda.runtime.cudaStream_t), cudaMemcpyFromArrayAsync(jcuda.Pointer, jcuda.runtime.cudaArray, long, long, long, int, jcuda.runtime.cudaStream_t), cudaMemcpy2DFromArrayAsync(jcuda.Pointer, long, jcuda.runtime.cudaArray, long, long, long, long, int, jcuda.runtime.cudaStream_t), cudaMemcpyToSymbolAsync(java.lang.String, jcuda.Pointer, long, long, int, jcuda.runtime.cudaStream_t), cudaMemcpyFromSymbolAsync(jcuda.Pointer, java.lang.String, long, long, int, jcuda.runtime.cudaStream_t)

cudaHostAlloc

public static int cudaHostAlloc(Pointer ptr,
                                long size,
                                int flags)
Allocates page-locked memory on the host.
cudaError_t cudaHostAlloc ( void **  ptr,
size_t  size,
unsigned int  flags  
)

Allocates size bytes of host memory that is page-locked and accessible to the device. The driver tracks the virtual memory ranges allocated with this function and automatically accelerates calls to functions such as cudaMemcpy(). Since the memory can be accessed directly by the device, it can be read or written with much higher bandwidth than pageable memory obtained with functions such as malloc(). Allocating excessive amounts of pinned memory may degrade system performance, since it reduces the amount of memory available to the system for paging. As a result, this function is best used sparingly to allocate staging areas for data exchange between host and device.

The flags parameter enables different options to be specified that affect the allocation, as follows.

  • cudaHostAllocDefault: This flag's value is defined to be 0 and causes cudaHostAlloc() to emulate cudaMallocHost().
  • cudaHostAllocPortable: The memory returned by this call will be considered as pinned memory by all CUDA contexts, not just the one that performed the allocation.
  • cudaHostAllocMapped: Maps the allocation into the CUDA address space. The device pointer to the memory may be obtained by calling cudaHostGetDevicePointer().
  • cudaHostAllocWriteCombined: Allocates the memory as write-combined (WC). WC memory can be transferred across the PCI Express bus more quickly on some system configurations, but cannot be read efficiently by most CPUs. WC memory is a good option for buffers that will be written by the CPU and read by the device via mapped pinned memory or host->device transfers.

All of these flags are orthogonal to one another: a developer may allocate memory that is portable, mapped and/or write-combined with no restrictions.

cudaSetDeviceFlags() must have been called with the cudaDeviceMapHost flag in order for the cudaHostAllocMapped flag to have any effect.

The cudaHostAllocMapped flag may be specified on CUDA contexts for devices that do not support mapped pinned memory. The failure is deferred to cudaHostGetDevicePointer() because the memory may be mapped into other CUDA contexts via the cudaHostAllocPortable flag.

Memory allocated by this function must be freed with cudaFreeHost().

Returns:
cudaSuccess, cudaErrorMemoryAllocation
See Also:
cudaSetDeviceFlags(int), cudaMallocHost(jcuda.Pointer, long), cudaFreeHost(jcuda.Pointer)

cudaHostGetDevicePointer

public static int cudaHostGetDevicePointer(Pointer pDevice,
                                           Pointer pHost,
                                           int flags)
Passes back device pointer of mapped host memory allocated by cudaHostAlloc().
cudaError_t cudaHostGetDevicePointer ( void **  pDevice,
void *  pHost,
unsigned int  flags  
)

Passes back the device pointer corresponding to the mapped, pinned host buffer allocated by cudaHostAlloc().

cudaHostGetDevicePointer() will fail if the cudaDeviceMapHost flag was not specified before deferred context creation occurred, or if called on a device that does not support mapped, pinned memory.

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

Returns:
cudaSuccess, cudaErrorInvalidValue, cudaErrorMemoryAllocation
See Also:
cudaSetDeviceFlags(int), cudaHostAlloc(jcuda.Pointer, long, int)

cudaMalloc

public static int cudaMalloc(Pointer devPtr,
                             long size)
Allocate memory on the device.
cudaError_t cudaMalloc ( void **  devPtr,
size_t  size  
)

Allocates size bytes of linear memory on the device and returns in *devPtr a pointer to the allocated memory. The allocated memory is suitably aligned for any kind of variable. The memory is not cleared. cudaMalloc() returns cudaErrorMemoryAllocation in case of failure.

Returns:
cudaSuccess, cudaErrorMemoryAllocation
See Also:
cudaMallocPitch(jcuda.Pointer, long[], long, long), cudaFree(jcuda.Pointer), cudaMallocArray(jcuda.runtime.cudaArray, jcuda.runtime.cudaChannelFormatDesc, long, long), cudaFreeArray(jcuda.runtime.cudaArray), cudaMalloc3D(jcuda.runtime.cudaPitchedPtr, jcuda.runtime.cudaExtent), cudaMalloc3DArray(jcuda.runtime.cudaArray, jcuda.runtime.cudaChannelFormatDesc, jcuda.runtime.cudaExtent), cudaMallocHost(jcuda.Pointer, long), cudaFreeHost(jcuda.Pointer), cudaHostAlloc(jcuda.Pointer, long, int)

cudaMallocHost

public static int cudaMallocHost(Pointer ptr,
                                 long size)
Allocates page-locked memory on the host.
cudaError_t cudaMallocHost ( void **  ptr,
size_t  size  
)

Allocates size bytes of host memory that is page-locked and accessible to the device. The driver tracks the virtual memory ranges allocated with this function and automatically accelerates calls to functions such as cudaMemcpy*(). Since the memory can be accessed directly by the device, it can be read or written with much higher bandwidth than pageable memory obtained with functions such as malloc(). Allocating excessive amounts of memory with cudaMallocHost() may degrade system performance, since it reduces the amount of memory available to the system for paging. As a result, this function is best used sparingly to allocate staging areas for data exchange between host and device.

Returns:
cudaSuccess, cudaErrorMemoryAllocation
See Also:
cudaMalloc(jcuda.Pointer, long), cudaMallocPitch(jcuda.Pointer, long[], long, long), cudaMallocArray(jcuda.runtime.cudaArray, jcuda.runtime.cudaChannelFormatDesc, long, long), cudaMalloc3D(jcuda.runtime.cudaPitchedPtr, jcuda.runtime.cudaExtent), cudaMalloc3DArray(jcuda.runtime.cudaArray, jcuda.runtime.cudaChannelFormatDesc, jcuda.runtime.cudaExtent), cudaHostAlloc(jcuda.Pointer, long, int), cudaFree(jcuda.Pointer), cudaFreeArray(jcuda.runtime.cudaArray), cudaFreeHost(jcuda.Pointer), cudaHostAlloc(jcuda.Pointer, long, int)

cudaMallocPitch

public static int cudaMallocPitch(Pointer devPtr,
                                  long[] pitch,
                                  long width,
                                  long height)
Allocates pitched memory on the device.
cudaError_t cudaMallocPitch ( void **  devPtr,
size_t *  pitch,
size_t  width,
size_t  height  
)

Allocates at least widthInBytes * height bytes of linear memory on the device and returns in *devPtr a pointer to the allocated memory. The function may pad the allocation to ensure that corresponding pointers in any given row will continue to meet the alignment requirements for coalescing as the address is updated from row to row. The pitch returned in *pitch by cudaMallocPitch() 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;
 

For allocations of 2D arrays, it is recommended that programmers consider performing pitch allocations using cudaMallocPitch(). Due to pitch alignment restrictions in the hardware, this is especially true if the application will be performing 2D memory copies between different regions of device memory (whether linear memory or CUDA arrays).

Returns:
cudaSuccess, cudaErrorMemoryAllocation
See Also:
cudaMalloc(jcuda.Pointer, long), cudaFree(jcuda.Pointer), cudaMallocArray(jcuda.runtime.cudaArray, jcuda.runtime.cudaChannelFormatDesc, long, long), cudaFreeArray(jcuda.runtime.cudaArray), cudaMallocHost(jcuda.Pointer, long), cudaFreeHost(jcuda.Pointer), cudaMalloc3D(jcuda.runtime.cudaPitchedPtr, jcuda.runtime.cudaExtent), cudaMalloc3DArray(jcuda.runtime.cudaArray, jcuda.runtime.cudaChannelFormatDesc, jcuda.runtime.cudaExtent), cudaHostAlloc(jcuda.Pointer, long, int)

cudaMallocArray

public static int cudaMallocArray(cudaArray array,
                                  cudaChannelFormatDesc desc,
                                  long width,
                                  long height)
Calls cudaMallocArray wit the default value '0' as the last parameter

See Also:
cudaMallocArray(cudaArray, cudaChannelFormatDesc, long, long, int)

cudaMallocArray

public static int cudaMallocArray(cudaArray array,
                                  cudaChannelFormatDesc desc,
                                  long width,
                                  long height,
                                  int flags)
Allocate an array on the device.
cudaError_t cudaMallocArray ( struct cudaArray **  arrayPtr,
const struct cudaChannelFormatDesc *  desc,
size_t  width,
size_t  height,
unsigned int  flags  
)

Allocates a CUDA array according to the cudaChannelFormatDesc structure desc and returns a handle to the new CUDA array in *array.

The cudaChannelFormatDesc is defined as:

    struct
 cudaChannelFormatDesc {
         int x, y, z, w;
     enum cudaChannelFormatKind f;
     };
 
where cudaChannelFormatKind is one of cudaChannelFormatKindSigned, cudaChannelFormatKindUnsigned, or cudaChannelFormatKindFloat.

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

Returns:
cudaSuccess, cudaErrorMemoryAllocation
See Also:
cudaMalloc(jcuda.Pointer, long), cudaMallocPitch(jcuda.Pointer, long[], long, long), cudaFree(jcuda.Pointer), cudaFreeArray(jcuda.runtime.cudaArray), cudaMallocHost(jcuda.Pointer, long), cudaFreeHost(jcuda.Pointer), cudaMalloc3D(jcuda.runtime.cudaPitchedPtr, jcuda.runtime.cudaExtent), cudaMalloc3DArray(jcuda.runtime.cudaArray, jcuda.runtime.cudaChannelFormatDesc, jcuda.runtime.cudaExtent), cudaHostAlloc(jcuda.Pointer, long, int)

cudaFree

public static int cudaFree(Pointer devPtr)
Frees memory on the device.
cudaError_t cudaFree ( void *  devPtr  ) 

Frees the memory space pointed to by devPtr, which must have been returned by a previous call to cudaMalloc() or cudaMallocPitch(). Otherwise, or if cudaFree(devPtr) has already been called before, an error is returned. If devPtr is 0, no operation is performed. cudaFree() returns cudaErrorInvalidDevicePointer in case of failure.

Returns:
cudaSuccess, cudaErrorInvalidDevicePointer, cudaErrorInitializationError
See Also:
cudaMalloc(jcuda.Pointer, long), cudaMallocPitch(jcuda.Pointer, long[], long, long), cudaMallocArray(jcuda.runtime.cudaArray, jcuda.runtime.cudaChannelFormatDesc, long, long), cudaFreeArray(jcuda.runtime.cudaArray), cudaMallocHost(jcuda.Pointer, long), cudaFreeHost(jcuda.Pointer), cudaMalloc3D(jcuda.runtime.cudaPitchedPtr, jcuda.runtime.cudaExtent), cudaMalloc3DArray(jcuda.runtime.cudaArray, jcuda.runtime.cudaChannelFormatDesc, jcuda.runtime.cudaExtent), cudaHostAlloc(jcuda.Pointer, long, int)

cudaFreeHost

public static int cudaFreeHost(Pointer ptr)
Frees page-locked memory.
cudaError_t cudaFreeHost ( void *  ptr  ) 

Frees the memory space pointed to by hostPtr, which must have been returned by a previous call to cudaMallocHost() or cudaHostAlloc().

Returns:
cudaSuccess, cudaErrorInitializationError
See Also:
cudaMalloc(jcuda.Pointer, long), cudaMallocPitch(jcuda.Pointer, long[], long, long), cudaFree(jcuda.Pointer), cudaMallocArray(jcuda.runtime.cudaArray, jcuda.runtime.cudaChannelFormatDesc, long, long), cudaFreeArray(jcuda.runtime.cudaArray), cudaMallocHost(jcuda.Pointer, long), cudaMalloc3D(jcuda.runtime.cudaPitchedPtr, jcuda.runtime.cudaExtent), cudaMalloc3DArray(jcuda.runtime.cudaArray, jcuda.runtime.cudaChannelFormatDesc, jcuda.runtime.cudaExtent), cudaHostAlloc(jcuda.Pointer, long, int)

cudaFreeArray

public static int cudaFreeArray(cudaArray array)
Frees an array on the device.
cudaError_t cudaFreeArray ( struct cudaArray *  array  ) 

Frees the CUDA array array, which must have been * returned by a previous call to cudaMallocArray(). If cudaFreeArray(array) has already been called before, cudaErrorInvalidValue is returned. If devPtr is 0, no operation is performed.

Returns:
cudaSuccess, cudaErrorInvalidValue, cudaErrorInitializationError
See Also:
cudaMalloc(jcuda.Pointer, long), cudaMallocPitch(jcuda.Pointer, long[], long, long), cudaFree(jcuda.Pointer), cudaMallocArray(jcuda.runtime.cudaArray, jcuda.runtime.cudaChannelFormatDesc, long, long), cudaMallocHost(jcuda.Pointer, long), cudaFreeHost(jcuda.Pointer), cudaHostAlloc(jcuda.Pointer, long, int)

cudaMemcpy

public static int cudaMemcpy(Pointer dst,
                             Pointer src,
                             long count,
                             int cudaMemcpyKind_kind)
Copies data between host and device.
cudaError_t cudaMemcpy ( void *  dst,
const void *  src,
size_t  count,
enum cudaMemcpyKind  kind  
)

Copies count bytes from the memory area pointed to by src to the memory area pointed to by dst, where kind is one of cudaMemcpyHostToHost, cudaMemcpyHostToDevice, cudaMemcpyDeviceToHost, or cudaMemcpyDeviceToDevice, and specifies the direction of the copy. The memory areas may not overlap. Calling cudaMemcpy() with dst and src pointers that do not match the direction of the copy results in an undefined behavior.

Returns:
cudaSuccess, cudaErrorInvalidValue, cudaErrorInvalidDevicePointer, cudaErrorInvalidMemcpyDirection
See Also:
cudaMemcpy2D(jcuda.Pointer, long, jcuda.Pointer, long, long, long, int), cudaMemcpyToArray(jcuda.runtime.cudaArray, long, long, jcuda.Pointer, long, int), cudaMemcpy2DToArray(jcuda.runtime.cudaArray, long, long, jcuda.Pointer, long, long, long, int), cudaMemcpyFromArray(jcuda.Pointer, jcuda.runtime.cudaArray, long, long, long, int), cudaMemcpy2DFromArray(jcuda.Pointer, long, jcuda.runtime.cudaArray, long, long, long, long, int), cudaMemcpyArrayToArray(jcuda.runtime.cudaArray, long, long, jcuda.runtime.cudaArray, long, long, long, int), cudaMemcpy2DArrayToArray(jcuda.runtime.cudaArray, long, long, jcuda.runtime.cudaArray, long, long, long, long, int), cudaMemcpyToSymbol(java.lang.String, jcuda.Pointer, long, long, int), cudaMemcpyFromSymbol(jcuda.Pointer, java.lang.String, long, long, int), cudaMemcpyAsync(jcuda.Pointer, jcuda.Pointer, long, int, jcuda.runtime.cudaStream_t), cudaMemcpy2DAsync(jcuda.Pointer, long, jcuda.Pointer, long, long, long, int, jcuda.runtime.cudaStream_t), cudaMemcpyToArrayAsync(jcuda.runtime.cudaArray, long, long, jcuda.Pointer, long, int, jcuda.runtime.cudaStream_t), cudaMemcpy2DToArrayAsync(jcuda.runtime.cudaArray, long, long, jcuda.Pointer, long, long, long, int, jcuda.runtime.cudaStream_t), cudaMemcpyFromArrayAsync(jcuda.Pointer, jcuda.runtime.cudaArray, long, long, long, int, jcuda.runtime.cudaStream_t), cudaMemcpy2DFromArrayAsync(jcuda.Pointer, long, jcuda.runtime.cudaArray, long, long, long, long, int, jcuda.runtime.cudaStream_t), cudaMemcpyToSymbolAsync(java.lang.String, jcuda.Pointer, long, long, int, jcuda.runtime.cudaStream_t), cudaMemcpyFromSymbolAsync(jcuda.Pointer, java.lang.String, long, long, int, jcuda.runtime.cudaStream_t)

cudaMemcpyToArray

public static int cudaMemcpyToArray(cudaArray dst,
                                    long wOffset,
                                    long hOffset,
                                    Pointer src,
                                    long count,
                                    int cudaMemcpyKind_kind)
Copies data between host and device.
cudaError_t cudaMemcpyToArray ( struct cudaArray *  dst,
size_t  wOffset,
size_t  hOffset,
const void *  src,
size_t  count,
enum cudaMemcpyKind  kind  
)

Copies count bytes from the memory area pointed to by src to the CUDA array dst starting at the upper left corner (wOffset, hOffset), where kind is one of cudaMemcpyHostToHost, cudaMemcpyHostToDevice, cudaMemcpyDeviceToHost, or cudaMemcpyDeviceToDevice, and specifies the direction of the copy.

Returns:
cudaSuccess, cudaErrorInvalidValue, cudaErrorInvalidDevicePointer, cudaErrorInvalidMemcpyDirection
See Also:
cudaMemcpy(jcuda.Pointer, jcuda.Pointer, long, int), cudaMemcpy2D(jcuda.Pointer, long, jcuda.Pointer, long, long, long, int), cudaMemcpy2DToArray(jcuda.runtime.cudaArray, long, long, jcuda.Pointer, long, long, long, int), cudaMemcpyFromArray(jcuda.Pointer, jcuda.runtime.cudaArray, long, long, long, int), cudaMemcpy2DFromArray(jcuda.Pointer, long, jcuda.runtime.cudaArray, long, long, long, long, int), cudaMemcpyArrayToArray(jcuda.runtime.cudaArray, long, long, jcuda.runtime.cudaArray, long, long, long, int), cudaMemcpy2DArrayToArray(jcuda.runtime.cudaArray, long, long, jcuda.runtime.cudaArray, long, long, long, long, int), cudaMemcpyToSymbol(java.lang.String, jcuda.Pointer, long, long, int), cudaMemcpyFromSymbol(jcuda.Pointer, java.lang.String, long, long, int), cudaMemcpyAsync(jcuda.Pointer, jcuda.Pointer, long, int, jcuda.runtime.cudaStream_t), cudaMemcpy2DAsync(jcuda.Pointer, long, jcuda.Pointer, long, long, long, int, jcuda.runtime.cudaStream_t), cudaMemcpyToArrayAsync(jcuda.runtime.cudaArray, long, long, jcuda.Pointer, long, int, jcuda.runtime.cudaStream_t), cudaMemcpy2DToArrayAsync(jcuda.runtime.cudaArray, long, long, jcuda.Pointer, long, long, long, int, jcuda.runtime.cudaStream_t), cudaMemcpyFromArrayAsync(jcuda.Pointer, jcuda.runtime.cudaArray, long, long, long, int, jcuda.runtime.cudaStream_t), cudaMemcpy2DFromArrayAsync(jcuda.Pointer, long, jcuda.runtime.cudaArray, long, long, long, long, int, jcuda.runtime.cudaStream_t), cudaMemcpyToSymbolAsync(java.lang.String, jcuda.Pointer, long, long, int, jcuda.runtime.cudaStream_t), cudaMemcpyFromSymbolAsync(jcuda.Pointer, java.lang.String, long, long, int, jcuda.runtime.cudaStream_t)

cudaMemcpyFromArray

public static int cudaMemcpyFromArray(Pointer dst,
                                      cudaArray src,
                                      long wOffset,
                                      long hOffset,
                                      long count,
                                      int cudaMemcpyKind_kind)
Copies data between host and device.
cudaError_t cudaMemcpyFromArray ( void *  dst,
const struct cudaArray *  src,
size_t  wOffset,
size_t  hOffset,
size_t  count,
enum cudaMemcpyKind  kind  
)

Copies count bytes from the CUDA array src starting at the upper left corner (wOffset, hOffset) to the memory area pointed to by dst, where kind is one of cudaMemcpyHostToHost, cudaMemcpyHostToDevice, cudaMemcpyDeviceToHost, or cudaMemcpyDeviceToDevice, and specifies the direction of the copy.

Returns:
cudaSuccess, cudaErrorInvalidValue, cudaErrorInvalidDevicePointer, cudaErrorInvalidMemcpyDirection
See Also:
cudaMemcpy(jcuda.Pointer, jcuda.Pointer, long, int), cudaMemcpy2D(jcuda.Pointer, long, jcuda.Pointer, long, long, long, int), cudaMemcpyToArray(jcuda.runtime.cudaArray, long, long, jcuda.Pointer, long, int), cudaMemcpy2DToArray(jcuda.runtime.cudaArray, long, long, jcuda.Pointer, long, long, long, int), cudaMemcpy2DFromArray(jcuda.Pointer, long, jcuda.runtime.cudaArray, long, long, long, long, int), cudaMemcpyArrayToArray(jcuda.runtime.cudaArray, long, long, jcuda.runtime.cudaArray, long, long, long, int), cudaMemcpy2DArrayToArray(jcuda.runtime.cudaArray, long, long, jcuda.runtime.cudaArray, long, long, long, long, int), cudaMemcpyToSymbol(java.lang.String, jcuda.Pointer, long, long, int), cudaMemcpyFromSymbol(jcuda.Pointer, java.lang.String, long, long, int), cudaMemcpyAsync(jcuda.Pointer, jcuda.Pointer, long, int, jcuda.runtime.cudaStream_t), cudaMemcpy2DAsync(jcuda.Pointer, long, jcuda.Pointer, long, long, long, int, jcuda.runtime.cudaStream_t), cudaMemcpyToArrayAsync(jcuda.runtime.cudaArray, long, long, jcuda.Pointer, long, int, jcuda.runtime.cudaStream_t), cudaMemcpy2DToArrayAsync(jcuda.runtime.cudaArray, long, long, jcuda.Pointer, long, long, long, int, jcuda.runtime.cudaStream_t), cudaMemcpyFromArrayAsync(jcuda.Pointer, jcuda.runtime.cudaArray, long, long, long, int, jcuda.runtime.cudaStream_t), cudaMemcpy2DFromArrayAsync(jcuda.Pointer, long, jcuda.runtime.cudaArray, long, long, long, long, int, jcuda.runtime.cudaStream_t), cudaMemcpyToSymbolAsync(java.lang.String, jcuda.Pointer, long, long, int, jcuda.runtime.cudaStream_t), cudaMemcpyFromSymbolAsync(jcuda.Pointer, java.lang.String, long, long, int, jcuda.runtime.cudaStream_t)

cudaMemcpyArrayToArray

public static int cudaMemcpyArrayToArray(cudaArray dst,
                                         long wOffsetDst,
                                         long hOffsetDst,
                                         cudaArray src,
                                         long wOffsetSrc,
                                         long hOffsetSrc,
                                         long count,
                                         int cudaMemcpyKind_kind)
Copies data between host and device.
cudaError_t cudaMemcpyArrayToArray ( struct cudaArray *  dst,
size_t  wOffsetDst,
size_t  hOffsetDst,
const struct cudaArray *  src,
size_t  wOffsetSrc,
size_t  hOffsetSrc,
size_t  count,
enum cudaMemcpyKind  kind  
)

Copies count bytes from the CUDA array src starting at the upper left corner (wOffsetSrc, hOffsetSrc) to the CUDA array dst starting at the upper left corner (wOffsetDst, hOffsetDst) where kind is one of cudaMemcpyHostToHost, cudaMemcpyHostToDevice, cudaMemcpyDeviceToHost, or cudaMemcpyDeviceToDevice, and specifies the direction of the copy.

Returns:
cudaSuccess, cudaErrorInvalidValue, cudaErrorInvalidMemcpyDirection
See Also:
cudaMemcpy(jcuda.Pointer, jcuda.Pointer, long, int), cudaMemcpy2D(jcuda.Pointer, long, jcuda.Pointer, long, long, long, int), cudaMemcpyToArray(jcuda.runtime.cudaArray, long, long, jcuda.Pointer, long, int), cudaMemcpy2DToArray(jcuda.runtime.cudaArray, long, long, jcuda.Pointer, long, long, long, int), cudaMemcpyFromArray(jcuda.Pointer, jcuda.runtime.cudaArray, long, long, long, int), cudaMemcpy2DFromArray(jcuda.Pointer, long, jcuda.runtime.cudaArray, long, long, long, long, int), cudaMemcpy2DArrayToArray(jcuda.runtime.cudaArray, long, long, jcuda.runtime.cudaArray, long, long, long, long, int), cudaMemcpyToSymbol(java.lang.String, jcuda.Pointer, long, long, int), cudaMemcpyFromSymbol(jcuda.Pointer, java.lang.String, long, long, int), cudaMemcpyAsync(jcuda.Pointer, jcuda.Pointer, long, int, jcuda.runtime.cudaStream_t), cudaMemcpy2DAsync(jcuda.Pointer, long, jcuda.Pointer, long, long, long, int, jcuda.runtime.cudaStream_t), cudaMemcpyToArrayAsync(jcuda.runtime.cudaArray, long, long, jcuda.Pointer, long, int, jcuda.runtime.cudaStream_t), cudaMemcpy2DToArrayAsync(jcuda.runtime.cudaArray, long, long, jcuda.Pointer, long, long, long, int, jcuda.runtime.cudaStream_t), cudaMemcpyFromArrayAsync(jcuda.Pointer, jcuda.runtime.cudaArray, long, long, long, int, jcuda.runtime.cudaStream_t), cudaMemcpy2DFromArrayAsync(jcuda.Pointer, long, jcuda.runtime.cudaArray, long, long, long, long, int, jcuda.runtime.cudaStream_t), cudaMemcpyToSymbolAsync(java.lang.String, jcuda.Pointer, long, long, int, jcuda.runtime.cudaStream_t), cudaMemcpyFromSymbolAsync(jcuda.Pointer, java.lang.String, long, long, int, jcuda.runtime.cudaStream_t)

cudaMemcpy2D

public static int cudaMemcpy2D(Pointer dst,
                               long dpitch,
                               Pointer src,
                               long spitch,
                               long width,
                               long height,
                               int cudaMemcpyKind_kind)
Copies data between host and device.
cudaError_t cudaMemcpy2D ( void *  dst,
size_t  dpitch,
const void *  src,
size_t  spitch,
size_t  width,
size_t  height,
enum cudaMemcpyKind  kind  
)

Copies a matrix (height rows of width bytes each) from the memory area pointed to by src to the memory area pointed to by dst, where kind is one of cudaMemcpyHostToHost, cudaMemcpyHostToDevice, cudaMemcpyDeviceToHost, or cudaMemcpyDeviceToDevice, and specifies the direction of the copy. dpitch and spitch are the widths in memory in bytes of the 2D arrays pointed to by dst and src, including any padding added to the end of each row. The memory areas may not overlap. Calling cudaMemcpy2D() with dst and src pointers that do not match the direction of the copy results in an undefined behavior. cudaMemcpy2D() returns an error if dpitch or spitch is greater than the maximum allowed.

Returns:
cudaSuccess, cudaErrorInvalidValue, cudaErrorInvalidPitchValue, cudaErrorInvalidDevicePointer, cudaErrorInvalidMemcpyDirection
See Also:
cudaMemcpy(jcuda.Pointer, jcuda.Pointer, long, int), cudaMemcpyToArray(jcuda.runtime.cudaArray, long, long, jcuda.Pointer, long, int), cudaMemcpy2DToArray(jcuda.runtime.cudaArray, long, long, jcuda.Pointer, long, long, long, int), cudaMemcpyFromArray(jcuda.Pointer, jcuda.runtime.cudaArray, long, long, long, int), cudaMemcpy2DFromArray(jcuda.Pointer, long, jcuda.runtime.cudaArray, long, long, long, long, int), cudaMemcpyArrayToArray(jcuda.runtime.cudaArray, long, long, jcuda.runtime.cudaArray, long, long, long, int), cudaMemcpy2DArrayToArray(jcuda.runtime.cudaArray, long, long, jcuda.runtime.cudaArray, long, long, long, long, int), cudaMemcpyToSymbol(java.lang.String, jcuda.Pointer, long, long, int), cudaMemcpyFromSymbol(jcuda.Pointer, java.lang.String, long, long, int), cudaMemcpyAsync(jcuda.Pointer, jcuda.Pointer, long, int, jcuda.runtime.cudaStream_t), cudaMemcpy2DAsync(jcuda.Pointer, long, jcuda.Pointer, long, long, long, int, jcuda.runtime.cudaStream_t), cudaMemcpyToArrayAsync(jcuda.runtime.cudaArray, long, long, jcuda.Pointer, long, int, jcuda.runtime.cudaStream_t), cudaMemcpy2DToArrayAsync(jcuda.runtime.cudaArray, long, long, jcuda.Pointer, long, long, long, int, jcuda.runtime.cudaStream_t), cudaMemcpyFromArrayAsync(jcuda.Pointer, jcuda.runtime.cudaArray, long, long, long, int, jcuda.runtime.cudaStream_t), cudaMemcpy2DFromArrayAsync(jcuda.Pointer, long, jcuda.runtime.cudaArray, long, long, long, long, int, jcuda.runtime.cudaStream_t), cudaMemcpyToSymbolAsync(java.lang.String, jcuda.Pointer, long, long, int, jcuda.runtime.cudaStream_t), cudaMemcpyFromSymbolAsync(jcuda.Pointer, java.lang.String, long, long, int, jcuda.runtime.cudaStream_t)

cudaMemcpy2DToArray

public static int cudaMemcpy2DToArray(cudaArray dst,
                                      long wOffset,
                                      long hOffset,
                                      Pointer src,
                                      long spitch,
                                      long width,
                                      long height,
                                      int cudaMemcpyKind_kind)
Copies data between host and device.
cudaError_t cudaMemcpy2DToArray ( struct cudaArray *  dst,
size_t  wOffset,
size_t  hOffset,
const void *  src,
size_t  spitch,
size_t  width,
size_t  height,
enum cudaMemcpyKind  kind  
)

Copies a matrix (height rows of width bytes each) from the memory area pointed to by src to the CUDA array dst starting at the upper left corner (wOffset, hOffset) where kind is one of cudaMemcpyHostToHost, cudaMemcpyHostToDevice, cudaMemcpyDeviceToHost, or cudaMemcpyDeviceToDevice, and specifies the direction of the copy. spitch is the width in memory in bytes of the 2D array pointed to by src, including any padding added to the end of each row. cudaMemcpy2DToArray() returns an error if spitch is greater than the maximum allowed.

Returns:
cudaSuccess, cudaErrorInvalidValue, cudaErrorInvalidDevicePointer, cudaErrorInvalidPitchValue, cudaErrorInvalidMemcpyDirection
See Also:
cudaMemcpy(jcuda.Pointer, jcuda.Pointer, long, int), cudaMemcpy2D(jcuda.Pointer, long, jcuda.Pointer, long, long, long, int), cudaMemcpyToArray(jcuda.runtime.cudaArray, long, long, jcuda.Pointer, long, int), cudaMemcpyFromArray(jcuda.Pointer, jcuda.runtime.cudaArray, long, long, long, int), cudaMemcpy2DFromArray(jcuda.Pointer, long, jcuda.runtime.cudaArray, long, long, long, long, int), cudaMemcpyArrayToArray(jcuda.runtime.cudaArray, long, long, jcuda.runtime.cudaArray, long, long, long, int), cudaMemcpy2DArrayToArray(jcuda.runtime.cudaArray, long, long, jcuda.runtime.cudaArray, long, long, long, long, int), cudaMemcpyToSymbol(java.lang.String, jcuda.Pointer, long, long, int), cudaMemcpyFromSymbol(jcuda.Pointer, java.lang.String, long, long, int), cudaMemcpyAsync(jcuda.Pointer, jcuda.Pointer, long, int, jcuda.runtime.cudaStream_t), cudaMemcpy2DAsync(jcuda.Pointer, long, jcuda.Pointer, long, long, long, int, jcuda.runtime.cudaStream_t), cudaMemcpyToArrayAsync(jcuda.runtime.cudaArray, long, long, jcuda.Pointer, long, int, jcuda.runtime.cudaStream_t), cudaMemcpy2DToArrayAsync(jcuda.runtime.cudaArray, long, long, jcuda.Pointer, long, long, long, int, jcuda.runtime.cudaStream_t), cudaMemcpyFromArrayAsync(jcuda.Pointer, jcuda.runtime.cudaArray, long, long, long, int, jcuda.runtime.cudaStream_t), cudaMemcpy2DFromArrayAsync(jcuda.Pointer, long, jcuda.runtime.cudaArray, long, long, long, long, int, jcuda.runtime.cudaStream_t), cudaMemcpyToSymbolAsync(java.lang.String, jcuda.Pointer, long, long, int, jcuda.runtime.cudaStream_t), cudaMemcpyFromSymbolAsync(jcuda.Pointer, java.lang.String, long, long, int, jcuda.runtime.cudaStream_t)

cudaMemcpy2DFromArray

public static int cudaMemcpy2DFromArray(Pointer dst,
                                        long dpitch,
                                        cudaArray src,
                                        long wOffset,
                                        long hOffset,
                                        long width,
                                        long height,
                                        int cudaMemcpyKind_kind)
Copies data between host and device.
cudaError_t cudaMemcpy2DFromArray ( void *  dst,
size_t  dpitch,
const struct cudaArray *  src,
size_t  wOffset,
size_t  hOffset,
size_t  width,
size_t  height,
enum cudaMemcpyKind  kind  
)

Copies a matrix (height rows of width bytes each) from the CUDA array srcArray starting at the upper left corner (wOffset, hOffset) to the memory area pointed to by dst, where kind is one of cudaMemcpyHostToHost, cudaMemcpyHostToDevice, cudaMemcpyDeviceToHost, or cudaMemcpyDeviceToDevice, and specifies the direction of the copy. dpitch is the width in memory in bytes of the 2D array pointed to by dst, including any padding added to the end of each row. cudaMemcpy2DFromArray() returns an error if dpitch is greater than the maximum allowed.

Returns:
cudaSuccess, cudaErrorInvalidValue, cudaErrorInvalidDevicePointer, cudaErrorInvalidPitchValue, cudaErrorInvalidMemcpyDirection
See Also:
cudaMemcpy(jcuda.Pointer, jcuda.Pointer, long, int), cudaMemcpy2D(jcuda.Pointer, long, jcuda.Pointer, long, long, long, int), cudaMemcpyToArray(jcuda.runtime.cudaArray, long, long, jcuda.Pointer, long, int), cudaMemcpy2DToArray(jcuda.runtime.cudaArray, long, long, jcuda.Pointer, long, long, long, int), cudaMemcpyFromArray(jcuda.Pointer, jcuda.runtime.cudaArray, long, long, long, int), cudaMemcpyArrayToArray(jcuda.runtime.cudaArray, long, long, jcuda.runtime.cudaArray, long, long, long, int), cudaMemcpy2DArrayToArray(jcuda.runtime.cudaArray, long, long, jcuda.runtime.cudaArray, long, long, long, long, int), cudaMemcpyToSymbol(java.lang.String, jcuda.Pointer, long, long, int), cudaMemcpyFromSymbol(jcuda.Pointer, java.lang.String, long, long, int), cudaMemcpyAsync(jcuda.Pointer, jcuda.Pointer, long, int, jcuda.runtime.cudaStream_t), cudaMemcpy2DAsync(jcuda.Pointer, long, jcuda.Pointer, long, long, long, int, jcuda.runtime.cudaStream_t), cudaMemcpyToArrayAsync(jcuda.runtime.cudaArray, long, long, jcuda.Pointer, long, int, jcuda.runtime.cudaStream_t), cudaMemcpy2DToArrayAsync(jcuda.runtime.cudaArray, long, long, jcuda.Pointer, long, long, long, int, jcuda.runtime.cudaStream_t), cudaMemcpyFromArrayAsync(jcuda.Pointer, jcuda.runtime.cudaArray, long, long, long, int, jcuda.runtime.cudaStream_t), cudaMemcpy2DFromArrayAsync(jcuda.Pointer, long, jcuda.runtime.cudaArray, long, long, long, long, int, jcuda.runtime.cudaStream_t), cudaMemcpyToSymbolAsync(java.lang.String, jcuda.Pointer, long, long, int, jcuda.runtime.cudaStream_t), cudaMemcpyFromSymbolAsync(jcuda.Pointer, java.lang.String, long, long, int, jcuda.runtime.cudaStream_t)

cudaMemcpy2DArrayToArray

public static int cudaMemcpy2DArrayToArray(cudaArray dst,
                                           long wOffsetDst,
                                           long hOffsetDst,
                                           cudaArray src,
                                           long wOffsetSrc,
                                           long hOffsetSrc,
                                           long width,
                                           long height,
                                           int cudaMemcpyKind_kind)
Copies data between host and device.
cudaError_t cudaMemcpy2DArrayToArray ( struct cudaArray *  dst,
size_t  wOffsetDst,
size_t  hOffsetDst,
const struct cudaArray *  src,
size_t  wOffsetSrc,
size_t  hOffsetSrc,
size_t  width,
size_t  height,
enum cudaMemcpyKind  kind  
)

Copies a matrix (height rows of width bytes each) from the CUDA array srcArray starting at the upper left corner (wOffsetSrc, hOffsetSrc) to the CUDA array dst starting at the upper left corner (wOffsetDst, hOffsetDst), where kind is one of cudaMemcpyHostToHost, cudaMemcpyHostToDevice, cudaMemcpyDeviceToHost, or cudaMemcpyDeviceToDevice, and specifies the direction of the copy.

Returns:
cudaSuccess, cudaErrorInvalidValue, cudaErrorInvalidMemcpyDirection
See Also:
cudaMemcpy(jcuda.Pointer, jcuda.Pointer, long, int), cudaMemcpy2D(jcuda.Pointer, long, jcuda.Pointer, long, long, long, int), cudaMemcpyToArray(jcuda.runtime.cudaArray, long, long, jcuda.Pointer, long, int), cudaMemcpy2DToArray(jcuda.runtime.cudaArray, long, long, jcuda.Pointer, long, long, long, int), cudaMemcpyFromArray(jcuda.Pointer, jcuda.runtime.cudaArray, long, long, long, int), cudaMemcpy2DFromArray(jcuda.Pointer, long, jcuda.runtime.cudaArray, long, long, long, long, int), cudaMemcpyArrayToArray(jcuda.runtime.cudaArray, long, long, jcuda.runtime.cudaArray, long, long, long, int), cudaMemcpyToSymbol(java.lang.String, jcuda.Pointer, long, long, int), cudaMemcpyFromSymbol(jcuda.Pointer, java.lang.String, long, long, int), cudaMemcpyAsync(jcuda.Pointer, jcuda.Pointer, long, int, jcuda.runtime.cudaStream_t), cudaMemcpy2DAsync(jcuda.Pointer, long, jcuda.Pointer, long, long, long, int, jcuda.runtime.cudaStream_t), cudaMemcpyToArrayAsync(jcuda.runtime.cudaArray, long, long, jcuda.Pointer, long, int, jcuda.runtime.cudaStream_t), cudaMemcpy2DToArrayAsync(jcuda.runtime.cudaArray, long, long, jcuda.Pointer, long, long, long, int, jcuda.runtime.cudaStream_t), cudaMemcpyFromArrayAsync(jcuda.Pointer, jcuda.runtime.cudaArray, long, long, long, int, jcuda.runtime.cudaStream_t), cudaMemcpy2DFromArrayAsync(jcuda.Pointer, long, jcuda.runtime.cudaArray, long, long, long, long, int, jcuda.runtime.cudaStream_t), cudaMemcpyToSymbolAsync(java.lang.String, jcuda.Pointer, long, long, int, jcuda.runtime.cudaStream_t), cudaMemcpyFromSymbolAsync(jcuda.Pointer, java.lang.String, long, long, int, jcuda.runtime.cudaStream_t)

cudaMemcpyToSymbol

public static int cudaMemcpyToSymbol(java.lang.String symbol,
                                     Pointer src,
                                     long count,
                                     long offset,
                                     int cudaMemcpyKind_kind)
Copies data to the given symbol on the device.
cudaError_t cudaMemcpyToSymbol ( const char *  symbol,
const void *  src,
size_t  count,
size_t  offset,
enum cudaMemcpyKind  kind  
)

Copies count bytes from the memory area pointed to by src to the memory area pointed to by offset bytes from the start of symbol symbol. The memory areas may not overlap. symbol can either be a variable that resides in global or constant memory space, or it can be a character string, naming a variable that resides in global or constant memory space. kind can be either cudaMemcpyHostToDevice or cudaMemcpyDeviceToDevice.

Returns:
cudaSuccess, cudaErrorInvalidValue, cudaErrorInvalidSymbol, cudaErrorInvalidDevicePointer, cudaErrorInvalidMemcpyDirection
See Also:
cudaMemcpy(jcuda.Pointer, jcuda.Pointer, long, int), cudaMemcpy2D(jcuda.Pointer, long, jcuda.Pointer, long, long, long, int), cudaMemcpyToArray(jcuda.runtime.cudaArray, long, long, jcuda.Pointer, long, int), cudaMemcpy2DToArray(jcuda.runtime.cudaArray, long, long, jcuda.Pointer, long, long, long, int), cudaMemcpyFromArray(jcuda.Pointer, jcuda.runtime.cudaArray, long, long, long, int), cudaMemcpy2DFromArray(jcuda.Pointer, long, jcuda.runtime.cudaArray, long, long, long, long, int), cudaMemcpyArrayToArray(jcuda.runtime.cudaArray, long, long, jcuda.runtime.cudaArray, long, long, long, int), cudaMemcpy2DArrayToArray(jcuda.runtime.cudaArray, long, long, jcuda.runtime.cudaArray, long, long, long, long, int), cudaMemcpyFromSymbol(jcuda.Pointer, java.lang.String, long, long, int), cudaMemcpyAsync(jcuda.Pointer, jcuda.Pointer, long, int, jcuda.runtime.cudaStream_t), cudaMemcpy2DAsync(jcuda.Pointer, long, jcuda.Pointer, long, long, long, int, jcuda.runtime.cudaStream_t), cudaMemcpyToArrayAsync(jcuda.runtime.cudaArray, long, long, jcuda.Pointer, long, int, jcuda.runtime.cudaStream_t), cudaMemcpy2DToArrayAsync(jcuda.runtime.cudaArray, long, long, jcuda.Pointer, long, long, long, int, jcuda.runtime.cudaStream_t), cudaMemcpyFromArrayAsync(jcuda.Pointer, jcuda.runtime.cudaArray, long, long, long, int, jcuda.runtime.cudaStream_t), cudaMemcpy2DFromArrayAsync(jcuda.Pointer, long, jcuda.runtime.cudaArray, long, long, long, long, int, jcuda.runtime.cudaStream_t), cudaMemcpyToSymbolAsync(java.lang.String, jcuda.Pointer, long, long, int, jcuda.runtime.cudaStream_t), cudaMemcpyFromSymbolAsync(jcuda.Pointer, java.lang.String, long, long, int, jcuda.runtime.cudaStream_t)

cudaMemcpyFromSymbol

public static int cudaMemcpyFromSymbol(Pointer dst,
                                       java.lang.String symbol,
                                       long count,
                                       long offset,
                                       int cudaMemcpyKind_kind)
Copies data from the given symbol on the device.
cudaError_t cudaMemcpyFromSymbol ( void *  dst,
const char *  symbol,
size_t  count,
size_t  offset,
enum cudaMemcpyKind  kind  
)

Copies count bytes from the memory area pointed to by offset bytes from the start of symbol symbol to the memory area pointed to by dst. The memory areas may not overlap. symbol can either be a variable that resides in global or constant memory space, or it can be a character string, naming a variable that resides in global or constant memory space. kind can be either cudaMemcpyDeviceToHost or cudaMemcpyDeviceToDevice.

Returns:
cudaSuccess, cudaErrorInvalidValue, cudaErrorInvalidSymbol, cudaErrorInvalidDevicePointer, cudaErrorInvalidMemcpyDirection
See Also:
cudaMemcpy(jcuda.Pointer, jcuda.Pointer, long, int), cudaMemcpy2D(jcuda.Pointer, long, jcuda.Pointer, long, long, long, int), cudaMemcpyToArray(jcuda.runtime.cudaArray, long, long, jcuda.Pointer, long, int), cudaMemcpy2DToArray(jcuda.runtime.cudaArray, long, long, jcuda.Pointer, long, long, long, int), cudaMemcpyFromArray(jcuda.Pointer, jcuda.runtime.cudaArray, long, long, long, int), cudaMemcpy2DFromArray(jcuda.Pointer, long, jcuda.runtime.cudaArray, long, long, long, long, int), cudaMemcpyArrayToArray(jcuda.runtime.cudaArray, long, long, jcuda.runtime.cudaArray, long, long, long, int), cudaMemcpy2DArrayToArray(jcuda.runtime.cudaArray, long, long, jcuda.runtime.cudaArray, long, long, long, long, int), cudaMemcpyToSymbol(java.lang.String, jcuda.Pointer, long, long, int), cudaMemcpyAsync(jcuda.Pointer, jcuda.Pointer, long, int, jcuda.runtime.cudaStream_t), cudaMemcpy2DAsync(jcuda.Pointer, long, jcuda.Pointer, long, long, long, int, jcuda.runtime.cudaStream_t), cudaMemcpyToArrayAsync(jcuda.runtime.cudaArray, long, long, jcuda.Pointer, long, int, jcuda.runtime.cudaStream_t), cudaMemcpy2DToArrayAsync(jcuda.runtime.cudaArray, long, long, jcuda.Pointer, long, long, long, int, jcuda.runtime.cudaStream_t), cudaMemcpyFromArrayAsync(jcuda.Pointer, jcuda.runtime.cudaArray, long, long, long, int, jcuda.runtime.cudaStream_t), cudaMemcpy2DFromArrayAsync(jcuda.Pointer, long, jcuda.runtime.cudaArray, long, long, long, long, int, jcuda.runtime.cudaStream_t), cudaMemcpyToSymbolAsync(java.lang.String, jcuda.Pointer, long, long, int, jcuda.runtime.cudaStream_t), cudaMemcpyFromSymbolAsync(jcuda.Pointer, java.lang.String, long, long, int, jcuda.runtime.cudaStream_t)

cudaMemcpyAsync

public static int cudaMemcpyAsync(Pointer dst,
                                  Pointer src,
                                  long count,
                                  int cudaMemcpyKind_kind,
                                  cudaStream_t stream)
Copies data between host and device.
cudaError_t cudaMemcpyAsync ( void *  dst,
const void *  src,
size_t  count,
enum cudaMemcpyKind  kind,
cudaStream_t  stream  
)

Copies count bytes from the memory area pointed to by src to the memory area pointed to by dst, where kind is one of cudaMemcpyHostToHost, cudaMemcpyHostToDevice, cudaMemcpyDeviceToHost, or cudaMemcpyDeviceToDevice, and specifies the direction of the copy. The memory areas may not overlap. Calling cudaMemcpyAsync() with dst and src pointers that do not match the direction of the copy results in an undefined behavior.

cudaMemcpyAsync() is asynchronous with respect to the host, so the call may return before the copy is complete. It only works on page-locked host memory and returns an error if a pointer to pageable memory is passed as input. The copy can optionally be associated to a stream by passing a non-zero stream argument. If kind is cudaMemcpyHostToDevice or cudaMemcpyDeviceToHost and the stream is non-zero, the copy may overlap with operations in other streams.

Returns:
cudaSuccess, cudaErrorInvalidValue, cudaErrorInvalidDevicePointer, cudaErrorInvalidMemcpyDirection
See Also:
cudaMemcpy(jcuda.Pointer, jcuda.Pointer, long, int), cudaMemcpy2D(jcuda.Pointer, long, jcuda.Pointer, long, long, long, int), cudaMemcpyToArray(jcuda.runtime.cudaArray, long, long, jcuda.Pointer, long, int), cudaMemcpy2DToArray(jcuda.runtime.cudaArray, long, long, jcuda.Pointer, long, long, long, int), cudaMemcpyFromArray(jcuda.Pointer, jcuda.runtime.cudaArray, long, long, long, int), cudaMemcpy2DFromArray(jcuda.Pointer, long, jcuda.runtime.cudaArray, long, long, long, long, int), cudaMemcpyArrayToArray(jcuda.runtime.cudaArray, long, long, jcuda.runtime.cudaArray, long, long, long, int), cudaMemcpy2DArrayToArray(jcuda.runtime.cudaArray, long, long, jcuda.runtime.cudaArray, long, long, long, long, int), cudaMemcpyToSymbol(java.lang.String, jcuda.Pointer, long, long, int), cudaMemcpyFromSymbol(jcuda.Pointer, java.lang.String, long, long, int), cudaMemcpy2DAsync(jcuda.Pointer, long, jcuda.Pointer, long, long, long, int, jcuda.runtime.cudaStream_t), cudaMemcpyToArrayAsync(jcuda.runtime.cudaArray, long, long, jcuda.Pointer, long, int, jcuda.runtime.cudaStream_t), cudaMemcpy2DToArrayAsync(jcuda.runtime.cudaArray, long, long, jcuda.Pointer, long, long, long, int, jcuda.runtime.cudaStream_t), cudaMemcpyFromArrayAsync(jcuda.Pointer, jcuda.runtime.cudaArray, long, long, long, int, jcuda.runtime.cudaStream_t), cudaMemcpy2DFromArrayAsync(jcuda.Pointer, long, jcuda.runtime.cudaArray, long, long, long, long, int, jcuda.runtime.cudaStream_t), cudaMemcpyToSymbolAsync(java.lang.String, jcuda.Pointer, long, long, int, jcuda.runtime.cudaStream_t), cudaMemcpyFromSymbolAsync(jcuda.Pointer, java.lang.String, long, long, int, jcuda.runtime.cudaStream_t)

cudaMemcpyToArrayAsync

public static int cudaMemcpyToArrayAsync(cudaArray dst,
                                         long wOffset,
                                         long hOffset,
                                         Pointer src,
                                         long count,
                                         int cudaMemcpyKind_kind,
                                         cudaStream_t stream)
Copies data between host and device.
cudaError_t cudaMemcpyToArrayAsync ( struct cudaArray *  dst,
size_t  wOffset,
size_t  hOffset,
const void *  src,
size_t  count,
enum cudaMemcpyKind  kind,
cudaStream_t  stream  
)

Copies count bytes from the memory area pointed to by src to the CUDA array dst starting at the upper left corner (wOffset, hOffset), where kind is one of cudaMemcpyHostToHost, cudaMemcpyHostToDevice, cudaMemcpyDeviceToHost, or cudaMemcpyDeviceToDevice, and specifies the direction of the copy.

cudaMemcpyToArrayAsync() is asynchronous with respect to the host, so the call may return before the copy is complete. It only works on page-locked host memory and returns an error if a pointer to pageable memory is passed as input. The copy can optionally be associated to a stream by passing a non-zero stream argument. If kind is cudaMemcpyHostToDevice or cudaMemcpyDeviceToHost and stream is non-zero, the copy may overlap with operations in other streams.

Returns:
cudaSuccess, cudaErrorInvalidValue, cudaErrorInvalidDevicePointer, cudaErrorInvalidMemcpyDirection
See Also:
cudaMemcpy(jcuda.Pointer, jcuda.Pointer, long, int), cudaMemcpy2D(jcuda.Pointer, long, jcuda.Pointer, long, long, long, int), cudaMemcpyToArray(jcuda.runtime.cudaArray, long, long, jcuda.Pointer, long, int), cudaMemcpy2DToArray(jcuda.runtime.cudaArray, long, long, jcuda.Pointer, long, long, long, int), cudaMemcpyFromArray(jcuda.Pointer, jcuda.runtime.cudaArray, long, long, long, int), cudaMemcpy2DFromArray(jcuda.Pointer, long, jcuda.runtime.cudaArray, long, long, long, long, int), cudaMemcpyArrayToArray(jcuda.runtime.cudaArray, long, long, jcuda.runtime.cudaArray, long, long, long, int), cudaMemcpy2DArrayToArray(jcuda.runtime.cudaArray, long, long, jcuda.runtime.cudaArray, long, long, long, long, int), cudaMemcpyToSymbol(java.lang.String, jcuda.Pointer, long, long, int), cudaMemcpyFromSymbol(jcuda.Pointer, java.lang.String, long, long, int), cudaMemcpyAsync(jcuda.Pointer, jcuda.Pointer, long, int, jcuda.runtime.cudaStream_t), cudaMemcpy2DAsync(jcuda.Pointer, long, jcuda.Pointer, long, long, long, int, jcuda.runtime.cudaStream_t), cudaMemcpy2DToArrayAsync(jcuda.runtime.cudaArray, long, long, jcuda.Pointer, long, long, long, int, jcuda.runtime.cudaStream_t), cudaMemcpyFromArrayAsync(jcuda.Pointer, jcuda.runtime.cudaArray, long, long, long, int, jcuda.runtime.cudaStream_t), cudaMemcpy2DFromArrayAsync(jcuda.Pointer, long, jcuda.runtime.cudaArray, long, long, long, long, int, jcuda.runtime.cudaStream_t), cudaMemcpyToSymbolAsync(java.lang.String, jcuda.Pointer, long, long, int, jcuda.runtime.cudaStream_t), cudaMemcpyFromSymbolAsync(jcuda.Pointer, java.lang.String, long, long, int, jcuda.runtime.cudaStream_t)

cudaMemcpyFromArrayAsync

public static int cudaMemcpyFromArrayAsync(Pointer dst,
                                           cudaArray src,
                                           long wOffset,
                                           long hOffset,
                                           long count,
                                           int cudaMemcpyKind_kind,
                                           cudaStream_t stream)
Copies data between host and device.
cudaError_t cudaMemcpyFromArrayAsync ( void *  dst,
const struct cudaArray *  src,
size_t  wOffset,
size_t  hOffset,
size_t  count,
enum cudaMemcpyKind  kind,
cudaStream_t  stream  
)

Copies count bytes from the CUDA array src starting at the upper left corner (wOffset, hOffset) to the memory area pointed to by dst, where kind is one of cudaMemcpyHostToHost, cudaMemcpyHostToDevice, cudaMemcpyDeviceToHost, or cudaMemcpyDeviceToDevice, and specifies the direction of the copy.

cudaMemcpyFromArrayAsync() is asynchronous with respect to the host, so the call may return before the copy is complete. It only works on page-locked host memory and returns an error if a pointer to pageable memory is passed as input. The copy can optionally be associated to a stream by passing a non-zero stream argument. If kind is cudaMemcpyHostToDevice or cudaMemcpyDeviceToHost and stream is non-zero, the copy may overlap with operations in other streams.

Returns:
cudaSuccess, cudaErrorInvalidValue, cudaErrorInvalidDevicePointer, cudaErrorInvalidMemcpyDirection
See Also:
cudaMemcpy(jcuda.Pointer, jcuda.Pointer, long, int), cudaMemcpy2D(jcuda.Pointer, long, jcuda.Pointer, long, long, long, int), cudaMemcpyToArray(jcuda.runtime.cudaArray, long, long, jcuda.Pointer, long, int), cudaMemcpy2DToArray(jcuda.runtime.cudaArray, long, long, jcuda.Pointer, long, long, long, int), cudaMemcpyFromArray(jcuda.Pointer, jcuda.runtime.cudaArray, long, long, long, int), cudaMemcpy2DFromArray(jcuda.Pointer, long, jcuda.runtime.cudaArray, long, long, long, long, int), cudaMemcpyArrayToArray(jcuda.runtime.cudaArray, long, long, jcuda.runtime.cudaArray, long, long, long, int), cudaMemcpy2DArrayToArray(jcuda.runtime.cudaArray, long, long, jcuda.runtime.cudaArray, long, long, long, long, int), cudaMemcpyToSymbol(java.lang.String, jcuda.Pointer, long, long, int), cudaMemcpyFromSymbol(jcuda.Pointer, java.lang.String, long, long, int), cudaMemcpyAsync(jcuda.Pointer, jcuda.Pointer, long, int, jcuda.runtime.cudaStream_t), cudaMemcpy2DAsync(jcuda.Pointer, long, jcuda.Pointer, long, long, long, int, jcuda.runtime.cudaStream_t), cudaMemcpyToArrayAsync(jcuda.runtime.cudaArray, long, long, jcuda.Pointer, long, int, jcuda.runtime.cudaStream_t), cudaMemcpy2DToArrayAsync(jcuda.runtime.cudaArray, long, long, jcuda.Pointer, long, long, long, int, jcuda.runtime.cudaStream_t), cudaMemcpy2DFromArrayAsync(jcuda.Pointer, long, jcuda.runtime.cudaArray, long, long, long, long, int, jcuda.runtime.cudaStream_t), cudaMemcpyToSymbolAsync(java.lang.String, jcuda.Pointer, long, long, int, jcuda.runtime.cudaStream_t), cudaMemcpyFromSymbolAsync(jcuda.Pointer, java.lang.String, long, long, int, jcuda.runtime.cudaStream_t)

cudaMemcpy2DAsync

public static int cudaMemcpy2DAsync(Pointer dst,
                                    long dpitch,
                                    Pointer src,
                                    long spitch,
                                    long width,
                                    long height,
                                    int cudaMemcpyKind_kind,
                                    cudaStream_t stream)
Copies data between host and device.
cudaError_t cudaMemcpy2DAsync ( void *  dst,
size_t  dpitch,
const void *  src,
size_t  spitch,
size_t  width,
size_t  height,
enum cudaMemcpyKind  kind,
cudaStream_t  stream  
)

Copies a matrix (height rows of width bytes each) from the memory area pointed to by src to the memory area pointed to by dst, where kind is one of cudaMemcpyHostToHost, cudaMemcpyHostToDevice, cudaMemcpyDeviceToHost, or cudaMemcpyDeviceToDevice, and specifies the direction of the copy. dpitch and spitch are the widths in memory in bytes of the 2D arrays pointed to by dst and src, including any padding added to the end of each row. The memory areas may not overlap. Calling cudaMemcpy2DAsync() with dst and src pointers that do not match the direction of the copy results in an undefined behavior. cudaMemcpy2DAsync() returns an error if dpitch or spitch is greater than the maximum allowed.

cudaMemcpy2DAsync() is asynchronous with respect to the host, so the call may return before the copy is complete. It only works on page-locked host memory and returns an error if a pointer to pageable memory is passed as input. The copy can optionally be associated to a stream by passing a non-zero stream argument. If kind is cudaMemcpyHostToDevice or cudaMemcpyDeviceToHost and stream is non-zero, the copy may overlap with operations in other streams.

Returns:
cudaSuccess, cudaErrorInvalidValue, cudaErrorInvalidPitchValue, cudaErrorInvalidDevicePointer, cudaErrorInvalidMemcpyDirection
See Also:
cudaMemcpy(jcuda.Pointer, jcuda.Pointer, long, int), cudaMemcpy2D(jcuda.Pointer, long, jcuda.Pointer, long, long, long, int), cudaMemcpyToArray(jcuda.runtime.cudaArray, long, long, jcuda.Pointer, long, int), cudaMemcpy2DToArray(jcuda.runtime.cudaArray, long, long, jcuda.Pointer, long, long, long, int), cudaMemcpyFromArray(jcuda.Pointer, jcuda.runtime.cudaArray, long, long, long, int), cudaMemcpy2DFromArray(jcuda.Pointer, long, jcuda.runtime.cudaArray, long, long, long, long, int), cudaMemcpyArrayToArray(jcuda.runtime.cudaArray, long, long, jcuda.runtime.cudaArray, long, long, long, int), cudaMemcpy2DArrayToArray(jcuda.runtime.cudaArray, long, long, jcuda.runtime.cudaArray, long, long, long, long, int), cudaMemcpyToSymbol(java.lang.String, jcuda.Pointer, long, long, int), cudaMemcpyFromSymbol(jcuda.Pointer, java.lang.String, long, long, int), cudaMemcpyAsync(jcuda.Pointer, jcuda.Pointer, long, int, jcuda.runtime.cudaStream_t), cudaMemcpyToArrayAsync(jcuda.runtime.cudaArray, long, long, jcuda.Pointer, long, int, jcuda.runtime.cudaStream_t), cudaMemcpy2DToArrayAsync(jcuda.runtime.cudaArray, long, long, jcuda.Pointer, long, long, long, int, jcuda.runtime.cudaStream_t), cudaMemcpyFromArrayAsync(jcuda.Pointer, jcuda.runtime.cudaArray, long, long, long, int, jcuda.runtime.cudaStream_t), cudaMemcpy2DFromArrayAsync(jcuda.Pointer, long, jcuda.runtime.cudaArray, long, long, long, long, int, jcuda.runtime.cudaStream_t), cudaMemcpyToSymbolAsync(java.lang.String, jcuda.Pointer, long, long, int, jcuda.runtime.cudaStream_t), cudaMemcpyFromSymbolAsync(jcuda.Pointer, java.lang.String, long, long, int, jcuda.runtime.cudaStream_t)

cudaMemcpy2DToArrayAsync

public static int cudaMemcpy2DToArrayAsync(cudaArray dst,
                                           long wOffset,
                                           long hOffset,
                                           Pointer src,
                                           long spitch,
                                           long width,
                                           long height,
                                           int cudaMemcpyKind_kind,
                                           cudaStream_t stream)
Copies data between host and device.
cudaError_t cudaMemcpy2DToArrayAsync ( struct cudaArray *  dst,
size_t  wOffset,
size_t  hOffset,
const void *  src,
size_t  spitch,
size_t  width,
size_t  height,
enum cudaMemcpyKind  kind,
cudaStream_t  stream  
)

Copies a matrix (height rows of width bytes each) from the memory area pointed to by src to the CUDA array dst starting at the upper left corner (wOffset, hOffset) where kind is one of cudaMemcpyHostToHost, cudaMemcpyHostToDevice, cudaMemcpyDeviceToHost, or cudaMemcpyDeviceToDevice, and specifies the direction of the copy. spitch is the width in memory in bytes of the 2D array pointed to by src, including any padding added to the end of each row. cudaMemcpy2DToArrayAsync() returns an error if spitch is greater than the maximum allowed.

cudaMemcpy2DToArrayAsync() is asynchronous with respect to the host, so the call may return before the copy is complete. It only works on page-locked host memory and returns an error if a pointer to pageable memory is passed as input. The copy can optionally be associated to a stream by passing a non-zero stream argument. If kind is cudaMemcpyHostToDevice or cudaMemcpyDeviceToHost and stream is non-zero, the copy may overlap with operations in other streams.

Returns:
cudaSuccess, cudaErrorInvalidValue, cudaErrorInvalidDevicePointer, cudaErrorInvalidPitchValue, cudaErrorInvalidMemcpyDirection
See Also:
cudaMemcpy(jcuda.Pointer, jcuda.Pointer, long, int), cudaMemcpy2D(jcuda.Pointer, long, jcuda.Pointer, long, long, long, int), cudaMemcpyToArray(jcuda.runtime.cudaArray, long, long, jcuda.Pointer, long, int), cudaMemcpy2DToArray(jcuda.runtime.cudaArray, long, long, jcuda.Pointer, long, long, long, int), cudaMemcpyFromArray(jcuda.Pointer, jcuda.runtime.cudaArray, long, long, long, int), cudaMemcpy2DFromArray(jcuda.Pointer, long, jcuda.runtime.cudaArray, long, long, long, long, int), cudaMemcpyArrayToArray(jcuda.runtime.cudaArray, long, long, jcuda.runtime.cudaArray, long, long, long, int), cudaMemcpy2DArrayToArray(jcuda.runtime.cudaArray, long, long, jcuda.runtime.cudaArray, long, long, long, long, int), cudaMemcpyToSymbol(java.lang.String, jcuda.Pointer, long, long, int), cudaMemcpyFromSymbol(jcuda.Pointer, java.lang.String, long, long, int), cudaMemcpyAsync(jcuda.Pointer, jcuda.Pointer, long, int, jcuda.runtime.cudaStream_t), cudaMemcpy2DAsync(jcuda.Pointer, long, jcuda.Pointer, long, long, long, int, jcuda.runtime.cudaStream_t), cudaMemcpyToArrayAsync(jcuda.runtime.cudaArray, long, long, jcuda.Pointer, long, int, jcuda.runtime.cudaStream_t), cudaMemcpyFromArrayAsync(jcuda.Pointer, jcuda.runtime.cudaArray, long, long, long, int, jcuda.runtime.cudaStream_t), cudaMemcpy2DFromArrayAsync(jcuda.Pointer, long, jcuda.runtime.cudaArray, long, long, long, long, int, jcuda.runtime.cudaStream_t), cudaMemcpyToSymbolAsync(java.lang.String, jcuda.Pointer, long, long, int, jcuda.runtime.cudaStream_t), cudaMemcpyFromSymbolAsync(jcuda.Pointer, java.lang.String, long, long, int, jcuda.runtime.cudaStream_t)

cudaMemcpy2DFromArrayAsync

public static int cudaMemcpy2DFromArrayAsync(Pointer dst,
                                             long dpitch,
                                             cudaArray src,
                                             long wOffset,
                                             long hOffset,
                                             long width,
                                             long height,
                                             int cudaMemcpyKind_kind,
                                             cudaStream_t stream)
Copies data between host and device.
cudaError_t cudaMemcpy2DFromArrayAsync ( void *  dst,
size_t  dpitch,
const struct cudaArray *  src,
size_t  wOffset,
size_t  hOffset,
size_t  width,
size_t  height,
enum cudaMemcpyKind  kind,
cudaStream_t  stream  
)

Copies a matrix (height rows of width bytes each) from the CUDA array srcArray starting at the upper left corner (wOffset, hOffset) to the memory area pointed to by dst, where kind is one of cudaMemcpyHostToHost, cudaMemcpyHostToDevice, cudaMemcpyDeviceToHost, or cudaMemcpyDeviceToDevice, and specifies the direction of the copy. dpitch is the width in memory in bytes of the 2D array pointed to by dst, including any padding added to the end of each row. cudaMemcpy2DFromArrayAsync() returns an error if dpitch is greater than the maximum allowed.

cudaMemcpy2DFromArrayAsync() is asynchronous with respect to the host, so the call may return before the copy is complete. It only works on page-locked host memory and returns an error if a pointer to pageable memory is passed as input. The copy can optionally be associated to a stream by passing a non-zero stream argument. If kind is cudaMemcpyHostToDevice or cudaMemcpyDeviceToHost and stream is non-zero, the copy may overlap with operations in other streams.

Returns:
cudaSuccess, cudaErrorInvalidValue, cudaErrorInvalidDevicePointer, cudaErrorInvalidPitchValue, cudaErrorInvalidMemcpyDirection
See Also:
cudaMemcpy(jcuda.Pointer, jcuda.Pointer, long, int), cudaMemcpy2D(jcuda.Pointer, long, jcuda.Pointer, long, long, long, int), cudaMemcpyToArray(jcuda.runtime.cudaArray, long, long, jcuda.Pointer, long, int), cudaMemcpy2DToArray(jcuda.runtime.cudaArray, long, long, jcuda.Pointer, long, long, long, int), cudaMemcpyFromArray(jcuda.Pointer, jcuda.runtime.cudaArray, long, long, long, int), cudaMemcpy2DFromArray(jcuda.Pointer, long, jcuda.runtime.cudaArray, long, long, long, long, int), cudaMemcpyArrayToArray(jcuda.runtime.cudaArray, long, long, jcuda.runtime.cudaArray, long, long, long, int), cudaMemcpy2DArrayToArray(jcuda.runtime.cudaArray, long, long, jcuda.runtime.cudaArray, long, long, long, long, int), cudaMemcpyToSymbol(java.lang.String, jcuda.Pointer, long, long, int), cudaMemcpyFromSymbol(jcuda.Pointer, java.lang.String, long, long, int), cudaMemcpyAsync(jcuda.Pointer, jcuda.Pointer, long, int, jcuda.runtime.cudaStream_t), cudaMemcpy2DAsync(jcuda.Pointer, long, jcuda.Pointer, long, long, long, int, jcuda.runtime.cudaStream_t), cudaMemcpyToArrayAsync(jcuda.runtime.cudaArray, long, long, jcuda.Pointer, long, int, jcuda.runtime.cudaStream_t), cudaMemcpy2DToArrayAsync(jcuda.runtime.cudaArray, long, long, jcuda.Pointer, long, long, long, int, jcuda.runtime.cudaStream_t), cudaMemcpyFromArrayAsync(jcuda.Pointer, jcuda.runtime.cudaArray, long, long, long, int, jcuda.runtime.cudaStream_t), cudaMemcpyToSymbolAsync(java.lang.String, jcuda.Pointer, long, long, int, jcuda.runtime.cudaStream_t), cudaMemcpyFromSymbolAsync(jcuda.Pointer, java.lang.String, long, long, int, jcuda.runtime.cudaStream_t)

cudaMemcpyToSymbolAsync

public static int cudaMemcpyToSymbolAsync(java.lang.String symbol,
                                          Pointer src,
                                          long count,
                                          long offset,
                                          int cudaMemcpyKind_kind,
                                          cudaStream_t stream)
Copies data to the given symbol on the device.
cudaError_t cudaMemcpyToSymbolAsync ( const char *  symbol,
const void *  src,
size_t  count,
size_t  offset,
enum cudaMemcpyKind  kind,
cudaStream_t  stream  
)

Copies count bytes from the memory area pointed to by src to the memory area pointed to by offset bytes from the start of symbol symbol. The memory areas may not overlap. symbol can either be a variable that resides in global or constant memory space, or it can be a character string, naming a variable that resides in global or constant memory space. kind can be either cudaMemcpyHostToDevice or cudaMemcpyDeviceToDevice.

cudaMemcpyToSymbolAsync() is asynchronous with respect to the host, so the call may return before the copy is complete. It only works on page-locked host memory and returns an error if a pointer to pageable memory is passed as input. The copy can optionally be associated to a stream by passing a non-zero stream argument. If kind is cudaMemcpyHostToDevice and stream is non-zero, the copy may overlap with operations in other streams.

Returns:
cudaSuccess, cudaErrorInvalidValue, cudaErrorInvalidSymbol, cudaErrorInvalidDevicePointer, cudaErrorInvalidMemcpyDirection
See Also:
cudaMemcpy(jcuda.Pointer, jcuda.Pointer, long, int), cudaMemcpy2D(jcuda.Pointer, long, jcuda.Pointer, long, long, long, int), cudaMemcpyToArray(jcuda.runtime.cudaArray, long, long, jcuda.Pointer, long, int), cudaMemcpy2DToArray(jcuda.runtime.cudaArray, long, long, jcuda.Pointer, long, long, long, int), cudaMemcpyFromArray(jcuda.Pointer, jcuda.runtime.cudaArray, long, long, long, int), cudaMemcpy2DFromArray(jcuda.Pointer, long, jcuda.runtime.cudaArray, long, long, long, long, int), cudaMemcpyArrayToArray(jcuda.runtime.cudaArray, long, long, jcuda.runtime.cudaArray, long, long, long, int), cudaMemcpy2DArrayToArray(jcuda.runtime.cudaArray, long, long, jcuda.runtime.cudaArray, long, long, long, long, int), cudaMemcpyToSymbol(java.lang.String, jcuda.Pointer, long, long, int), cudaMemcpyFromSymbol(jcuda.Pointer, java.lang.String, long, long, int), cudaMemcpyAsync(jcuda.Pointer, jcuda.Pointer, long, int, jcuda.runtime.cudaStream_t), cudaMemcpy2DAsync(jcuda.Pointer, long, jcuda.Pointer, long, long, long, int, jcuda.runtime.cudaStream_t), cudaMemcpyToArrayAsync(jcuda.runtime.cudaArray, long, long, jcuda.Pointer, long, int, jcuda.runtime.cudaStream_t), cudaMemcpy2DToArrayAsync(jcuda.runtime.cudaArray, long, long, jcuda.Pointer, long, long, long, int, jcuda.runtime.cudaStream_t), cudaMemcpyFromArrayAsync(jcuda.Pointer, jcuda.runtime.cudaArray, long, long, long, int, jcuda.runtime.cudaStream_t), cudaMemcpy2DFromArrayAsync(jcuda.Pointer, long, jcuda.runtime.cudaArray, long, long, long, long, int, jcuda.runtime.cudaStream_t), cudaMemcpyFromSymbolAsync(jcuda.Pointer, java.lang.String, long, long, int, jcuda.runtime.cudaStream_t)

cudaMemcpyFromSymbolAsync

public static int cudaMemcpyFromSymbolAsync(Pointer dst,
                                            java.lang.String symbol,
                                            long count,
                                            long offset,
                                            int cudaMemcpyKind_kind,
                                            cudaStream_t stream)
Copies data from the given symbol on the device.
cudaError_t cudaMemcpyFromSymbolAsync ( void *  dst,
const char *  symbol,
size_t  count,
size_t  offset,
enum cudaMemcpyKind  kind,
cudaStream_t  stream  
)

Copies count bytes from the memory area pointed to by offset bytes from the start of symbol symbol to the memory area pointed to by dst. The memory areas may not overlap. symbol can either be a variable that resides in global or constant memory space, or it can be a character string, naming a variable that resides in global or constant memory space. kind can be either cudaMemcpyDeviceToHost or cudaMemcpyDeviceToDevice.

cudaMemcpyFromSymbolAsync() is asynchronous with respect to the host, so the call may return before the copy is complete. It only works on page-locked host memory and returns an error if a pointer to pageable memory is passed as input. The copy can optionally be associated to a stream by passing a non-zero stream argument. If kind is cudaMemcpyDeviceToHost and stream is non-zero, the copy may overlap with operations in other streams.

Returns:
cudaSuccess, cudaErrorInvalidValue, cudaErrorInvalidSymbol, cudaErrorInvalidDevicePointer, cudaErrorInvalidMemcpyDirection
See Also:
cudaMemcpy(jcuda.Pointer, jcuda.Pointer, long, int), cudaMemcpy2D(jcuda.Pointer, long, jcuda.Pointer, long, long, long, int), cudaMemcpyToArray(jcuda.runtime.cudaArray, long, long, jcuda.Pointer, long, int), cudaMemcpy2DToArray(jcuda.runtime.cudaArray, long, long, jcuda.Pointer, long, long, long, int), cudaMemcpyFromArray(jcuda.Pointer, jcuda.runtime.cudaArray, long, long, long, int), cudaMemcpy2DFromArray(jcuda.Pointer, long, jcuda.runtime.cudaArray, long, long, long, long, int), cudaMemcpyArrayToArray(jcuda.runtime.cudaArray, long, long, jcuda.runtime.cudaArray, long, long, long, int), cudaMemcpy2DArrayToArray(jcuda.runtime.cudaArray, long, long, jcuda.runtime.cudaArray, long, long, long, long, int), cudaMemcpyToSymbol(java.lang.String, jcuda.Pointer, long, long, int), cudaMemcpyFromSymbol(jcuda.Pointer, java.lang.String, long, long, int), cudaMemcpyAsync(jcuda.Pointer, jcuda.Pointer, long, int, jcuda.runtime.cudaStream_t), cudaMemcpy2DAsync(jcuda.Pointer, long, jcuda.Pointer, long, long, long, int, jcuda.runtime.cudaStream_t), cudaMemcpyToArrayAsync(jcuda.runtime.cudaArray, long, long, jcuda.Pointer, long, int, jcuda.runtime.cudaStream_t), cudaMemcpy2DToArrayAsync(jcuda.runtime.cudaArray, long, long, jcuda.Pointer, long, long, long, int, jcuda.runtime.cudaStream_t), cudaMemcpyFromArrayAsync(jcuda.Pointer, jcuda.runtime.cudaArray, long, long, long, int, jcuda.runtime.cudaStream_t), cudaMemcpy2DFromArrayAsync(jcuda.Pointer, long, jcuda.runtime.cudaArray, long, long, long, long, int, jcuda.runtime.cudaStream_t), cudaMemcpyToSymbolAsync(java.lang.String, jcuda.Pointer, long, long, int, jcuda.runtime.cudaStream_t)

cudaMemset

public static int cudaMemset(Pointer mem,
                             int c,
                             long count)
Initializes or sets device memory to a value.
cudaError_t cudaMemset ( void *  devPtr,
int  value,
size_t  count  
)

Fills the first count bytes of the memory area pointed to by devPtr with the constant byte value value.

Returns:
cudaSuccess, cudaErrorInvalidValue, cudaErrorInvalidDevicePointer
See Also:
cudaMemset2D(jcuda.Pointer, long, int, long, long), cudaMemset3D(jcuda.runtime.cudaPitchedPtr, int, jcuda.runtime.cudaExtent)

cudaMemset2D

public static int cudaMemset2D(Pointer mem,
                               long pitch,
                               int c,
                               long width,
                               long height)
Initializes or sets device memory to a value.
cudaError_t cudaMemset2D ( void *  devPtr,
size_t  pitch,
int  value,
size_t  width,
size_t  height  
)

Sets to the specified value value a matrix (height rows of width bytes each) pointed to by dstPtr. pitch is the width in bytes of the 2D array pointed to by dstPtr, including any padding added to the end of each row. This function performs fastest when the pitch is one that has been passed back by cudaMallocPitch().

Returns:
cudaSuccess, cudaErrorInvalidValue, cudaErrorInvalidDevicePointer
See Also:
cudaMemset(jcuda.Pointer, int, long), cudaMemset3D(jcuda.runtime.cudaPitchedPtr, int, jcuda.runtime.cudaExtent)

cudaGetChannelDesc

public static int cudaGetChannelDesc(cudaChannelFormatDesc desc,
                                     cudaArray array)
Get the channel descriptor of an array.
cudaError_t cudaGetChannelDesc ( struct cudaChannelFormatDesc *  desc,
const struct cudaArray *  array  
)

Returns in *desc the channel descriptor of the CUDA array array.

Returns:
cudaSuccess, cudaErrorInvalidValue
See Also:
cudaCreateChannelDesc(int, int, int, int, int), cudaGetTextureReference(jcuda.runtime.textureReference, java.lang.String), cudaBindTexture(long[], jcuda.runtime.textureReference, jcuda.Pointer, jcuda.runtime.cudaChannelFormatDesc, long), cudaBindTexture2D(long[], jcuda.runtime.textureReference, jcuda.Pointer, jcuda.runtime.cudaChannelFormatDesc, long, long, long), cudaBindTextureToArray(jcuda.runtime.textureReference, jcuda.runtime.cudaArray, jcuda.runtime.cudaChannelFormatDesc), cudaUnbindTexture(jcuda.runtime.textureReference), cudaGetTextureAlignmentOffset(long[], jcuda.runtime.textureReference)

cudaCreateChannelDesc

public static cudaChannelFormatDesc cudaCreateChannelDesc(int x,
                                                          int y,
                                                          int z,
                                                          int w,
                                                          int cudaChannelFormatKind_f)
Returns a channel descriptor using the specified format.
template<class T >
cudaChannelFormatDesc cudaCreateChannelDesc ( void   ) 

Returns a channel descriptor with format f and number of bits of each component x, y, z, and w. The cudaChannelFormatDesc is defined as:

  struct cudaChannelFormatDesc {
     int x, y, z, w;
     enum cudaChannelFormatKind f;
   };
 

where cudaChannelFormatKind is one of cudaChannelFormatKindSigned, cudaChannelFormatKindUnsigned, or cudaChannelFormatKindFloat.

Returns:
Channel descriptor with format f
See Also:
cudaCreateChannelDesc(int, int, int, int, int), cudaGetChannelDesc(jcuda.runtime.cudaChannelFormatDesc, jcuda.runtime.cudaArray), cudaGetTextureReference(jcuda.runtime.textureReference, java.lang.String), cudaBindTexture(long[], jcuda.runtime.textureReference, jcuda.Pointer, jcuda.runtime.cudaChannelFormatDesc, long), cudaBindTexture(long[], jcuda.runtime.textureReference, jcuda.Pointer, jcuda.runtime.cudaChannelFormatDesc, long), cudaBindTexture2D(long[], jcuda.runtime.textureReference, jcuda.Pointer, jcuda.runtime.cudaChannelFormatDesc, long, long, long), cudaBindTextureToArray(jcuda.runtime.textureReference, jcuda.runtime.cudaArray, jcuda.runtime.cudaChannelFormatDesc), cudaBindTextureToArray(jcuda.runtime.textureReference, jcuda.runtime.cudaArray, jcuda.runtime.cudaChannelFormatDesc), cudaUnbindTexture(jcuda.runtime.textureReference), cudaGetTextureAlignmentOffset(long[], jcuda.runtime.textureReference)

cudaGetLastError

public static int cudaGetLastError()
Returns the last error from a runtime call.
cudaError_t cudaGetLastError ( void   ) 

Returns the last error that has been produced by any of the runtime calls in the same host thread and resets it to cudaSuccess.

Returns:
cudaSuccess, cudaErrorMissingConfiguration, cudaErrorMemoryAllocation, cudaErrorInitializationError, cudaErrorLaunchFailure, cudaErrorPriorLaunchFailure, cudaErrorLaunchTimeout, cudaErrorLaunchOutOfResources, cudaErrorInvalidDeviceFunction, cudaErrorInvalidConfiguration, cudaErrorInvalidDevice cudaErrorInvalidValue cudaErrorInvalidPitchValue cudaErrorInvalidSymbol cudaErrorMapBufferObjectFailed cudaErrorUnmapBufferObjectFailed cudaErrorInvalidHostPointer cudaErrorInvalidDevicePointer cudaErrorInvalidTexture cudaErrorInvalidTextureBinding cudaErrorInvalidChannelDescriptor cudaErrorInvalidMemcpyDirection cudaErrorTextureFetchFailed cudaErrorTextureNotBound cudaErrorSynchronizationError cudaErrorInvalidFilterSetting cudaErrorInvalidNormSetting cudaErrorMixedDeviceExecution cudaErrorCudartUnloading cudaErrorUnknown cudaErrorNotYetImplemented cudaErrorMemoryValueTooLarge cudaErrorInvalidResourceHandle cudaErrorInsufficientDriver cudaErrorSetOnActiveProcess cudaErrorStartupFailure cudaErrorApiFailureBase
See Also:
cudaPeekAtLastError(), cudaGetErrorString(int)

cudaPeekAtLastError

public static int cudaPeekAtLastError()
Returns the last error from a runtime call.
cudaError_t cudaPeekAtLastError ( void   ) 

Returns the last error that has been produced by any of the runtime calls in the same host thread. Note that this call does not reset the error to cudaSuccess like cudaGetLastError().

Returns:
cudaSuccess, cudaErrorMissingConfiguration, cudaErrorMemoryAllocation, cudaErrorInitializationError, cudaErrorLaunchFailure, cudaErrorPriorLaunchFailure, cudaErrorLaunchTimeout, cudaErrorLaunchOutOfResources, cudaErrorInvalidDeviceFunction, cudaErrorInvalidConfiguration, cudaErrorInvalidDevice cudaErrorInvalidValue cudaErrorInvalidPitchValue cudaErrorInvalidSymbol cudaErrorMapBufferObjectFailed cudaErrorUnmapBufferObjectFailed cudaErrorInvalidHostPointer cudaErrorInvalidDevicePointer cudaErrorInvalidTexture cudaErrorInvalidTextureBinding cudaErrorInvalidChannelDescriptor cudaErrorInvalidMemcpyDirection cudaErrorTextureFetchFailed cudaErrorTextureNotBound cudaErrorSynchronizationError cudaErrorInvalidFilterSetting cudaErrorInvalidNormSetting cudaErrorMixedDeviceExecution cudaErrorCudartUnloading cudaErrorUnknown cudaErrorNotYetImplemented cudaErrorMemoryValueTooLarge cudaErrorInvalidResourceHandle cudaErrorInsufficientDriver cudaErrorSetOnActiveProcess cudaErrorStartupFailure cudaErrorApiFailureBase
See Also:
cudaGetLastError(), cudaGetErrorString(int)

cudaGetErrorString

public static java.lang.String cudaGetErrorString(int error)
Returns the message string from an error code.
const char* cudaGetErrorString ( cudaError_t  error  ) 

Returns the message string from an error code.

Returns:
char* pointer to a NULL-terminated string
See Also:
cudaGetLastError(), cudaPeekAtLastError()

cudaStreamCreate

public static int cudaStreamCreate(cudaStream_t stream)
Create an asynchronous stream.
cudaError_t cudaStreamCreate ( cudaStream_t *  pStream  ) 

Creates a new asynchronous stream.

Returns:
cudaSuccess, cudaErrorInvalidValue
See Also:
cudaStreamQuery(jcuda.runtime.cudaStream_t), cudaStreamSynchronize(jcuda.runtime.cudaStream_t), cudaStreamDestroy(jcuda.runtime.cudaStream_t)

cudaStreamDestroy

public static int cudaStreamDestroy(cudaStream_t stream)
Destroys and cleans up an asynchronous stream.
cudaError_t cudaStreamDestroy ( cudaStream_t  stream  ) 

Destroys and cleans up the asynchronous stream specified by stream.

Returns:
cudaSuccess, cudaErrorInvalidResourceHandle
See Also:
cudaStreamCreate(jcuda.runtime.cudaStream_t), cudaStreamQuery(jcuda.runtime.cudaStream_t), cudaStreamSynchronize(jcuda.runtime.cudaStream_t)

cudaStreamSynchronize

public static int cudaStreamSynchronize(cudaStream_t stream)
Waits for stream tasks to complete.
cudaError_t cudaStreamSynchronize ( cudaStream_t  stream  ) 

Blocks until stream has completed all operations. If the cudaDeviceBlockingSync flag was set for this device, the host thread will block until the stream is finished with all of its tasks.

Returns:
cudaSuccess, cudaErrorInvalidResourceHandle
See Also:
cudaStreamCreate(jcuda.runtime.cudaStream_t), cudaStreamQuery(jcuda.runtime.cudaStream_t), cudaStreamDestroy(jcuda.runtime.cudaStream_t)

cudaStreamQuery

public static int cudaStreamQuery(cudaStream_t stream)
Queries an asynchronous stream for completion status.
cudaError_t cudaStreamQuery ( cudaStream_t  stream  ) 

Returns cudaSuccess if all operations in stream have completed, or cudaErrorNotReady if not.

Returns:
cudaSuccess, cudaErrorNotReady cudaErrorInvalidResourceHandle
See Also:
cudaStreamCreate(jcuda.runtime.cudaStream_t), cudaStreamSynchronize(jcuda.runtime.cudaStream_t), cudaStreamDestroy(jcuda.runtime.cudaStream_t)

cudaEventCreate

public static int cudaEventCreate(cudaEvent_t event)
Creates an event object.
cudaError_t cudaEventCreate ( cudaEvent_t *  event  ) 

Creates an event object using cudaEventDefault.

Returns:
cudaSuccess, cudaErrorInitializationError, cudaErrorPriorLaunchFailure, cudaErrorInvalidValue, cudaErrorMemoryAllocation
See Also:
cudaEventCreateWithFlags(jcuda.runtime.cudaEvent_t, int), cudaEventRecord(jcuda.runtime.cudaEvent_t, jcuda.runtime.cudaStream_t), cudaEventQuery(jcuda.runtime.cudaEvent_t), cudaEventSynchronize(jcuda.runtime.cudaEvent_t), cudaEventDestroy(jcuda.runtime.cudaEvent_t), cudaEventElapsedTime(float[], jcuda.runtime.cudaEvent_t, jcuda.runtime.cudaEvent_t)

cudaEventCreateWithFlags

public static int cudaEventCreateWithFlags(cudaEvent_t event,
                                           int flags)
Creates an event object with the specified flags.
cudaError_t cudaEventCreateWithFlags ( cudaEvent_t *  event,
int  flags  
)

Creates an event object with the specified flags. Valid flags include:

  • cudaEventDefault: Default event creation flag.
  • cudaEventBlockingSync: Specifies that event should use blocking synchronization. A host thread that uses cudaEventSynchronize() to wait on an event created with this flag will block until the event actually completes.

Returns:
cudaSuccess, cudaErrorInitializationError, cudaErrorPriorLaunchFailure, cudaErrorInvalidValue, cudaErrorMemoryAllocation
See Also:
cudaEventCreate(jcuda.runtime.cudaEvent_t), cudaEventRecord(jcuda.runtime.cudaEvent_t, jcuda.runtime.cudaStream_t), cudaEventQuery(jcuda.runtime.cudaEvent_t), cudaEventSynchronize(jcuda.runtime.cudaEvent_t), cudaEventDestroy(jcuda.runtime.cudaEvent_t), cudaEventElapsedTime(float[], jcuda.runtime.cudaEvent_t, jcuda.runtime.cudaEvent_t)

cudaEventRecord

public static int cudaEventRecord(cudaEvent_t event,
                                  cudaStream_t stream)
Records an event.
cudaError_t cudaEventRecord ( cudaEvent_t  event,
cudaStream_t  stream  
)

Records an event. If stream is non-zero, the event is recorded after all preceding operations in the stream have been completed; otherwise, it is recorded after all preceding operations in the CUDA context have been completed. Since this operation is asynchronous, cudaEventQuery() and/or cudaEventSynchronize() must be used to determine when the event has actually been recorded.

If cudaEventRecord() has previously been called and the event has not been recorded yet, this function returns cudaErrorInvalidValue.

Returns:
cudaSuccess, cudaErrorInvalidValue, cudaErrorInitializationError, cudaErrorPriorLaunchFailure, cudaErrorInvalidResourceHandle
See Also:
cudaEventCreate(jcuda.runtime.cudaEvent_t), cudaEventCreateWithFlags(jcuda.runtime.cudaEvent_t, int), cudaEventQuery(jcuda.runtime.cudaEvent_t), cudaEventSynchronize(jcuda.runtime.cudaEvent_t), cudaEventDestroy(jcuda.runtime.cudaEvent_t), cudaEventElapsedTime(float[], jcuda.runtime.cudaEvent_t, jcuda.runtime.cudaEvent_t)

cudaEventQuery

public static int cudaEventQuery(cudaEvent_t event)
Query if an event has been recorded.
cudaError_t cudaEventQuery ( cudaEvent_t  event  ) 

Returns cudaSuccess if the event has actually been recorded, or cudaErrorNotReady if not. If cudaEventRecord() has not been called on this event, the function returns cudaErrorInvalidValue.

Returns:
cudaSuccess, cudaErrorNotReady, cudaErrorInitializationError, cudaErrorPriorLaunchFailure, cudaErrorInvalidValue cudaErrorInvalidResourceHandle
See Also:
cudaEventCreate(jcuda.runtime.cudaEvent_t), cudaEventCreateWithFlags(jcuda.runtime.cudaEvent_t, int), cudaEventRecord(jcuda.runtime.cudaEvent_t, jcuda.runtime.cudaStream_t), cudaEventSynchronize(jcuda.runtime.cudaEvent_t), cudaEventDestroy(jcuda.runtime.cudaEvent_t), cudaEventElapsedTime(float[], jcuda.runtime.cudaEvent_t, jcuda.runtime.cudaEvent_t)

cudaEventSynchronize

public static int cudaEventSynchronize(cudaEvent_t event)
Wait for an event to be recorded.
cudaError_t cudaEventSynchronize ( cudaEvent_t  event  ) 

Blocks until the event has actually been recorded. If cudaEventRecord() has not been called on this event, the function returns cudaErrorInvalidValue. Waiting for an event that was created with the cudaEventBlockingSync flag will cause the calling host thread to block until the event has actually been recorded.

Returns:
cudaSuccess, cudaErrorInitializationError, cudaErrorPriorLaunchFailure, cudaErrorInvalidValue cudaErrorInvalidResourceHandle
See Also:
cudaEventCreate(jcuda.runtime.cudaEvent_t), cudaEventCreateWithFlags(jcuda.runtime.cudaEvent_t, int), cudaEventRecord(jcuda.runtime.cudaEvent_t, jcuda.runtime.cudaStream_t), cudaEventQuery(jcuda.runtime.cudaEvent_t), cudaEventDestroy(jcuda.runtime.cudaEvent_t), cudaEventElapsedTime(float[], jcuda.runtime.cudaEvent_t, jcuda.runtime.cudaEvent_t)

cudaEventDestroy

public static int cudaEventDestroy(cudaEvent_t event)
Destroys an event object.
cudaError_t cudaEventDestroy ( cudaEvent_t  event  ) 

Destroys the specified event object.

Returns:
cudaSuccess, cudaErrorInitializationError, cudaErrorPriorLaunchFailure, cudaErrorInvalidValue
See Also:
cudaEventCreate(jcuda.runtime.cudaEvent_t), cudaEventCreateWithFlags(jcuda.runtime.cudaEvent_t, int), cudaEventQuery(jcuda.runtime.cudaEvent_t), cudaEventSynchronize(jcuda.runtime.cudaEvent_t), cudaEventRecord(jcuda.runtime.cudaEvent_t, jcuda.runtime.cudaStream_t), cudaEventElapsedTime(float[], jcuda.runtime.cudaEvent_t, jcuda.runtime.cudaEvent_t)

cudaEventElapsedTime

public static int cudaEventElapsedTime(float[] ms,
                                       cudaEvent_t start,
                                       cudaEvent_t end)
Computes the elapsed time between events.
cudaError_t cudaEventElapsedTime ( float *  ms,
cudaEvent_t  start,
cudaEvent_t  end  
)

Computes the elapsed time between two events (in milliseconds with a resolution of around 0.5 microseconds). If either event has not been recorded yet, this function returns cudaErrorInvalidValue.

When stream is non-zero for either event (even if it uses the same stream ID), the result may be greater than expected. This is because the cudaEventRecord() operation takes place asynchronously and there is no guarantee that the measured latency is actually just between the two events. Any number of other different stream operations could execute in between the two measured events, thus altering the timing in a significant way.

Returns:
cudaSuccess, cudaErrorInvalidValue, cudaErrorInitializationError, cudaErrorPriorLaunchFailure, cudaErrorInvalidResourceHandle
See Also:
cudaEventCreate(jcuda.runtime.cudaEvent_t), cudaEventCreateWithFlags(jcuda.runtime.cudaEvent_t, int), cudaEventQuery(jcuda.runtime.cudaEvent_t), cudaEventSynchronize(jcuda.runtime.cudaEvent_t), cudaEventDestroy(jcuda.runtime.cudaEvent_t), cudaEventRecord(jcuda.runtime.cudaEvent_t, jcuda.runtime.cudaStream_t)

cudaThreadExit

public static int cudaThreadExit()
Exit and clean up from CUDA launches.
cudaError_t cudaThreadExit ( void   ) 

Explicitly cleans up all runtime-related resources associated with the calling host thread. Any subsequent API call reinitializes the runtime. cudaThreadExit() is implicitly called on host thread exit.

Returns:
cudaSuccess
See Also:
cudaThreadSynchronize()

cudaThreadSynchronize

public static int cudaThreadSynchronize()
Wait for compute device to finish.
cudaError_t cudaThreadSynchronize ( void   ) 

Blocks until the device has completed all preceding requested tasks. cudaThreadSynchronize() returns an error if one of the preceding tasks has failed. If the cudaDeviceBlockingSync flag was set for this device, the host thread will block until the device has finished its work.

Returns:
cudaSuccess
See Also:
cudaThreadExit()

cudaThreadSetLimit

public static int cudaThreadSetLimit(int limit,
                                     long value)
Set resource limits.
cudaError_t cudaThreadSetLimit ( enum cudaLimit  limit,
size_t  value  
)

Setting limit to value is a request by the application to update the current limit maintained by the thread. The driver is free to modify the requested value to meet h/w requirements (this could be clamping to minimum or maximum values, rounding up to nearest element size, etc). The application can use cudaThreadGetLimit() to find out exactly what the limit has been set to.

Setting each cudaLimit has its own specific restrictions, so each is discussed here.

  • cudaLimitStackSize controls the stack size of each GPU thread. This limit is only applicable to devices of compute capability 2.0 and higher. Attempting to set this limit on devices of compute capability less than 2.0 will result in the error cudaErrorUnsupportedLimit being returned.

  • cudaLimitPrintfFifoSize controls the size of the FIFO used by the printf() device system call. Setting cudaLimitPrintfFifoSize must be performed before loading any module that uses the printf() device system call, otherwise cudaErrorInvalidValue will be returned. This limit is only applicable to devices of compute capability 2.0 and higher. Attempting to set this limit on devices of compute capability less than 2.0 will result in the error cudaErrorUnsupportedLimit being returned.

Returns:
cudaSuccess, cudaErrorUnsupportedLimit, cudaErrorInvalidValue
See Also:
cudaThreadGetLimit(long[], int)

cudaThreadGetLimit

public static int cudaThreadGetLimit(long[] pValue,
                                     int limit)
Returns resource limits.
cudaError_t cudaThreadGetLimit ( size_t *  pValue,
enum cudaLimit  limit  
)

Returns in *pValue the current size of limit. The supported cudaLimit values are:

  • cudaLimitStackSize: stack size of each GPU thread;
  • cudaLimitPrintfFifoSize: size of the FIFO used by the printf() device system call.

Returns:
cudaSuccess, cudaErrorUnsupportedLimit, cudaErrorInvalidValue
See Also:
cudaThreadSetLimit(int, long)

cudaGetSymbolAddress

public static int cudaGetSymbolAddress(Pointer devPtr,
                                       java.lang.String symbol)
Finds the address associated with a CUDA symbol.
template<class T >
cudaError_t cudaGetSymbolAddress ( void **  devPtr,
const T &  symbol  
)

Returns in *devPtr the address of symbol symbol on the device. symbol can either be a variable that resides in global or constant memory space, or it can be a character string, naming a variable that resides in global or constant memory space. If symbol cannot be found, or if symbol is not declared in the global or constant memory space, *devPtr is unchanged and the error cudaErrorInvalidSymbol is returned. If there are multiple global or constant variables with the same string name (from separate files) and the lookup is done via character string, cudaErrorDuplicateVariableName is returned.

Returns:
cudaSuccess, cudaErrorInvalidSymbol, cudaErrorDuplicateVariableName
See Also:
cudaGetSymbolAddress(jcuda.Pointer, java.lang.String)

cudaGetSymbolSize

public static int cudaGetSymbolSize(long[] size,
                                    java.lang.String symbol)
Finds the size of the object associated with a CUDA symbol.
template<class T >
cudaError_t cudaGetSymbolSize ( size_t *  size,
const T &  symbol  
)

Returns in *size the size of symbol symbol. symbol can either be a variable that resides in global or constant memory space, or it can be a character string, naming a variable that resides in global or constant memory space. If symbol cannot be found, or if symbol is not declared in global or constant memory space, *size is unchanged and the error cudaErrorInvalidSymbol is returned. If there are multiple global variables with the same string name (from separate files) and the lookup is done via character string, cudaErrorDuplicateVariableName is returned.

Returns:
cudaSuccess, cudaErrorInvalidSymbol, cudaErrorDuplicateVariableName
See Also:
cudaGetSymbolAddress(jcuda.Pointer, java.lang.String)

cudaBindTexture

public static int cudaBindTexture(long[] offset,
                                  textureReference texref,
                                  Pointer devPtr,
                                  cudaChannelFormatDesc desc,
                                  long size)
Binds a memory area to a texture.
template<class T , int dim, enum cudaTextureReadMode readMode>
cudaError_t cudaBindTexture ( size_t *  offset,
const struct texture< T, dim, readMode > &  tex,
const void *  devPtr,
const struct cudaChannelFormatDesc &  desc,
size_t  size = UINT_MAX  
)

Binds size bytes of the memory area pointed to by devPtr to texture reference tex. desc describes how the memory is interpreted when fetching values from the texture. The offset parameter is an optional byte offset as with the low-level cudaBindTexture() function. Any memory previously bound to tex is unbound.

Returns:
cudaSuccess, cudaErrorInvalidValue, cudaErrorInvalidDevicePointer, cudaErrorInvalidTexture
See Also:
cudaCreateChannelDesc(int, int, int, int, int), cudaGetChannelDesc(jcuda.runtime.cudaChannelFormatDesc, jcuda.runtime.cudaArray), cudaGetTextureReference(jcuda.runtime.textureReference, java.lang.String), cudaBindTexture(long[], jcuda.runtime.textureReference, jcuda.Pointer, jcuda.runtime.cudaChannelFormatDesc, long), cudaBindTexture(long[], jcuda.runtime.textureReference, jcuda.Pointer, jcuda.runtime.cudaChannelFormatDesc, long), cudaBindTexture2D(long[], jcuda.runtime.textureReference, jcuda.Pointer, jcuda.runtime.cudaChannelFormatDesc, long, long, long), cudaBindTextureToArray(jcuda.runtime.textureReference, jcuda.runtime.cudaArray, jcuda.runtime.cudaChannelFormatDesc), cudaBindTextureToArray(jcuda.runtime.textureReference, jcuda.runtime.cudaArray, jcuda.runtime.cudaChannelFormatDesc), cudaUnbindTexture(jcuda.runtime.textureReference), cudaGetTextureAlignmentOffset(long[], jcuda.runtime.textureReference)

cudaBindTexture2D

public static int cudaBindTexture2D(long[] offset,
                                    textureReference texref,
                                    Pointer devPtr,
                                    cudaChannelFormatDesc desc,
                                    long width,
                                    long height,
                                    long pitch)
Binds a 2D memory area to a texture.
template<class T , int dim, enum cudaTextureReadMode readMode>
cudaError_t cudaBindTexture2D ( size_t *  offset,
const struct texture< T, dim, readMode > &  tex,
const void *  devPtr,
const struct cudaChannelFormatDesc &  desc,
size_t  width,
size_t  height,
size_t  pitch  
)

Binds the 2D memory area pointed to by devPtr to the texture reference tex. The size of the area is constrained by width in texel units, height in texel units, and pitch in byte units. desc describes how the memory is interpreted when fetching values from the texture. Any memory previously bound to tex is unbound.

Since the hardware enforces an alignment requirement on texture base addresses, cudaBindTexture2D() returns in *offset a byte offset that must be applied to texture fetches in order to read from the desired memory. This offset must be divided by the texel size and passed to kernels that read from the texture so they can be applied to the tex2D() function. If the device memory pointer was returned from cudaMalloc(), the offset is guaranteed to be 0 and NULL may be passed as the offset parameter.

Returns:
cudaSuccess, cudaErrorInvalidValue, cudaErrorInvalidDevicePointer, cudaErrorInvalidTexture
See Also:
cudaCreateChannelDesc(int, int, int, int, int), cudaGetChannelDesc(jcuda.runtime.cudaChannelFormatDesc, jcuda.runtime.cudaArray), cudaGetTextureReference(jcuda.runtime.textureReference, java.lang.String), cudaBindTexture(long[], jcuda.runtime.textureReference, jcuda.Pointer, jcuda.runtime.cudaChannelFormatDesc, long), cudaBindTexture(long[], jcuda.runtime.textureReference, jcuda.Pointer, jcuda.runtime.cudaChannelFormatDesc, long), cudaBindTexture2D(long[], jcuda.runtime.textureReference, jcuda.Pointer, jcuda.runtime.cudaChannelFormatDesc, long, long, long), cudaBindTextureToArray(jcuda.runtime.textureReference, jcuda.runtime.cudaArray, jcuda.runtime.cudaChannelFormatDesc), cudaBindTextureToArray(jcuda.runtime.textureReference, jcuda.runtime.cudaArray, jcuda.runtime.cudaChannelFormatDesc), cudaUnbindTexture(jcuda.runtime.textureReference), cudaGetTextureAlignmentOffset(long[], jcuda.runtime.textureReference)

cudaBindTextureToArray

public static int cudaBindTextureToArray(textureReference texref,
                                         cudaArray array,
                                         cudaChannelFormatDesc desc)
Binds an array to a texture.
template<class T , int dim, enum cudaTextureReadMode readMode>
cudaError_t cudaBindTextureToArray ( const struct texture< T, dim, readMode > &  tex,
const struct cudaArray *  array,
const struct cudaChannelFormatDesc &  desc  
)

Binds the CUDA array array to the texture reference tex. desc describes how the memory is interpreted when fetching values from the texture. Any CUDA array previously bound to tex is unbound.

Returns:
cudaSuccess, cudaErrorInvalidValue, cudaErrorInvalidDevicePointer, cudaErrorInvalidTexture
See Also:
cudaCreateChannelDesc(int, int, int, int, int), cudaGetChannelDesc(jcuda.runtime.cudaChannelFormatDesc, jcuda.runtime.cudaArray), cudaGetTextureReference(jcuda.runtime.textureReference, java.lang.String), cudaBindTexture(long[], jcuda.runtime.textureReference, jcuda.Pointer, jcuda.runtime.cudaChannelFormatDesc, long), cudaBindTexture(long[], jcuda.runtime.textureReference, jcuda.Pointer, jcuda.runtime.cudaChannelFormatDesc, long), cudaBindTexture2D(long[], jcuda.runtime.textureReference, jcuda.Pointer, jcuda.runtime.cudaChannelFormatDesc, long, long, long), cudaBindTextureToArray(jcuda.runtime.textureReference, jcuda.runtime.cudaArray, jcuda.runtime.cudaChannelFormatDesc), cudaBindTextureToArray(jcuda.runtime.textureReference, jcuda.runtime.cudaArray, jcuda.runtime.cudaChannelFormatDesc), cudaUnbindTexture(jcuda.runtime.textureReference), cudaGetTextureAlignmentOffset(long[], jcuda.runtime.textureReference)

cudaUnbindTexture

public static int cudaUnbindTexture(textureReference texref)
Unbinds a texture.
template<class T , int dim, enum cudaTextureReadMode readMode>
cudaError_t cudaUnbindTexture ( const struct texture< T, dim, readMode > &  tex  ) 

Unbinds the texture bound to tex.

Returns:
cudaSuccess
See Also:
cudaCreateChannelDesc(int, int, int, int, int), cudaGetChannelDesc(jcuda.runtime.cudaChannelFormatDesc, jcuda.runtime.cudaArray), cudaGetTextureReference(jcuda.runtime.textureReference, java.lang.String), cudaBindTexture(long[], jcuda.runtime.textureReference, jcuda.Pointer, jcuda.runtime.cudaChannelFormatDesc, long), cudaBindTexture(long[], jcuda.runtime.textureReference, jcuda.Pointer, jcuda.runtime.cudaChannelFormatDesc, long), cudaBindTexture2D(long[], jcuda.runtime.textureReference, jcuda.Pointer, jcuda.runtime.cudaChannelFormatDesc, long, long, long), cudaBindTextureToArray(jcuda.runtime.textureReference, jcuda.runtime.cudaArray, jcuda.runtime.cudaChannelFormatDesc), cudaBindTextureToArray(jcuda.runtime.textureReference, jcuda.runtime.cudaArray, jcuda.runtime.cudaChannelFormatDesc), cudaUnbindTexture(jcuda.runtime.textureReference), cudaGetTextureAlignmentOffset(long[], jcuda.runtime.textureReference)

cudaGetTextureAlignmentOffset

public static int cudaGetTextureAlignmentOffset(long[] offset,
                                                textureReference texref)
Get the alignment offset of a texture.
template<class T , int dim, enum cudaTextureReadMode readMode>
cudaError_t cudaGetTextureAlignmentOffset ( size_t *  offset,
const struct texture< T, dim, readMode > &  tex  
)

Returns in *offset the offset that was returned when texture reference tex was bound.

Returns:
cudaSuccess, cudaErrorInvalidTexture, cudaErrorInvalidTextureBinding
See Also:
cudaCreateChannelDesc(int, int, int, int, int), cudaGetChannelDesc(jcuda.runtime.cudaChannelFormatDesc, jcuda.runtime.cudaArray), cudaGetTextureReference(jcuda.runtime.textureReference, java.lang.String), cudaBindTexture(long[], jcuda.runtime.textureReference, jcuda.Pointer, jcuda.runtime.cudaChannelFormatDesc, long), cudaBindTexture(long[], jcuda.runtime.textureReference, jcuda.Pointer, jcuda.runtime.cudaChannelFormatDesc, long), cudaBindTexture2D(long[], jcuda.runtime.textureReference, jcuda.Pointer, jcuda.runtime.cudaChannelFormatDesc, long, long, long), cudaBindTextureToArray(jcuda.runtime.textureReference, jcuda.runtime.cudaArray, jcuda.runtime.cudaChannelFormatDesc), cudaBindTextureToArray(jcuda.runtime.textureReference, jcuda.runtime.cudaArray, jcuda.runtime.cudaChannelFormatDesc), cudaUnbindTexture(jcuda.runtime.textureReference), cudaGetTextureAlignmentOffset(long[], jcuda.runtime.textureReference)

cudaGetTextureReference

public static int cudaGetTextureReference(textureReference texref,
                                          java.lang.String symbol)
Get the texture reference associated with a symbol.
cudaError_t cudaGetTextureReference ( const struct textureReference **  texref,
const char *  symbol  
)

Returns in *texref the structure associated to the texture reference defined by symbol symbol.

Returns:
cudaSuccess, cudaErrorInvalidTexture
See Also:
cudaCreateChannelDesc(int, int, int, int, int), cudaGetChannelDesc(jcuda.runtime.cudaChannelFormatDesc, jcuda.runtime.cudaArray), cudaGetTextureAlignmentOffset(long[], jcuda.runtime.textureReference), cudaBindTexture(long[], jcuda.runtime.textureReference, jcuda.Pointer, jcuda.runtime.cudaChannelFormatDesc, long), cudaBindTexture2D(long[], jcuda.runtime.textureReference, jcuda.Pointer, jcuda.runtime.cudaChannelFormatDesc, long, long, long), cudaBindTextureToArray(jcuda.runtime.textureReference, jcuda.runtime.cudaArray, jcuda.runtime.cudaChannelFormatDesc), cudaUnbindTexture(jcuda.runtime.textureReference)

cudaBindSurfaceToArray

public static int cudaBindSurfaceToArray(surfaceReference surfref,
                                         cudaArray array,
                                         cudaChannelFormatDesc desc)
Binds an array to a surface.
template<class T , int dim>
cudaError_t cudaBindSurfaceToArray ( const struct surface< T, dim > &  surf,
const struct cudaArray *  array,
const struct cudaChannelFormatDesc &  desc  
)

Binds the CUDA array array to the surface reference surf. desc describes how the memory is interpreted when dealing with the surface. Any CUDA array previously bound to surf is unbound.

Returns:
cudaSuccess, cudaErrorInvalidValue, cudaErrorInvalidSurface
See Also:
cudaBindSurfaceToArray(jcuda.runtime.surfaceReference, jcuda.runtime.cudaArray, jcuda.runtime.cudaChannelFormatDesc), cudaBindSurfaceToArray(jcuda.runtime.surfaceReference, jcuda.runtime.cudaArray, jcuda.runtime.cudaChannelFormatDesc)

cudaGetSurfaceAlignmentOffset

public static int cudaGetSurfaceAlignmentOffset(long[] offset,
                                                surfaceReference surfref)
NOTE: This function occurs in the documentation and the header filed, but is NOT present in the CUDA runtime library, Version 3.1, Build 9. This might be a copy&paste-error. So this function currently throws an UnsupportedOperationException Get the alignment offset of a surface.
cudaError_t cudaGetSurfaceAlignmentOffset ( size_t *  offset,
const struct surfaceReference *  surfref  
)

Returns in *offset the offset that was returned when surface reference surface was bound.

Returns:
cudaSuccess, cudaErrorInvalidSurface, cudaErrorInvalidSurfaceBinding
See Also:
cudaBindSurfaceToArray(jcuda.runtime.surfaceReference, jcuda.runtime.cudaArray, jcuda.runtime.cudaChannelFormatDesc), cudaGetSurfaceReference(jcuda.runtime.surfaceReference, java.lang.String)

cudaGetSurfaceReference

public static int cudaGetSurfaceReference(surfaceReference surfref,
                                          java.lang.String symbol)
Get the surface reference associated with a symbol.
cudaError_t cudaGetSurfaceReference ( const struct surfaceReference **  surfref,
const char *  symbol  
)

Returns in *surfref the structure associated to the surface reference defined by symbol symbol.

Returns:
cudaSuccess, cudaErrorInvalidSurface
See Also:
cudaBindSurfaceToArray(jcuda.runtime.surfaceReference, jcuda.runtime.cudaArray, jcuda.runtime.cudaChannelFormatDesc), cudaGetSurfaceAlignmentOffset(long[], jcuda.runtime.surfaceReference)

cudaConfigureCall

public static int cudaConfigureCall(dim3 gridDim,
                                    dim3 blockDim,
                                    long sharedMem,
                                    cudaStream_t stream)
Configure a device-launch.
cudaError_t cudaConfigureCall ( dim3  gridDim,
dim3  blockDim,
size_t  sharedMem,
cudaStream_t  stream  
)

Specifies the grid and block dimensions for the device call to be executed similar to the execution configuration syntax. cudaConfigureCall() is stack based. Each call pushes data on top of an execution stack. This data contains the dimension for the grid and thread blocks, together with any arguments for the call.

Returns:
cudaSuccess, cudaErrorInvalidConfiguration
See Also:
cudaFuncGetAttributes(jcuda.runtime.cudaFuncAttributes, java.lang.String), cudaLaunch(java.lang.String), cudaSetupArgument(jcuda.Pointer, long, long)

cudaSetupArgument

public static int cudaSetupArgument(Pointer arg,
                                    long size,
                                    long offset)
Configure a device launch.
template<class T >
cudaError_t cudaSetupArgument ( arg,
size_t  offset  
)

Pushes size bytes of the argument pointed to by arg at offset bytes from the start of the parameter passing area, which starts at offset 0. The arguments are stored in the top of the execution stack. cudaSetupArgument() must be preceded by a call to cudaConfigureCall().

Returns:
cudaSuccess
See Also:
cudaConfigureCall(jcuda.runtime.dim3, jcuda.runtime.dim3, long, jcuda.runtime.cudaStream_t), cudaFuncGetAttributes(jcuda.runtime.cudaFuncAttributes, java.lang.String), cudaLaunch(java.lang.String), cudaSetupArgument(jcuda.Pointer, long, long)

cudaFuncGetAttributes

public static int cudaFuncGetAttributes(cudaFuncAttributes attr,
                                        java.lang.String func)
Find out attributes for a given function.
template<class T >
cudaError_t cudaFuncGetAttributes ( struct cudaFuncAttributes *  attr,
T *  entry  
)

This function obtains the attributes of a function specified via entry. The parameter entry can either be a pointer to a function that executes on the device, or it can be a character string specifying the fully-decorated (C++) name of a function that executes on the device. The parameter specified by entry must be declared as a __global__ function. The fetched attributes are placed in attr. If the specified function does not exist, then cudaErrorInvalidDeviceFunction is returned.

Returns:
cudaSuccess, cudaErrorInitializationError, cudaErrorInvalidDeviceFunction
See Also:
cudaConfigureCall(jcuda.runtime.dim3, jcuda.runtime.dim3, long, jcuda.runtime.cudaStream_t), cudaFuncGetAttributes(jcuda.runtime.cudaFuncAttributes, java.lang.String), cudaLaunch(java.lang.String), cudaSetupArgument(jcuda.Pointer, long, long)

cudaLaunch

public static int cudaLaunch(java.lang.String symbol)
Launches a device function.
template<class T >
cudaError_t cudaLaunch ( T *  entry  ) 

Launches the function entry on the device. The parameter entry can either be a function that executes on the device, or it can be a character string, naming a function that executes on the device. The parameter specified by entry must be declared as a __global__ function. cudaLaunch() must be preceded by a call to cudaConfigureCall() since it pops the data that was pushed by cudaConfigureCall() from the execution stack.

Returns:
cudaSuccess, cudaErrorInvalidDeviceFunction, cudaErrorInvalidConfiguration, cudaErrorLaunchFailure, cudaErrorPriorLaunchFailure, cudaErrorLaunchTimeout, cudaErrorLaunchOutOfResources, cudaErrorSharedObjectSymbolNotFound, cudaErrorSharedObjectInitFailed
See Also:
cudaConfigureCall(jcuda.runtime.dim3, jcuda.runtime.dim3, long, jcuda.runtime.cudaStream_t), cudaFuncGetAttributes(jcuda.runtime.cudaFuncAttributes, java.lang.String), cudaLaunch(java.lang.String), cudaSetupArgument(jcuda.Pointer, long, long)

cudaGLSetGLDevice

public static int cudaGLSetGLDevice(int device)
Sets the CUDA device for use with OpenGL interoperability.
cudaError_t cudaGLSetGLDevice ( int  device  ) 

Records device as the device on which the active host thread executes the device code. Records the thread as using OpenGL interoperability. If the host thread has already initialized the CUDA runtime by calling non-device management runtime functions or if there exists a CUDA driver context active on the host thread, then this call returns cudaErrorSetOnActiveProcess.

Returns:
cudaSuccess, cudaErrorInvalidDevice, cudaErrorSetOnActiveProcess
See Also:
cudaGLRegisterBufferObject(int), cudaGLMapBufferObject(jcuda.Pointer, int), cudaGLUnmapBufferObject(int), cudaGLUnregisterBufferObject(int), cudaGLMapBufferObjectAsync(jcuda.Pointer, int, jcuda.runtime.cudaStream_t), cudaGLUnmapBufferObjectAsync(int, jcuda.runtime.cudaStream_t)

cudaGraphicsGLRegisterImage

public static int cudaGraphicsGLRegisterImage(cudaGraphicsResource resource,
                                              int image,
                                              int target,
                                              int Flags)
Register an OpenGL texture or renderbuffer object.
cudaError_t cudaGraphicsGLRegisterImage ( struct cudaGraphicsResource **  resource,
GLuint  image,
GLenum  target,
unsigned int  flags  
)

Registers the texture or renderbuffer object specified by image for access by CUDA. target must match the type of the object. A handle to the registered object is returned as resource. The map flags flags specify the intended usage, as follows:

  • cudaGraphicsMapFlagsNone: Specifies no hints about how this resource will be used. It is therefore assumed that this resource will be read from and written to by CUDA. This is the default value.
  • cudaGraphicsMapFlagsReadOnly: Specifies that CUDA will not write to this resource.
  • cudaGraphicsMapFlagsWriteDiscard: Specifies that CUDA will not read from this resource and will write over the entire contents of the resource, so none of the data previously stored in the resource will be preserved.

The following image classes are currently disallowed:

  • Textures with borders
  • Multisampled renderbuffers

Returns:
cudaSuccess, cudaErrorInvalidDevice, cudaErrorInvalidValue, cudaErrorInvalidResourceHandle, cudaErrorUnknown
See Also:
cudaGLSetGLDevice(int), cudaGraphicsMapResources(int, jcuda.runtime.cudaGraphicsResource[], jcuda.runtime.cudaStream_t), cudaGraphicsSubResourceGetMappedArray(jcuda.runtime.cudaArray, jcuda.runtime.cudaGraphicsResource, int, int)

cudaGraphicsGLRegisterBuffer

public static int cudaGraphicsGLRegisterBuffer(cudaGraphicsResource resource,
                                               int buffer,
                                               int Flags)
Registers an OpenGL buffer object.
cudaError_t cudaGraphicsGLRegisterBuffer ( struct cudaGraphicsResource **  resource,
GLuint  buffer,
unsigned int  flags  
)

Registers the buffer object specified by buffer for access by CUDA. A handle to the registered object is returned as resource. The map flags flags specify the intended usage, as follows:

  • cudaGraphicsMapFlagsNone: Specifies no hints about how this resource will be used. It is therefore assumed that this resource will be read from and written to by CUDA. This is the default value.
  • cudaGraphicsMapFlagsReadOnly: Specifies that CUDA will not write to this resource.
  • cudaGraphicsMapFlagsWriteDiscard: Specifies that CUDA will not read from this resource and will write over the entire contents of the resource, so none of the data previously stored in the resource will be preserved.

Returns:
cudaSuccess, cudaErrorInvalidDevice, cudaErrorInvalidValue, cudaErrorInvalidResourceHandle, cudaErrorUnknown
See Also:
cudaGraphicsUnregisterResource(jcuda.runtime.cudaGraphicsResource), cudaGraphicsMapResources(int, jcuda.runtime.cudaGraphicsResource[], jcuda.runtime.cudaStream_t), cudaGraphicsResourceGetMappedPointer(jcuda.Pointer, long[], jcuda.runtime.cudaGraphicsResource)

cudaGLRegisterBufferObject

public static int cudaGLRegisterBufferObject(int bufObj)
Registers a buffer object for access by CUDA.
cudaError_t cudaGLRegisterBufferObject ( GLuint  bufObj  ) 

Deprecated:
This function is deprecated as of Cuda 3.0.
Registers the buffer object of ID bufObj for access by CUDA. This function must be called before CUDA can map the buffer object. The OpenGL context used to create the buffer, or another context from the same share group, must be bound to the current thread when this is called.

Returns:
cudaSuccess, cudaErrorInitializationError
See Also:
cudaGraphicsGLRegisterBuffer(jcuda.runtime.cudaGraphicsResource, int, int)

cudaGLMapBufferObject

public static int cudaGLMapBufferObject(Pointer devPtr,
                                        int bufObj)
Maps a buffer object for access by CUDA.
cudaError_t cudaGLMapBufferObject ( void **  devPtr,
GLuint  bufObj  
)

Deprecated:
This function is deprecated as of Cuda 3.0.
Maps the buffer object of ID bufObj into the address space of CUDA and returns in *devPtr the base pointer of the resulting mapping. The buffer must have previously been registered by calling cudaGLRegisterBufferObject(). While a buffer is mapped by CUDA, any OpenGL operation which references the buffer will result in undefined behavior. The OpenGL context used to create the buffer, or another context from the same share group, must be bound to the current thread when this is called.

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

Returns:
cudaSuccess, cudaErrorMapBufferObjectFailed
See Also:
cudaGraphicsMapResources(int, jcuda.runtime.cudaGraphicsResource[], jcuda.runtime.cudaStream_t)

cudaGLUnmapBufferObject

public static int cudaGLUnmapBufferObject(int bufObj)
Unmaps a buffer object for access by CUDA.
cudaError_t cudaGLUnmapBufferObject ( GLuint  bufObj  ) 

Deprecated:
This function is deprecated as of Cuda 3.0.
Unmaps the buffer object of ID bufObj for access by CUDA. When a buffer is unmapped, the base address returned by cudaGLMapBufferObject() is invalid and subsequent references to the address result in undefined behavior. The OpenGL context used to create the buffer, or another context from the same share group, must be bound to the current thread when this is called.

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

Returns:
cudaSuccess, cudaErrorInvalidDevicePointer, cudaErrorUnmapBufferObjectFailed
See Also:
cudaGraphicsUnmapResources(int, jcuda.runtime.cudaGraphicsResource[], jcuda.runtime.cudaStream_t)

cudaGLUnregisterBufferObject

public static int cudaGLUnregisterBufferObject(int bufObj)
Unregisters a buffer object for access by CUDA.
cudaError_t cudaGLUnregisterBufferObject ( GLuint  bufObj  ) 

Deprecated:
This function is deprecated as of Cuda 3.0.
Unregisters the buffer object of ID bufObj for access by CUDA and releases any CUDA resources associated with the buffer. Once a buffer is unregistered, it may no longer be mapped by CUDA. The GL context used to create the buffer, or another context from the same share group, must be bound to the current thread when this is called.

Returns:
cudaSuccess
See Also:
cudaGraphicsUnregisterResource(jcuda.runtime.cudaGraphicsResource)

cudaGLSetBufferObjectMapFlags

public static int cudaGLSetBufferObjectMapFlags(int bufObj,
                                                int flags)
Set usage flags for mapping an OpenGL buffer.
cudaError_t cudaGLSetBufferObjectMapFlags ( GLuint  bufObj,
unsigned int  flags  
)

Deprecated:
This function is deprecated as of Cuda 3.0.
Set flags for mapping the OpenGL buffer bufObj

Changes to flags will take effect the next time bufObj is mapped. The flags argument may be any of the following:

  • cudaGLMapFlagsNone: Specifies no hints about how this buffer will be used. It is therefore assumed that this buffer will be read from and written to by CUDA kernels. This is the default value.
  • cudaGLMapFlagsReadOnly: Specifies that CUDA kernels which access this buffer will not write to the buffer.
  • cudaGLMapFlagsWriteDiscard: Specifies that CUDA kernels which access this buffer will not read from the buffer and will write over the entire contents of the buffer, so none of the data previously stored in the buffer will be preserved.

If bufObj has not been registered for use with CUDA, then cudaErrorInvalidResourceHandle is returned. If bufObj is presently mapped for access by CUDA, then cudaErrorUnknown is returned.

Returns:
cudaSuccess, cudaErrorInvalidValue, cudaErrorInvalidResourceHandle, cudaErrorUnknown
See Also:
cudaGraphicsResourceSetMapFlags(jcuda.runtime.cudaGraphicsResource, int)

cudaGLMapBufferObjectAsync

public static int cudaGLMapBufferObjectAsync(Pointer devPtr,
                                             int bufObj,
                                             cudaStream_t stream)
Maps a buffer object for access by CUDA.
cudaError_t cudaGLMapBufferObjectAsync ( void **  devPtr,
GLuint  bufObj,
cudaStream_t  stream  
)

Deprecated:
This function is deprecated as of Cuda 3.0.
Maps the buffer object of ID bufObj into the address space of CUDA and returns in *devPtr the base pointer of the resulting mapping. The buffer must have previously been registered by calling cudaGLRegisterBufferObject(). While a buffer is mapped by CUDA, any OpenGL operation which references the buffer will result in undefined behavior. The OpenGL context used to create the buffer, or another context from the same share group, must be bound to the current thread when this is called.

Stream /p stream is synchronized with the current GL context.

Returns:
cudaSuccess, cudaErrorMapBufferObjectFailed
See Also:
cudaGraphicsMapResources(int, jcuda.runtime.cudaGraphicsResource[], jcuda.runtime.cudaStream_t)

cudaGLUnmapBufferObjectAsync

public static int cudaGLUnmapBufferObjectAsync(int bufObj,
                                               cudaStream_t stream)
Unmaps a buffer object for access by CUDA.
cudaError_t cudaGLUnmapBufferObjectAsync ( GLuint  bufObj,
cudaStream_t  stream  
)

Deprecated:
This function is deprecated as of Cuda 3.0.
Unmaps the buffer object of ID bufObj for access by CUDA. When a buffer is unmapped, the base address returned by cudaGLMapBufferObject() is invalid and subsequent references to the address result in undefined behavior. The OpenGL context used to create the buffer, or another context from the same share group, must be bound to the current thread when this is called.

Stream /p stream is synchronized with the current GL context.

Returns:
cudaSuccess, cudaErrorInvalidDevicePointer, cudaErrorUnmapBufferObjectFailed
See Also:
cudaGraphicsUnmapResources(int, jcuda.runtime.cudaGraphicsResource[], jcuda.runtime.cudaStream_t)

cudaDriverGetVersion

public static int cudaDriverGetVersion(int[] driverVersion)
Returns the CUDA driver version.
cudaError_t cudaDriverGetVersion ( int *  driverVersion  ) 

Returns in *driverVersion the version number of the installed CUDA driver. If no driver is installed, then 0 is returned as the driver version (via driverVersion). This function automatically returns cudaErrorInvalidValue if the driverVersion argument is NULL.

Returns:
cudaSuccess, cudaErrorInvalidValue
See Also:
cudaRuntimeGetVersion(int[])

cudaRuntimeGetVersion

public static int cudaRuntimeGetVersion(int[] runtimeVersion)
Returns the CUDA Runtime version.
cudaError_t cudaRuntimeGetVersion ( int *  runtimeVersion  ) 

Returns in *runtimeVersion the version number of the installed CUDA Runtime. This function automatically returns cudaErrorInvalidValue if the runtimeVersion argument is NULL.

Returns:
cudaSuccess, cudaErrorInvalidValue
See Also:
cudaDriverGetVersion(int[])

cudaGraphicsUnregisterResource

public static int cudaGraphicsUnregisterResource(cudaGraphicsResource resource)
Unregisters a graphics resource for access by CUDA.
cudaError_t cudaGraphicsUnregisterResource ( struct cudaGraphicsResource *  resource  ) 

Unregisters the graphics resource resource so it is not accessible by CUDA unless registered again.

If resource is invalid then cudaErrorInvalidResourceHandle is returned.

Returns:
cudaSuccess, cudaErrorInvalidResourceHandle, cudaErrorUnknown
See Also:
cudaGraphicsGLRegisterBuffer(jcuda.runtime.cudaGraphicsResource, int, int), cudaGraphicsGLRegisterImage(jcuda.runtime.cudaGraphicsResource, int, int, int)

cudaGraphicsResourceSetMapFlags

public static int cudaGraphicsResourceSetMapFlags(cudaGraphicsResource resource,
                                                  int flags)
Set usage flags for mapping a graphics resource.
cudaError_t cudaGraphicsResourceSetMapFlags ( struct cudaGraphicsResource *  resource,
unsigned int  flags  
)

Set flags for mapping the graphics resource resource.

Changes to flags will take effect the next time resource is mapped. The flags argument may be any of the following:

  • cudaGraphicsMapFlagsNone: Specifies no hints about how resource will be used. It is therefore assumed that CUDA may read from or write to resource.
  • cudaGraphicsMapFlagsReadOnly: Specifies that CUDA will not write to resource.
  • cudaGraphicsMapFlagsWriteDiscard: Specifies CUDA will not read from resource and will write over the entire contents of resource, so none of the data previously stored in resource will be preserved.

If resource is presently mapped for access by CUDA then cudaErrorUnknown is returned. If flags is not one of the above values then cudaErrorInvalidValue is returned.

Returns:
cudaSuccess, cudaErrorInvalidValue, cudaErrorInvalidResourceHandle, cudaErrorUnknown,
See Also:
cudaGraphicsMapResources(int, jcuda.runtime.cudaGraphicsResource[], jcuda.runtime.cudaStream_t)

cudaGraphicsMapResources

public static int cudaGraphicsMapResources(int count,
                                           cudaGraphicsResource[] resources,
                                           cudaStream_t stream)
Map graphics resources for access by CUDA.
cudaError_t cudaGraphicsMapResources ( int  count,
struct cudaGraphicsResource **  resources,
cudaStream_t  stream  
)

Maps the count graphics resources in resources for access by CUDA.

The resources in resources may be accessed by CUDA until they are unmapped. The graphics API from which resources were registered should not access any resources while they are mapped by CUDA. If an application does so, the results are undefined.

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

If resources contains any duplicate entries then cudaErrorInvalidResourceHandle is returned. If any of resources are presently mapped for access by CUDA then cudaErrorUnknown is returned.

Returns:
cudaSuccess, cudaErrorInvalidResourceHandle, cudaErrorUnknown
See Also:
cudaGraphicsResourceGetMappedPointer(jcuda.Pointer, long[], jcuda.runtime.cudaGraphicsResource)

cudaGraphicsUnmapResources

public static int cudaGraphicsUnmapResources(int count,
                                             cudaGraphicsResource[] resources,
                                             cudaStream_t stream)
Unmap graphics resources.
cudaError_t cudaGraphicsUnmapResources ( int  count,
struct cudaGraphicsResource **  resources,
cudaStream_t  stream  
)

Unmaps the count graphics resources in resources.

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

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

If resources contains any duplicate entries then cudaErrorInvalidResourceHandle is returned. If any of resources are not presently mapped for access by Cuda then cudaErrorUnknown is returned.

Returns:
cudaSuccess, cudaErrorInvalidResourceHandle, cudaErrorUnknown
See Also:
cudaGraphicsMapResources(int, jcuda.runtime.cudaGraphicsResource[], jcuda.runtime.cudaStream_t)

cudaGraphicsResourceGetMappedPointer

public static int cudaGraphicsResourceGetMappedPointer(Pointer devPtr,
                                                       long[] size,
                                                       cudaGraphicsResource resource)
Get an device pointer through which to access a mapped graphics resource.
cudaError_t cudaGraphicsResourceGetMappedPointer ( void **  devPtr,
size_t *  size,
struct cudaGraphicsResource *  resource  
)

Returns in *devPtr a pointer through which the mapped graphics resource resource may be accessed. Returns in *size the size of the memory in bytes which may be accessed from that pointer. The value set in devPtr may change every time that resource is mapped.

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

Returns:
cudaSuccess, cudaErrorInvalidValue, cudaErrorInvalidResourceHandle, cudaErrorUnknown
See Also:
cudaGraphicsMapResources(int, jcuda.runtime.cudaGraphicsResource[], jcuda.runtime.cudaStream_t), cudaGraphicsSubResourceGetMappedArray(jcuda.runtime.cudaArray, jcuda.runtime.cudaGraphicsResource, int, int)

cudaGraphicsSubResourceGetMappedArray

public static int cudaGraphicsSubResourceGetMappedArray(cudaArray arrayPtr,
                                                        cudaGraphicsResource resource,
                                                        int arrayIndex,
                                                        int mipLevel)
Get an array through which to access a subresource of a mapped graphics resource.
cudaError_t cudaGraphicsSubResourceGetMappedArray ( cudaArray **  array,
struct cudaGraphicsResource *  resource,
unsigned int  arrayIndex,
unsigned int  mipLevel  
)

Returns in *array an array through which the subresource of the mapped graphics resource resource which corresponds to array index arrayIndex and mipmap level mipLevel may be accessed. The value set in array may change every time that resource is mapped.

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

Returns:
cudaSuccess, cudaErrorInvalidValue, cudaErrorInvalidResourceHandle, cudaErrorUnknown
See Also:
cudaGraphicsResourceGetMappedPointer(jcuda.Pointer, long[], jcuda.runtime.cudaGraphicsResource)