public class cudaError extends Object
Modifier and Type | Field and Description |
---|---|
static int |
cudaErrorAddressOfConstant
Deprecated.
This error return is deprecated as of CUDA 3.1. Variables in constant
memory may now have their address taken by the runtime via
JCuda.cudaGetSymbolAddress(jcuda.Pointer, java.lang.String) . |
static int |
cudaErrorAlreadyAcquired
This indicates that a resource has already been acquired.
|
static int |
cudaErrorAlreadyMapped
This indicates that the resource is already mapped.
|
static int |
cudaErrorApiFailureBase
Deprecated.
This error return is deprecated as of CUDA 4.1.
|
static int |
cudaErrorArrayIsMapped
This indicates that the specified array is currently mapped and thus
cannot be destroyed.
|
static int |
cudaErrorAssert
An assert triggered in device code during kernel execution.
|
static int |
cudaErrorCapturedEvent
The operation is not permitted on an event which was last recorded in a
capturing stream.
|
static int |
cudaErrorCompatNotSupportedOnDevice
This error indicates that the system was upgraded to run with forward compatibility
but the visible hardware detected by CUDA does not support this configuration.
|
static int |
cudaErrorContextIsDestroyed
This error indicates that the context current to the calling thread
has been destroyed using ::cuCtxDestroy, or is a primary context which
has not yet been initialized.
|
static int |
cudaErrorCooperativeLaunchTooLarge
This error indicates that the number of blocks launched per grid for a kernel that was
launched via either
JCuda#cudaLaunchCooperativeKernel or JCuda#cudaLaunchCooperativeKernelMultiDevice
exceeds the maximum number of blocks as allowed by ::cudaOccupancyMaxActiveBlocksPerMultiprocessor
or ::cudaOccupancyMaxActiveBlocksPerMultiprocessorWithFlags times the number of multiprocessors
as specified by the device attribute ::cudaDevAttrMultiProcessorCount. |
static int |
cudaErrorCudartUnloading
This indicates that a CUDA Runtime API call cannot be executed because
it is being called during process shut down, at a point in time after
CUDA driver has been unloaded.
|
static int |
cudaErrorDeviceAlreadyInUse
This indicates that a call tried to access an exclusive-thread device that
is already in use by a different thread.
|
static int |
cudaErrorDevicesUnavailable
This indicates that all CUDA devices are busy or unavailable at the current
time.
|
static int |
cudaErrorDeviceUninitialized
This most frequently indicates that there is no context bound to the
current thread.
|
static int |
cudaErrorDeviceUninitilialized
Deprecated.
As of CUDA 10.2, replaced by "cudaErrorDeviceUninitialized"
|
static int |
cudaErrorDuplicateSurfaceName
This indicates that multiple surfaces (across separate CUDA source
files in the application) share the same string name.
|
static int |
cudaErrorDuplicateTextureName
This indicates that multiple textures (across separate CUDA source
files in the application) share the same string name.
|
static int |
cudaErrorDuplicateVariableName
This indicates that multiple global or constant variables (across separate
CUDA source files in the application) share the same string name.
|
static int |
cudaErrorECCUncorrectable
This indicates that an uncorrectable ECC error was detected during
execution.
|
static int |
cudaErrorFileNotFound
This indicates that the file specified was not found.
|
static int |
cudaErrorGraphExecUpdateFailure
This error indicates that the graph update was not performed because it included
changes which violated constraints specific to instantiated graph update.
|
static int |
cudaErrorHardwareStackError
Device encountered an error in the call stack during kernel execution,
possibly due to stack corruption or exceeding the stack size limit.
|
static int |
cudaErrorHostMemoryAlreadyRegistered
This error indicates that the memory range passed to
JCuda.cudaHostRegister(jcuda.Pointer, long, int)
has already been registered. |
static int |
cudaErrorHostMemoryNotRegistered
This error indicates that the pointer passed to
JCuda.cudaHostUnregister(jcuda.Pointer)
does not correspond to any currently registered memory region. |
static int |
cudaErrorIllegalAddress
The device encountered a load or store instruction on an invalid memory address.
|
static int |
cudaErrorIllegalInstruction
The device encountered an illegal instruction during kernel execution
This leaves the process in an inconsistent state and any further CUDA work
will return the same error.
|
static int |
cudaErrorIllegalState
This indicates that a resource required by the API call is not in a
valid state to perform the requested operation.
|
static int |
cudaErrorIncompatibleDriverContext
This indicates that the current context is not compatible with this
the CUDA Runtime.
|
static int |
cudaErrorInitializationError
The API call failed because the CUDA driver and runtime could not be
initialized.
|
static int |
cudaErrorInsufficientDriver
This indicates that the installed NVIDIA CUDA driver is older than the
CUDA runtime library.
|
static int |
cudaErrorInvalidAddressSpace
While executing a kernel, the device encountered an instruction
which can only operate on memory locations in certain address spaces
(global, shared, or local), but was supplied a memory address not
belonging to an allowed address space.
|
static int |
cudaErrorInvalidChannelDescriptor
This indicates that the channel descriptor passed to the API call is not
valid.
|
static int |
cudaErrorInvalidConfiguration
This indicates that a kernel launch is requesting resources that can
never be satisfied by the current device.
|
static int |
cudaErrorInvalidDevice
This indicates that the device ordinal supplied by the user does not
correspond to a valid CUDA device.
|
static int |
cudaErrorInvalidDeviceFunction
The requested device function does not exist or is not compiled for the
proper device architecture.
|
static int |
cudaErrorInvalidDevicePointer
Deprecated.
This error return is deprecated as of CUDA 10.1.
|
static int |
cudaErrorInvalidFilterSetting
This indicates that a non-float texture was being accessed with linear
filtering.
|
static int |
cudaErrorInvalidGraphicsContext
This indicates an error with the OpenGL or DirectX context.
|
static int |
cudaErrorInvalidHostPointer
Deprecated.
This error return is deprecated as of CUDA 10.1.
|
static int |
cudaErrorInvalidKernelImage
This indicates that the device kernel image is invalid.
|
static int |
cudaErrorInvalidMemcpyDirection
This indicates that the direction of the memcpy passed to the API call is
not one of the types specified by ::cudaMemcpyKind.
|
static int |
cudaErrorInvalidNormSetting
This indicates that an attempt was made to read a non-float texture as a
normalized float.
|
static int |
cudaErrorInvalidPc
The device encountered an invalid program counter.
|
static int |
cudaErrorInvalidPitchValue
This indicates that one or more of the pitch-related parameters passed
to the API call is not within the acceptable range for pitch.
|
static int |
cudaErrorInvalidPtx
A PTX compilation failed.
|
static int |
cudaErrorInvalidResourceHandle
This indicates that a resource handle passed to the API call was not
valid.
|
static int |
cudaErrorInvalidSource
This indicates that the device kernel source is invalid.
|
static int |
cudaErrorInvalidSurface
This indicates that the surface passed to the API call is not a valid
surface.
|
static int |
cudaErrorInvalidSymbol
This indicates that the symbol name/identifier passed to the API call
is not a valid name or identifier.
|
static int |
cudaErrorInvalidTexture
This indicates that the texture passed to the API call is not a valid
texture.
|
static int |
cudaErrorInvalidTextureBinding
This indicates that the texture binding is not valid.
|
static int |
cudaErrorInvalidValue
This indicates that one or more of the parameters passed to the API call
is not within an acceptable range of values.
|
static int |
cudaErrorJitCompilerNotFound
This indicates that the PTX JIT compiler library was not found.
|
static int |
cudaErrorLaunchFailure
An exception occurred on the device while executing a kernel.
|
static int |
cudaErrorLaunchFileScopedSurf
This error indicates that a grid launch did not occur because the kernel
uses file-scoped surfaces which are unsupported by the device runtime.
|
static int |
cudaErrorLaunchFileScopedTex
This error indicates that a grid launch did not occur because the kernel
uses file-scoped textures which are unsupported by the device runtime.
|
static int |
cudaErrorLaunchIncompatibleTexturing
This error indicates a kernel launch that uses an incompatible texturing
mode.
|
static int |
cudaErrorLaunchMaxDepthExceeded
This error indicates that a device runtime grid launch did not occur
because the depth of the child grid would exceed the maximum supported
number of nested grid launches.
|
static int |
cudaErrorLaunchOutOfResources
This indicates that a launch did not occur because it did not have
appropriate resources.
|
static int |
cudaErrorLaunchPendingCountExceeded
This error indicates that a device runtime grid launch failed because
the launch would exceed the limit ::cudaLimitDevRuntimePendingLaunchCount.
|
static int |
cudaErrorLaunchTimeout
This indicates that the device kernel took too long to execute.
|
static int |
cudaErrorMapBufferObjectFailed
This indicates that the buffer object could not be mapped.
|
static int |
cudaErrorMemoryAllocation
The API call failed because it was unable to allocate enough memory to
perform the requested operation.
|
static int |
cudaErrorMemoryValueTooLarge
Deprecated.
This error return is deprecated as of CUDA 3.1. Device emulation mode was
removed with the CUDA 3.1 release.
|
static int |
cudaErrorMisalignedAddress
The device encountered a load or store instruction
on a memory address which is not aligned.
|
static int |
cudaErrorMissingConfiguration
The device function being invoked (usually via
JCuda#cudaLaunchKernel ) was not
previously configured via the JCuda.cudaConfigureCall(jcuda.runtime.dim3, jcuda.runtime.dim3, long, jcuda.runtime.cudaStream_t) function. |
static int |
cudaErrorMixedDeviceExecution
Deprecated.
This error return is deprecated as of CUDA 3.1. Device emulation mode was
removed with the CUDA 3.1 release.
|
static int |
cudaErrorNoDevice
This indicates that no CUDA-capable devices were detected by the installed
CUDA driver.
|
static int |
cudaErrorNoKernelImageForDevice
This indicates that there is no kernel image available that is suitable
for the device.
|
static int |
cudaErrorNotMapped
This indicates that a resource is not mapped.
|
static int |
cudaErrorNotMappedAsArray
This indicates that a mapped resource is not available for access as an
array.
|
static int |
cudaErrorNotMappedAsPointer
This indicates that a mapped resource is not available for access as a
pointer.
|
static int |
cudaErrorNotPermitted
This error indicates the attempted operation is not permitted.
|
static int |
cudaErrorNotReady
This indicates that asynchronous operations issued previously have not
completed yet.
|
static int |
cudaErrorNotSupported
This error indicates the attempted operation is not supported
on the current system or device.
|
static int |
cudaErrorNotYetImplemented
Deprecated.
This error return is deprecated as of CUDA 4.1.
|
static int |
cudaErrorNvlinkUncorrectable
This indicates that an uncorrectable NVLink error was detected during the
execution.
|
static int |
cudaErrorOperatingSystem
This error indicates that an OS call failed.
|
static int |
cudaErrorPeerAccessAlreadyEnabled
This error indicates that a call to
JCuda.cudaDeviceEnablePeerAccess(int, int) is
trying to re-enable peer addressing on from a context which has already
had peer addressing enabled. |
static int |
cudaErrorPeerAccessNotEnabled
This error indicates that
JCuda.cudaDeviceDisablePeerAccess(int) is trying to
disable peer addressing which has not been enabled yet via
JCuda.cudaDeviceEnablePeerAccess(int, int) . |
static int |
cudaErrorPeerAccessUnsupported
This error indicates that P2P access is not supported across the given
devices.
|
static int |
cudaErrorPriorLaunchFailure
Deprecated.
This error return is deprecated as of CUDA 3.1. Device emulation mode was
removed with the CUDA 3.1 release.
|
static int |
cudaErrorProfilerAlreadyStarted
Deprecated.
This error return is deprecated as of CUDA 5.0. It is no longer an error
to call cudaProfilerStart() when profiling is already enabled.
|
static int |
cudaErrorProfilerAlreadyStopped
Deprecated.
This error return is deprecated as of CUDA 5.0. It is no longer an error
to call cudaProfilerStop() when profiling is already disabled.
|
static int |
cudaErrorProfilerDisabled
This indicates profiler is not initialized for this run.
|
static int |
cudaErrorProfilerNotInitialized
Deprecated.
This error return is deprecated as of CUDA 5.0. It is no longer an error
to attempt to enable/disable the profiling via
JCuda.cudaProfilerStart() or
JCuda.cudaProfilerStop() without initialization. |
static int |
cudaErrorSetOnActiveProcess
This indicates that the user has called
JCuda.cudaSetValidDevices(int[], int) ,
JCuda.cudaSetDeviceFlags(int) , JCuda#cudaD3D9SetDirect3DDevice ,
JCuda#cudaD3D10SetDirect3DDevice , JCuda#cudaD3D11SetDirect3DDevice , or
JCuda#cudaVDPAUSetVDPAUDevice after initializing the CUDA runtime by
calling non-device management operations (allocating memory and
launching kernels are examples of non-device management operations). |
static int |
cudaErrorSharedObjectInitFailed
This indicates that initialization of a shared object failed.
|
static int |
cudaErrorSharedObjectSymbolNotFound
This indicates that a link to a shared object failed to resolve.
|
static int |
cudaErrorStartupFailure
This indicates an internal startup failure in the CUDA runtime.
|
static int |
cudaErrorStreamCaptureImplicit
The operation would have resulted in a disallowed implicit dependency on
a current capture sequence from cudaStreamLegacy.
|
static int |
cudaErrorStreamCaptureInvalidated
The current capture sequence on the stream has been invalidated due to
a previous error.
|
static int |
cudaErrorStreamCaptureIsolation
A dependency would have been created which crosses the capture sequence
boundary.
|
static int |
cudaErrorStreamCaptureMerge
The operation would have resulted in a merge of two independent capture
sequences.
|
static int |
cudaErrorStreamCaptureUnjoined
The capture sequence contains a fork that was not joined to the primary
stream.
|
static int |
cudaErrorStreamCaptureUnmatched
The capture was not initiated in this stream.
|
static int |
cudaErrorStreamCaptureUnsupported
The operation is not permitted when the stream is capturing.
|
static int |
cudaErrorStreamCaptureWrongThread
A stream capture sequence not initiated with the ::cudaStreamCaptureModeRelaxed
argument to ::cudaStreamBeginCapture was passed to ::cudaStreamEndCapture in a
different thread.
|
static int |
cudaErrorSymbolNotFound
This indicates that a named symbol was not found.
|
static int |
cudaErrorSyncDepthExceeded
This error indicates that a call to
JCuda.cudaDeviceSynchronize() made from
the device runtime failed because the call was made at grid depth greater
than than either the default (2 levels of grids) or user specified device
limit ::cudaLimitDevRuntimeSyncDepth. |
static int |
cudaErrorSynchronizationError
Deprecated.
This error return is deprecated as of CUDA 3.1. Device emulation mode was
removed with the CUDA 3.1 release.
|
static int |
cudaErrorSystemDriverMismatch
This error indicates that there is a mismatch between the versions of
the display driver and the CUDA driver.
|
static int |
cudaErrorSystemNotReady
This error indicates that the system is not yet ready to start any CUDA
work.
|
static int |
cudaErrorTextureFetchFailed
Deprecated.
This error return is deprecated as of CUDA 3.1. Device emulation mode was
removed with the CUDA 3.1 release.
|
static int |
cudaErrorTextureNotBound
Deprecated.
This error return is deprecated as of CUDA 3.1. Device emulation mode was
removed with the CUDA 3.1 release.
|
static int |
cudaErrorTimeout
This indicates that the wait operation has timed out.
|
static int |
cudaErrorTooManyPeers
This error indicates that the hardware resources required to enable
peer access have been exhausted for one or more of the devices
passed to
JCuda#cudaEnablePeerAccess . |
static int |
cudaErrorUnknown
This indicates that an unknown internal error has occurred.
|
static int |
cudaErrorUnmapBufferObjectFailed
This indicates that the buffer object could not be unmapped.
|
static int |
cudaErrorUnsupportedLimit
This indicates that the ::cudaLimit passed to the API call is not
supported by the active device.
|
static int |
cudaSuccess
The API call returned with no errors.
|
static int |
jcudaInternalError
An internal JCuda error occurred
|
Modifier and Type | Method and Description |
---|---|
static String |
stringFor(int n)
Returns a string representation of the given constant
|
public static final int cudaSuccess
JCuda#cudaEventQuery()
and JCuda#cudaStreamQuery()
).public static final int cudaErrorInvalidValue
public static final int cudaErrorMemoryAllocation
public static final int cudaErrorInitializationError
public static final int cudaErrorCudartUnloading
public static final int cudaErrorProfilerDisabled
public static final int cudaErrorProfilerNotInitialized
JCuda.cudaProfilerStart()
or
JCuda.cudaProfilerStop()
without initialization.public static final int cudaErrorProfilerAlreadyStarted
public static final int cudaErrorProfilerAlreadyStopped
public static final int cudaErrorInvalidConfiguration
JCuda#cudaDeviceProp
for more
device limitations.public static final int cudaErrorInvalidPitchValue
public static final int cudaErrorInvalidSymbol
public static final int cudaErrorInvalidHostPointer
public static final int cudaErrorInvalidDevicePointer
public static final int cudaErrorInvalidTexture
public static final int cudaErrorInvalidTextureBinding
JCuda.cudaGetTextureAlignmentOffset(long[], jcuda.runtime.textureReference)
with an unbound texture.public static final int cudaErrorInvalidChannelDescriptor
public static final int cudaErrorInvalidMemcpyDirection
public static final int cudaErrorAddressOfConstant
JCuda.cudaGetSymbolAddress(jcuda.Pointer, java.lang.String)
.public static final int cudaErrorTextureFetchFailed
public static final int cudaErrorTextureNotBound
public static final int cudaErrorSynchronizationError
public static final int cudaErrorInvalidFilterSetting
public static final int cudaErrorInvalidNormSetting
public static final int cudaErrorMixedDeviceExecution
public static final int cudaErrorNotYetImplemented
public static final int cudaErrorMemoryValueTooLarge
public static final int cudaErrorInsufficientDriver
public static final int cudaErrorInvalidSurface
public static final int cudaErrorDuplicateVariableName
public static final int cudaErrorDuplicateTextureName
public static final int cudaErrorDuplicateSurfaceName
public static final int cudaErrorDevicesUnavailable
public static final int cudaErrorIncompatibleDriverContext
public static final int cudaErrorMissingConfiguration
JCuda#cudaLaunchKernel
) was not
previously configured via the JCuda.cudaConfigureCall(jcuda.runtime.dim3, jcuda.runtime.dim3, long, jcuda.runtime.cudaStream_t)
function.public static final int cudaErrorPriorLaunchFailure
public static final int cudaErrorLaunchMaxDepthExceeded
public static final int cudaErrorLaunchFileScopedTex
public static final int cudaErrorLaunchFileScopedSurf
public static final int cudaErrorSyncDepthExceeded
JCuda.cudaDeviceSynchronize()
made from
the device runtime failed because the call was made at grid depth greater
than than either the default (2 levels of grids) or user specified device
limit ::cudaLimitDevRuntimeSyncDepth. To be able to synchronize on
launched grids at a greater depth successfully, the maximum nested
depth at which JCuda.cudaDeviceSynchronize()
will be called must be specified
with the ::cudaLimitDevRuntimeSyncDepth limit to the JCuda.cudaDeviceSetLimit(int, long)
api before the host-side launch of a kernel using the device runtime.
Keep in mind that additional levels of sync depth require the runtime
to reserve large amounts of device memory that cannot be used for
user allocations.public static final int cudaErrorLaunchPendingCountExceeded
JCuda.cudaDeviceSetLimit(int, long)
must be
called to set the ::cudaLimitDevRuntimePendingLaunchCount to be higher
than the upper bound of outstanding launches that can be issued to the
device runtime. Keep in mind that raising the limit of pending device
runtime launches will require the runtime to reserve device memory that
cannot be used for user allocations.public static final int cudaErrorInvalidDeviceFunction
public static final int cudaErrorNoDevice
public static final int cudaErrorInvalidDevice
public static final int cudaErrorStartupFailure
public static final int cudaErrorInvalidKernelImage
public static final int cudaErrorDeviceUninitialized
public static final int cudaErrorDeviceUninitilialized
public static final int cudaErrorMapBufferObjectFailed
public static final int cudaErrorUnmapBufferObjectFailed
public static final int cudaErrorArrayIsMapped
public static final int cudaErrorAlreadyMapped
public static final int cudaErrorNoKernelImageForDevice
public static final int cudaErrorAlreadyAcquired
public static final int cudaErrorNotMapped
public static final int cudaErrorNotMappedAsArray
public static final int cudaErrorNotMappedAsPointer
public static final int cudaErrorECCUncorrectable
public static final int cudaErrorUnsupportedLimit
public static final int cudaErrorDeviceAlreadyInUse
public static final int cudaErrorPeerAccessUnsupported
public static final int cudaErrorInvalidPtx
public static final int cudaErrorInvalidGraphicsContext
public static final int cudaErrorNvlinkUncorrectable
public static final int cudaErrorJitCompilerNotFound
public static final int cudaErrorInvalidSource
public static final int cudaErrorFileNotFound
public static final int cudaErrorSharedObjectSymbolNotFound
public static final int cudaErrorSharedObjectInitFailed
public static final int cudaErrorOperatingSystem
public static final int cudaErrorInvalidResourceHandle
public static final int cudaErrorIllegalState
public static final int cudaErrorSymbolNotFound
public static final int cudaErrorNotReady
JCuda.cudaEventQuery(jcuda.runtime.cudaEvent_t)
and JCuda.cudaStreamQuery(jcuda.runtime.cudaStream_t)
.public static final int cudaErrorIllegalAddress
public static final int cudaErrorLaunchOutOfResources
public static final int cudaErrorLaunchTimeout
public static final int cudaErrorLaunchIncompatibleTexturing
public static final int cudaErrorPeerAccessAlreadyEnabled
JCuda.cudaDeviceEnablePeerAccess(int, int)
is
trying to re-enable peer addressing on from a context which has already
had peer addressing enabled.public static final int cudaErrorPeerAccessNotEnabled
JCuda.cudaDeviceDisablePeerAccess(int)
is trying to
disable peer addressing which has not been enabled yet via
JCuda.cudaDeviceEnablePeerAccess(int, int)
.public static final int cudaErrorSetOnActiveProcess
JCuda.cudaSetValidDevices(int[], int)
,
JCuda.cudaSetDeviceFlags(int)
, JCuda#cudaD3D9SetDirect3DDevice
,
JCuda#cudaD3D10SetDirect3DDevice
, JCuda#cudaD3D11SetDirect3DDevice
, or
JCuda#cudaVDPAUSetVDPAUDevice
after initializing the CUDA runtime by
calling non-device management operations (allocating memory and
launching kernels are examples of non-device management operations).
This error can also be returned if using runtime/driver
interoperability and there is an existing ::CUcontext active on the
host thread.public static final int cudaErrorContextIsDestroyed
public static final int cudaErrorAssert
public static final int cudaErrorTooManyPeers
JCuda#cudaEnablePeerAccess
.public static final int cudaErrorHostMemoryAlreadyRegistered
JCuda.cudaHostRegister(jcuda.Pointer, long, int)
has already been registered.public static final int cudaErrorHostMemoryNotRegistered
JCuda.cudaHostUnregister(jcuda.Pointer)
does not correspond to any currently registered memory region.public static final int cudaErrorHardwareStackError
public static final int cudaErrorIllegalInstruction
public static final int cudaErrorMisalignedAddress
public static final int cudaErrorInvalidAddressSpace
public static final int cudaErrorInvalidPc
public static final int cudaErrorLaunchFailure
public static final int cudaErrorCooperativeLaunchTooLarge
JCuda#cudaLaunchCooperativeKernel
or JCuda#cudaLaunchCooperativeKernelMultiDevice
exceeds the maximum number of blocks as allowed by ::cudaOccupancyMaxActiveBlocksPerMultiprocessor
or ::cudaOccupancyMaxActiveBlocksPerMultiprocessorWithFlags times the number of multiprocessors
as specified by the device attribute ::cudaDevAttrMultiProcessorCount.public static final int cudaErrorNotPermitted
public static final int cudaErrorNotSupported
public static final int cudaErrorSystemNotReady
public static final int cudaErrorSystemDriverMismatch
public static final int cudaErrorCompatNotSupportedOnDevice
public static final int cudaErrorStreamCaptureUnsupported
public static final int cudaErrorStreamCaptureInvalidated
public static final int cudaErrorStreamCaptureMerge
public static final int cudaErrorStreamCaptureUnmatched
public static final int cudaErrorStreamCaptureUnjoined
public static final int cudaErrorStreamCaptureIsolation
public static final int cudaErrorStreamCaptureImplicit
public static final int cudaErrorCapturedEvent
public static final int cudaErrorStreamCaptureWrongThread
public static final int cudaErrorTimeout
public static final int cudaErrorGraphExecUpdateFailure
public static final int cudaErrorUnknown
public static final int cudaErrorApiFailureBase
public static final int jcudaInternalError
public static String stringFor(int n)
Copyright © 2020. All rights reserved.