Interface CudaError

public interface CudaError
The CudaError interface defines the possible values of CudaException.code.

  • Field Summary

    Fields
    Modifier and Type
    Field
    Description
    static final int
    Assert
    An assert triggered in device code during kernel execution.
    static final int
    CudartUnloading
    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 final int
    DeviceAlreadyInUse
    This indicates that a call tried to access an exclusive-thread device that is already in use by a different thread.
    static final int
    DevicesUnavailable
    This indicates that all CUDA devices are busy or unavailable at the current time.
    static final int
    DuplicateSurfaceName
    This indicates that multiple surfaces (across separate CUDA source files in the application) share the same string name.
    static final int
    DuplicateTextureName
    This indicates that multiple textures (across separate CUDA source files in the application) share the same string name.
    static final int
    DuplicateVariableName
    This indicates that multiple global or constant variables (across separate CUDA source files in the application) share the same string name.
    static final int
    ECCUncorrectable
    This indicates that an uncorrectable ECC error was detected during execution.
    static final int
    HostMemoryAlreadyRegistered
    This error indicates that the memory range passed to ::cudaHostRegister() has already been registered.
    static final int
    HostMemoryNotRegistered
    This error indicates that the pointer passed to ::cudaHostUnregister() does not correspond to any currently registered memory region.
    static final int
    IncompatibleDriverContext
    This indicates that the current context is not compatible with this the CUDA Runtime.
    static final int
    InitializationError
    The API call failed because the CUDA driver and runtime could not be initialized.
    static final int
    InsufficientDriver
    This indicates that the installed NVIDIA CUDA driver is older than the CUDA runtime library.
    static final int
    InvalidChannelDescriptor
    This indicates that the channel descriptor passed to the API call is not valid.
    static final int
    InvalidConfiguration
    This indicates that a kernel launch is requesting resources that can never be satisfied by the current device.
    static final int
    InvalidDevice
    This indicates that the device ordinal supplied by the user does not correspond to a valid CUDA device.
    static final int
    InvalidDeviceFunction
    The requested device function does not exist or is not compiled for the proper device architecture.
    static final int
    InvalidDevicePointer
    This indicates that at least one device pointer passed to the API call is not a valid device pointer.
    static final int
    InvalidFilterSetting
    This indicates that a non-float texture was being accessed with linear filtering.
    static final int
    InvalidHostPointer
    This indicates that at least one host pointer passed to the API call is not a valid host pointer.
    static final int
    InvalidKernelImage
    This indicates that the device kernel image is invalid.
    static final int
    InvalidMemcpyDirection
    This indicates that the direction of the memcpy passed to the API call is not one of the types specified by ::cudaMemcpyKind.
    static final int
    InvalidNormSetting
    This indicates that an attempt was made to read a non-float texture as a normalized float.
    static final int
    InvalidPitchValue
    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 final int
    InvalidResourceHandle
    This indicates that a resource handle passed to the API call was not valid.
    static final int
    InvalidSurface
    This indicates that the surface passed to the API call is not a valid surface.
    static final int
    InvalidSymbol
    This indicates that the symbol name/identifier passed to the API call is not a valid name or identifier.
    static final int
    InvalidTexture
    This indicates that the texture passed to the API call is not a valid texture.
    static final int
    InvalidTextureBinding
    This indicates that the texture binding is not valid.
    static final int
    InvalidValue
    This indicates that one or more of the parameters passed to the API call is not within an acceptable range of values.
    static final int
    LaunchFailure
    An exception occurred on the device while executing a kernel.
    static final int
    LaunchFileScopedSurf
    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 final int
    LaunchFileScopedTex
    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 final int
    LaunchMaxDepthExceeded
    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 final int
    LaunchOutOfResources
    This indicates that a launch did not occur because it did not have appropriate resources.
    static final int
    LaunchPendingCountExceeded
    This error indicates that a device runtime grid launch failed because the launch would exceed the limit ::cudaLimitDevRuntimePendingLaunchCount.
    static final int
    LaunchTimeout
    This indicates that the device kernel took too long to execute.
    static final int
    MapBufferObjectFailed
    This indicates that the buffer object could not be mapped.
    static final int
    MemoryAllocation
    The API call failed because it was unable to allocate enough memory to perform the requested operation.
    static final int
    MissingConfiguration
    The device function being invoked (usually via ::cudaLaunch()) was not previously configured via the ::cudaConfigureCall() function.
    static final int
    NoDevice
    This indicates that no CUDA-capable devices were detected by the installed CUDA driver.
    static final int
    NoKernelImageForDevice
    This indicates that there is no kernel image available that is suitable for the device.
    static final int
    NotPermitted
    This error indicates the attempted operation is not permitted.
    static final int
    NotReady
    This indicates that asynchronous operations issued previously have not completed yet.
    static final int
    NotSupported
    This error indicates the attempted operation is not supported on the current system or device.
    static final int
    OperatingSystem
    This error indicates that an OS call failed.
    static final int
    PeerAccessAlreadyEnabled
    This error indicates that a call to ::cudaDeviceEnablePeerAccess() is trying to re-enable peer addressing on from a context which has already had peer addressing enabled.
    static final int
    PeerAccessNotEnabled
    This error indicates that ::cudaDeviceDisablePeerAccess() is trying to disable peer addressing which has not been enabled yet via ::cudaDeviceEnablePeerAccess().
    static final int
    PeerAccessUnsupported
    This error indicates that P2P access is not supported across the given devices.
    static final int
    ProfilerDisabled
    This indicates profiler is not initialized for this run.
    static final int
    SetOnActiveProcess
    This indicates that the user has called ::cudaSetValidDevices(), ::cudaSetDeviceFlags(), ::cudaD3D9SetDirect3DDevice(), ::cudaD3D10SetDirect3DDevice, ::cudaD3D11SetDirect3DDevice(), or ::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 final int
    SharedObjectInitFailed
    This indicates that initialization of a shared object failed.
    static final int
    SharedObjectSymbolNotFound
    This indicates that a link to a shared object failed to resolve.
    static final int
    StartupFailure
    This indicates an internal startup failure in the CUDA runtime.
    static final int
    Success
    The API call returned with no errors.
    static final int
    SyncDepthExceeded
    This error indicates that a call to ::cudaDeviceSynchronize made from the device runtime failed because the call was made at grid depth greater than either the default (2 levels of grids) or user specified device limit ::cudaLimitDevRuntimeSyncDepth.
    static final int
    TooManyPeers
    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 final int
    Unknown
    This indicates that an unknown internal error has occurred.
    static final int
    UnmapBufferObjectFailed
    This indicates that the buffer object could not be unmapped.
    static final int
    UnsupportedLimit
    This indicates that the ::cudaLimit passed to the API call is not supported by the active device.

  • Field Details

    • Success

      static final int Success
      The API call returned with no errors. In the case of query calls, this can also mean that the operation being queried is complete (see ::cudaEventQuery() and ::cudaStreamQuery()).
      See Also:

    • MissingConfiguration

      static final int MissingConfiguration
      The device function being invoked (usually via ::cudaLaunch()) was not previously configured via the ::cudaConfigureCall() function.
      See Also:

    • MemoryAllocation

      static final int MemoryAllocation
      The API call failed because it was unable to allocate enough memory to perform the requested operation.
      See Also:

    • InitializationError

      static final int InitializationError
      The API call failed because the CUDA driver and runtime could not be initialized.
      See Also:

    • LaunchFailure

      static final int LaunchFailure
      An exception occurred on the device while executing a kernel. Common causes include dereferencing an invalid device pointer and accessing out of bounds shared memory. The device cannot be used until ::cudaThreadExit() is called. All existing device memory allocations are invalid and must be reconstructed if the program is to continue using CUDA.
      See Also:

    • LaunchTimeout

      static final int LaunchTimeout
      This indicates that the device kernel took too long to execute. This can only occur if timeouts are enabled - see the device property \ref ::cudaDeviceProp::kernelExecTimeoutEnabled "kernelExecTimeoutEnabled" for more information. The device cannot be used until ::cudaThreadExit() is called. All existing device memory allocations are invalid and must be reconstructed if the program is to continue using CUDA.
      See Also:

    • LaunchOutOfResources

      static final int LaunchOutOfResources
      This indicates that a launch did not occur because it did not have appropriate resources. Although this error is similar to ::InvalidConfiguration, 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.
      See Also:

    • InvalidDeviceFunction

      static final int InvalidDeviceFunction
      The requested device function does not exist or is not compiled for the proper device architecture.
      See Also:

    • InvalidConfiguration

      static final int InvalidConfiguration
      This indicates that a kernel launch is requesting resources that can never be satisfied by the current device. Requesting more shared memory per block than the device supports will trigger this error, as will requesting too many threads or blocks. See ::cudaDeviceProp for more device limitations.
      See Also:

    • InvalidDevice

      static final int InvalidDevice
      This indicates that the device ordinal supplied by the user does not correspond to a valid CUDA device.
      See Also:

    • InvalidValue

      static final int InvalidValue
      This indicates that one or more of the parameters passed to the API call is not within an acceptable range of values.
      See Also:

    • InvalidPitchValue

      static final int InvalidPitchValue
      This indicates that one or more of the pitch-related parameters passed to the API call is not within the acceptable range for pitch.
      See Also:

    • InvalidSymbol

      static final int InvalidSymbol
      This indicates that the symbol name/identifier passed to the API call is not a valid name or identifier.
      See Also:

    • MapBufferObjectFailed

      static final int MapBufferObjectFailed
      This indicates that the buffer object could not be mapped.
      See Also:

    • UnmapBufferObjectFailed

      static final int UnmapBufferObjectFailed
      This indicates that the buffer object could not be unmapped.
      See Also:

    • InvalidHostPointer

      static final int InvalidHostPointer
      This indicates that at least one host pointer passed to the API call is not a valid host pointer.
      See Also:

    • InvalidDevicePointer

      static final int InvalidDevicePointer
      This indicates that at least one device pointer passed to the API call is not a valid device pointer.
      See Also:

    • InvalidTexture

      static final int InvalidTexture
      This indicates that the texture passed to the API call is not a valid texture.
      See Also:

    • InvalidTextureBinding

      static final int InvalidTextureBinding
      This indicates that the texture binding is not valid. This occurs if you call ::cudaGetTextureAlignmentOffset() with an unbound texture.
      See Also:

    • InvalidChannelDescriptor

      static final int InvalidChannelDescriptor
      This indicates that the channel descriptor passed to the API call is not valid. This occurs if the format is not one of the formats specified by ::cudaChannelFormatKind, or if one of the dimensions is invalid.
      See Also:

    • InvalidMemcpyDirection

      static final int InvalidMemcpyDirection
      This indicates that the direction of the memcpy passed to the API call is not one of the types specified by ::cudaMemcpyKind.
      See Also:

    • InvalidFilterSetting

      static final int InvalidFilterSetting
      This indicates that a non-float texture was being accessed with linear filtering. This is not supported by CUDA.
      See Also:

    • InvalidNormSetting

      static final int InvalidNormSetting
      This indicates that an attempt was made to read a non-float texture as a normalized float. This is not supported by CUDA.
      See Also:

    • CudartUnloading

      static final int CudartUnloading
      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.
      See Also:

    • Unknown

      static final int Unknown
      This indicates that an unknown internal error has occurred.
      See Also:

    • InvalidResourceHandle

      static final int InvalidResourceHandle
      This indicates that a resource handle passed to the API call was not valid. Resource handles are opaque types like ::cudaStream_t and ::cudaEvent_t.
      See Also:

    • NotReady

      static final int NotReady
      This indicates that asynchronous operations issued previously have not completed yet. This result is not actually an error, but must be indicated differently than ::cudaSuccess (which indicates completion). Calls that may return this value include ::cudaEventQuery() and ::cudaStreamQuery().
      See Also:

    • InsufficientDriver

      static final int InsufficientDriver
      This indicates that the installed NVIDIA CUDA driver is older than the CUDA runtime library. This is not a supported configuration. Users should install an updated NVIDIA display driver to allow the application to run.
      See Also:

    • SetOnActiveProcess

      static final int SetOnActiveProcess
      This indicates that the user has called ::cudaSetValidDevices(), ::cudaSetDeviceFlags(), ::cudaD3D9SetDirect3DDevice(), ::cudaD3D10SetDirect3DDevice, ::cudaD3D11SetDirect3DDevice(), or ::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.
      See Also:

    • InvalidSurface

      static final int InvalidSurface
      This indicates that the surface passed to the API call is not a valid surface.
      See Also:

    • NoDevice

      static final int NoDevice
      This indicates that no CUDA-capable devices were detected by the installed CUDA driver.
      See Also:

    • ECCUncorrectable

      static final int ECCUncorrectable
      This indicates that an uncorrectable ECC error was detected during execution.
      See Also:

    • SharedObjectSymbolNotFound

      static final int SharedObjectSymbolNotFound
      This indicates that a link to a shared object failed to resolve.
      See Also:

    • SharedObjectInitFailed

      static final int SharedObjectInitFailed
      This indicates that initialization of a shared object failed.
      See Also:

    • UnsupportedLimit

      static final int UnsupportedLimit
      This indicates that the ::cudaLimit passed to the API call is not supported by the active device.
      See Also:

    • DuplicateVariableName

      static final int DuplicateVariableName
      This indicates that multiple global or constant variables (across separate CUDA source files in the application) share the same string name.
      See Also:

    • DuplicateTextureName

      static final int DuplicateTextureName
      This indicates that multiple textures (across separate CUDA source files in the application) share the same string name.
      See Also:

    • DuplicateSurfaceName

      static final int DuplicateSurfaceName
      This indicates that multiple surfaces (across separate CUDA source files in the application) share the same string name.
      See Also:

    • DevicesUnavailable

      static final int DevicesUnavailable
      This indicates that all CUDA devices are busy or unavailable at the current time. Devices are often busy/unavailable due to use of ::cudaComputeModeExclusive, ::cudaComputeModeProhibited or when long running CUDA kernels have filled up the GPU and are blocking new work from starting. They can also be unavailable due to memory constraints on a device that already has active CUDA work being performed.
      See Also:

    • InvalidKernelImage

      static final int InvalidKernelImage
      This indicates that the device kernel image is invalid.
      See Also:

    • NoKernelImageForDevice

      static final int NoKernelImageForDevice
      This indicates that there is no kernel image available that is suitable for the device. This can occur when a user specifies code generation options for a particular CUDA source file that do not include the corresponding device configuration.
      See Also:

    • IncompatibleDriverContext

      static final int IncompatibleDriverContext
      This indicates that the current context is not compatible with this the CUDA Runtime. This can only occur if you are using CUDA Runtime/Driver interoperability and have created an existing Driver context using the driver API. The Driver context may be incompatible either because the Driver context was created using an older version of the API, because the Runtime API call expects a primary driver context and the Driver context is not primary, or because the Driver context has been destroyed. Please see CUDART_DRIVER Interactions with the CUDA Driver API for more information.
      See Also:

    • PeerAccessAlreadyEnabled

      static final int PeerAccessAlreadyEnabled
      This error indicates that a call to ::cudaDeviceEnablePeerAccess() is trying to re-enable peer addressing on from a context which has already had peer addressing enabled.
      See Also:

    • PeerAccessNotEnabled

      static final int PeerAccessNotEnabled
      This error indicates that ::cudaDeviceDisablePeerAccess() is trying to disable peer addressing which has not been enabled yet via ::cudaDeviceEnablePeerAccess().
      See Also:

    • DeviceAlreadyInUse

      static final int DeviceAlreadyInUse
      This indicates that a call tried to access an exclusive-thread device that is already in use by a different thread.
      See Also:

    • ProfilerDisabled

      static final int ProfilerDisabled
      This indicates profiler is not initialized for this run. This can happen when the application is running with external profiling tools like visual profiler.
      See Also:

    • Assert

      static final int Assert
      An assert triggered in device code during kernel execution. The device cannot be used again until ::cudaThreadExit() is called. All existing allocations are invalid and must be reconstructed if the program is to continue using CUDA.
      See Also:

    • TooManyPeers

      static final int TooManyPeers
      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().
      See Also:

    • HostMemoryAlreadyRegistered

      static final int HostMemoryAlreadyRegistered
      This error indicates that the memory range passed to ::cudaHostRegister() has already been registered.
      See Also:

    • HostMemoryNotRegistered

      static final int HostMemoryNotRegistered
      This error indicates that the pointer passed to ::cudaHostUnregister() does not correspond to any currently registered memory region.
      See Also:

    • OperatingSystem

      static final int OperatingSystem
      This error indicates that an OS call failed.
      See Also:

    • PeerAccessUnsupported

      static final int PeerAccessUnsupported
      This error indicates that P2P access is not supported across the given devices.
      See Also:

    • LaunchMaxDepthExceeded

      static final int LaunchMaxDepthExceeded
      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.
      See Also:

    • LaunchFileScopedTex

      static final int LaunchFileScopedTex
      This error indicates that a grid launch did not occur because the kernel uses file-scoped textures which are unsupported by the device runtime. Kernels launched via the device runtime only support textures created with the Texture Object API's.
      See Also:

    • LaunchFileScopedSurf

      static final int LaunchFileScopedSurf
      This error indicates that a grid launch did not occur because the kernel uses file-scoped surfaces which are unsupported by the device runtime. Kernels launched via the device runtime only support surfaces created with the Surface Object API's.
      See Also:

    • SyncDepthExceeded

      static final int SyncDepthExceeded
      This error indicates that a call to ::cudaDeviceSynchronize made from the device runtime failed because the call was made at grid depth greater 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 ::cudaDeviceSynchronize will be called must be specified with the ::cudaLimitDevRuntimeSyncDepth limit to the ::cudaDeviceSetLimit 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.
      See Also:

    • LaunchPendingCountExceeded

      static final int LaunchPendingCountExceeded
      This error indicates that a device runtime grid launch failed because the launch would exceed the limit ::cudaLimitDevRuntimePendingLaunchCount. For this launch to proceed successfully, ::cudaDeviceSetLimit 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.
      See Also:

    • NotPermitted

      static final int NotPermitted
      This error indicates the attempted operation is not permitted.
      See Also:

    • NotSupported

      static final int NotSupported
      This error indicates the attempted operation is not supported on the current system or device.
      See Also:

    • StartupFailure

      static final int StartupFailure
      This indicates an internal startup failure in the CUDA runtime.
      See Also: