public class cudaError
extends java.lang.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 |
cudaErrorApiFailureBase
Deprecated.
This error return is deprecated as of CUDA 4.1.
|
static int |
cudaErrorAssert
An assert triggered in device code during kernel execution.
|
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 |
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 |
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
The context cannot be used, so it must be destroyed (and a new one
should be created).
|
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
This indicates that at least one device pointer passed to the API call is
not a valid device pointer.
|
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
This indicates that at least one host pointer passed to the API call is
not a valid host pointer.
|
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 |
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 |
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 |
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.cudaLaunch(java.lang.String) ) 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 |
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 |
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 a call to
JCuda.cudaDeviceEnablePeerAccess(int, int) trying to
register memory from a context which has not had peer addressing
enabled yet via JCuda.cudaDeviceEnablePeerAccess(int, int) , or that
JCuda.cudaDeviceDisablePeerAccess(int) is trying to disable peer addressing
which has not been enabled yet. |
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
JCuda.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
JCuda.cudaProfilerStop() when profiling is already disabled. |
static int |
cudaErrorProfilerDisabled
This indicates profiler has been disabled for this run and thus runtime
APIs cannot be used to profile subsets of the program.
|
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) ,
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 |
cudaErrorSyncDepthExceeded
This error indicates that a call to ::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 |
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 |
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 ::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 java.lang.String |
stringFor(int error)
Returns the String identifying the given cudaError
|
public static final int cudaSuccess
JCuda.cudaEventQuery(jcuda.runtime.cudaEvent_t)
and JCuda.cudaStreamQuery(jcuda.runtime.cudaStream_t)
).public static final int cudaErrorMissingConfiguration
JCuda.cudaLaunch(java.lang.String)
) was not
previously configured via the JCuda.cudaConfigureCall(jcuda.runtime.dim3, jcuda.runtime.dim3, long, jcuda.runtime.cudaStream_t)
function.public static final int cudaErrorMemoryAllocation
public static final int cudaErrorInitializationError
public static final int cudaErrorLaunchFailure
JCuda.cudaThreadExit()
is called. All existing device memory allocations
are invalid and must be reconstructed if the program is to continue
using CUDA.public static final int cudaErrorPriorLaunchFailure
public static final int cudaErrorLaunchTimeout
cudaDeviceProp.kernelExecTimeoutEnabled
"kernelExecTimeoutEnabled"
for more information. The device cannot be used until JCuda.cudaThreadExit()
is called. All existing device memory allocations are invalid and must be
reconstructed if the program is to continue using CUDA.public static final int cudaErrorLaunchOutOfResources
cudaErrorInvalidConfiguration
this error usually indicates that the
user has attempted to pass too many arguments to the device kernel, or the
kernel launch specifies too many threads for the kernel's register count.public static final int cudaErrorInvalidDeviceFunction
public static final int cudaErrorInvalidConfiguration
cudaDeviceProp
for more device limitations.public static final int cudaErrorInvalidDevice
public static final int cudaErrorInvalidValue
public static final int cudaErrorInvalidPitchValue
public static final int cudaErrorInvalidSymbol
public static final int cudaErrorMapBufferObjectFailed
public static final int cudaErrorUnmapBufferObjectFailed
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
cudaChannelFormatKind
or if one of the dimensions is invalid.public static final int cudaErrorInvalidMemcpyDirection
cudaMemcpyKind
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 cudaErrorCudartUnloading
public static final int cudaErrorUnknown
public static final int cudaErrorNotYetImplemented
public static final int cudaErrorMemoryValueTooLarge
public static final int cudaErrorInvalidResourceHandle
cudaStream_t
or
cudaEvent_t
public static final int cudaErrorNotReady
cudaSuccess
which indicates completion). Calls that
may return this value include JCuda.cudaEventQuery(jcuda.runtime.cudaEvent_t)
and JCuda.cudaStreamQuery(jcuda.runtime.cudaStream_t)
.public static final int cudaErrorInsufficientDriver
public static final int cudaErrorSetOnActiveProcess
JCuda.cudaSetValidDevices(int[], int)
,
JCuda.cudaSetDeviceFlags(int)
,
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 cudaErrorInvalidSurface
public static final int cudaErrorNoDevice
public static final int cudaErrorECCUncorrectable
public static final int cudaErrorSharedObjectSymbolNotFound
public static final int cudaErrorSharedObjectInitFailed
public static final int cudaErrorUnsupportedLimit
public static final int cudaErrorDuplicateVariableName
public static final int cudaErrorDuplicateTextureName
public static final int cudaErrorDuplicateSurfaceName
public static final int cudaErrorDevicesUnavailable
cudaComputeMode.cudaComputeModeExclusive
cudaComputeMode.cudaComputeModeProhibited
. They can also
be unavailable due to memory constraints on a device that already has
active CUDA work being performed.public static final int cudaErrorInvalidKernelImage
public static final int cudaErrorNoKernelImageForDevice
public static final int cudaErrorIncompatibleDriverContext
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.cudaDeviceEnablePeerAccess(int, int)
trying to
register memory from a context which has not had peer addressing
enabled yet via JCuda.cudaDeviceEnablePeerAccess(int, int)
, or that
JCuda.cudaDeviceDisablePeerAccess(int)
is trying to disable peer addressing
which has not been enabled yet.public static final int cudaErrorDeviceAlreadyInUse
public static final int cudaErrorProfilerDisabled
public static final int cudaErrorProfilerNotInitialized
JCuda.cudaProfilerStart()
or
JCuda.cudaProfilerStop()
without initialization.public static final int cudaErrorProfilerAlreadyStarted
JCuda.cudaProfilerStart()
when profiling is already enabled.public static final int cudaErrorProfilerAlreadyStopped
JCuda.cudaProfilerStop()
when profiling is already disabled.public static final int cudaErrorAssert
JCuda.cudaThreadExit()
is called. All existing
allocations are invalid and must be reconstructed if the program is to
continue using CUDA.public static final int cudaErrorTooManyPeers
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 cudaErrorOperatingSystem
public static final int cudaErrorPeerAccessUnsupported
public static final int cudaErrorLaunchMaxDepthExceeded
public static final int cudaErrorLaunchFileScopedTex
public static final int cudaErrorLaunchFileScopedSurf
public static final int cudaErrorSyncDepthExceeded
public static final int cudaErrorLaunchPendingCountExceeded
public static final int cudaErrorNotPermitted
public static final int cudaErrorNotSupported
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 cudaErrorIllegalAddress
public static final int cudaErrorInvalidPtx
public static final int cudaErrorInvalidGraphicsContext
public static final int cudaErrorStartupFailure
public static final int cudaErrorApiFailureBase
public static final int jcudaInternalError