Module openj9.cuda
Package com.ibm.cuda

Interface CudaError


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

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

      • 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:
        Constant Field Values
      • MissingConfiguration

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

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

        static final int InitializationError
        The API call failed because the CUDA driver and runtime could not be initialized.
        See Also:
        Constant Field Values
      • 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:
        Constant Field Values
      • 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:
        Constant Field Values
      • 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:
        Constant Field Values
      • InvalidDeviceFunction

        static final int InvalidDeviceFunction
        The requested device function does not exist or is not compiled for the proper device architecture.
        See Also:
        Constant Field Values
      • 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:
        Constant Field Values
      • 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:
        Constant Field Values
      • 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:
        Constant Field Values
      • 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:
        Constant Field Values
      • 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:
        Constant Field Values
      • MapBufferObjectFailed

        static final int MapBufferObjectFailed
        This indicates that the buffer object could not be mapped.
        See Also:
        Constant Field Values
      • UnmapBufferObjectFailed

        static final int UnmapBufferObjectFailed
        This indicates that the buffer object could not be unmapped.
        See Also:
        Constant Field Values
      • 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:
        Constant Field Values
      • 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:
        Constant Field Values
      • InvalidTexture

        static final int InvalidTexture
        This indicates that the texture passed to the API call is not a valid texture.
        See Also:
        Constant Field Values
      • 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:
        Constant Field Values
      • 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:
        Constant Field Values
      • 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:
        Constant Field Values
      • 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:
        Constant Field Values
      • 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:
        Constant Field Values
      • 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:
        Constant Field Values
      • Unknown

        static final int Unknown
        This indicates that an unknown internal error has occurred.
        See Also:
        Constant Field Values
      • 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:
        Constant Field Values
      • 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:
        Constant Field Values
      • 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:
        Constant Field Values
      • 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:
        Constant Field Values
      • InvalidSurface

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

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

        static final int ECCUncorrectable
        This indicates that an uncorrectable ECC error was detected during execution.
        See Also:
        Constant Field Values
      • SharedObjectSymbolNotFound

        static final int SharedObjectSymbolNotFound
        This indicates that a link to a shared object failed to resolve.
        See Also:
        Constant Field Values
      • SharedObjectInitFailed

        static final int SharedObjectInitFailed
        This indicates that initialization of a shared object failed.
        See Also:
        Constant Field Values
      • UnsupportedLimit

        static final int UnsupportedLimit
        This indicates that the ::cudaLimit passed to the API call is not supported by the active device.
        See Also:
        Constant Field Values
      • 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:
        Constant Field Values
      • 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:
        Constant Field Values
      • 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:
        Constant Field Values
      • 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:
        Constant Field Values
      • InvalidKernelImage

        static final int InvalidKernelImage
        This indicates that the device kernel image is invalid.
        See Also:
        Constant Field Values
      • 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:
        Constant Field Values
      • 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:
        Constant Field Values
      • 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:
        Constant Field Values
      • 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:
        Constant Field Values
      • 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:
        Constant Field Values
      • 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:
        Constant Field Values
      • 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:
        Constant Field Values
      • 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:
        Constant Field Values
      • HostMemoryAlreadyRegistered

        static final int HostMemoryAlreadyRegistered
        This error indicates that the memory range passed to ::cudaHostRegister() has already been registered.
        See Also:
        Constant Field Values
      • 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:
        Constant Field Values
      • OperatingSystem

        static final int OperatingSystem
        This error indicates that an OS call failed.
        See Also:
        Constant Field Values
      • PeerAccessUnsupported

        static final int PeerAccessUnsupported
        This error indicates that P2P access is not supported across the given devices.
        See Also:
        Constant Field Values
      • 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:
        Constant Field Values
      • 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:
        Constant Field Values
      • 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:
        Constant Field Values
      • 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:
        Constant Field Values
      • 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:
        Constant Field Values
      • NotPermitted

        static final int NotPermitted
        This error indicates the attempted operation is not permitted.
        See Also:
        Constant Field Values
      • NotSupported

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

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