Enum hip_sys::hiprt::hipError_t

#[non_exhaustive]
#[repr(u32)]
pub enum hipError_t {
    hipSuccess,
    hipErrorInvalidValue,
    hipErrorOutOfMemory,
    hipErrorNotInitialized,
    hipErrorDeinitialized,
    hipErrorProfilerDisabled,
    hipErrorProfilerNotInitialized,
    hipErrorProfilerAlreadyStarted,
    hipErrorProfilerAlreadyStopped,
    hipErrorInvalidConfiguration,
    hipErrorInvalidPitchValue,
    hipErrorInvalidSymbol,
    hipErrorInvalidDevicePointer,
    hipErrorInvalidMemcpyDirection,
    hipErrorInsufficientDriver,
    hipErrorMissingConfiguration,
    hipErrorPriorLaunchFailure,
    hipErrorInvalidDeviceFunction,
    hipErrorNoDevice,
    hipErrorInvalidDevice,
    hipErrorInvalidImage,
    hipErrorInvalidContext,
    hipErrorContextAlreadyCurrent,
    hipErrorMapFailed,
    hipErrorUnmapFailed,
    hipErrorArrayIsMapped,
    hipErrorAlreadyMapped,
    hipErrorNoBinaryForGpu,
    hipErrorAlreadyAcquired,
    hipErrorNotMapped,
    hipErrorNotMappedAsArray,
    hipErrorNotMappedAsPointer,
    hipErrorECCNotCorrectable,
    hipErrorUnsupportedLimit,
    hipErrorContextAlreadyInUse,
    hipErrorPeerAccessUnsupported,
    hipErrorInvalidKernelFile,
    hipErrorInvalidGraphicsContext,
    hipErrorInvalidSource,
    hipErrorFileNotFound,
    hipErrorSharedObjectSymbolNotFound,
    hipErrorSharedObjectInitFailed,
    hipErrorOperatingSystem,
    hipErrorInvalidHandle,
    hipErrorIllegalState,
    hipErrorNotFound,
    hipErrorNotReady,
    hipErrorIllegalAddress,
    hipErrorLaunchOutOfResources,
    hipErrorLaunchTimeOut,
    hipErrorPeerAccessAlreadyEnabled,
    hipErrorPeerAccessNotEnabled,
    hipErrorSetOnActiveProcess,
    hipErrorContextIsDestroyed,
    hipErrorAssert,
    hipErrorHostMemoryAlreadyRegistered,
    hipErrorHostMemoryNotRegistered,
    hipErrorLaunchFailure,
    hipErrorCooperativeLaunchTooLarge,
    hipErrorNotSupported,
    hipErrorStreamCaptureUnsupported,
    hipErrorStreamCaptureInvalidated,
    hipErrorStreamCaptureMerge,
    hipErrorStreamCaptureUnmatched,
    hipErrorStreamCaptureUnjoined,
    hipErrorStreamCaptureIsolation,
    hipErrorStreamCaptureImplicit,
    hipErrorCapturedEvent,
    hipErrorStreamCaptureWrongThread,
    hipErrorGraphExecUpdateFailure,
    hipErrorUnknown,
    hipErrorRuntimeMemory,
    hipErrorRuntimeOther,
    hipErrorTbd,
}

Variants (Non-exhaustive)

Non-exhaustive enums could have additional variants added in future. Therefore, when matching against variants of non-exhaustive enums, an extra wildcard arm must be added to account for any future variants.

hipSuccess

< Successful completion.

hipErrorInvalidValue

< One or more of the parameters passed to the API call is NULL < or not in an acceptable range.

hipErrorOutOfMemory

hipErrorNotInitialized

hipErrorDeinitialized

hipErrorProfilerDisabled

hipErrorProfilerNotInitialized

hipErrorProfilerAlreadyStarted

hipErrorProfilerAlreadyStopped

hipErrorInvalidConfiguration

hipErrorInvalidPitchValue

hipErrorInvalidSymbol

hipErrorInvalidDevicePointer

< Invalid Device Pointer

hipErrorInvalidMemcpyDirection

< Invalid memory copy direction

hipErrorInsufficientDriver

hipErrorMissingConfiguration

hipErrorPriorLaunchFailure

hipErrorInvalidDeviceFunction

hipErrorNoDevice

< Call to hipGetDeviceCount returned 0 devices

hipErrorInvalidDevice

< DeviceID must be in range 0…#compute-devices.

hipErrorInvalidImage

hipErrorInvalidContext

< Produced when input context is invalid.

hipErrorContextAlreadyCurrent

hipErrorMapFailed

hipErrorUnmapFailed

hipErrorArrayIsMapped

hipErrorAlreadyMapped

hipErrorNoBinaryForGpu

hipErrorAlreadyAcquired

hipErrorNotMapped

hipErrorNotMappedAsArray

hipErrorNotMappedAsPointer

hipErrorECCNotCorrectable

hipErrorUnsupportedLimit

hipErrorContextAlreadyInUse

hipErrorPeerAccessUnsupported

hipErrorInvalidKernelFile

< In CUDA DRV, it is CUDA_ERROR_INVALID_PTX

hipErrorInvalidGraphicsContext

hipErrorInvalidSource

hipErrorFileNotFound

hipErrorSharedObjectSymbolNotFound

hipErrorSharedObjectInitFailed

hipErrorOperatingSystem

hipErrorInvalidHandle

hipErrorIllegalState

< Resource required is not in a valid state to perform operation.

hipErrorNotFound

hipErrorNotReady

< Indicates that asynchronous operations enqueued earlier are not < ready. This is not actually an error, but is used to distinguish < from hipSuccess (which indicates completion). APIs that return < this error include hipEventQuery and hipStreamQuery.

hipErrorIllegalAddress

hipErrorLaunchOutOfResources

< Out of resources error.

hipErrorLaunchTimeOut

hipErrorPeerAccessAlreadyEnabled

hipErrorPeerAccessNotEnabled

hipErrorSetOnActiveProcess

hipErrorContextIsDestroyed

hipErrorAssert

< Produced when the kernel calls assert.

hipErrorHostMemoryAlreadyRegistered

hipErrorHostMemoryNotRegistered

hipErrorLaunchFailure

hipErrorCooperativeLaunchTooLarge

hipErrorNotSupported

< Produced when the hip API is not supported/implemented

hipErrorStreamCaptureUnsupported

< The operation is not permitted when the stream < is capturing.

hipErrorStreamCaptureInvalidated

< The current capture sequence on the stream < has been invalidated due to a previous error.

hipErrorStreamCaptureMerge

< The operation would have resulted in a merge of < two independent capture sequences.

hipErrorStreamCaptureUnmatched

< The capture was not initiated in this stream.

hipErrorStreamCaptureUnjoined

< The capture sequence contains a fork that was not < joined to the primary stream.

hipErrorStreamCaptureIsolation

< A dependency would have been created which crosses < the capture sequence boundary. Only implicit < in-stream ordering dependencies are allowed < to cross the boundary

hipErrorStreamCaptureImplicit

< The operation would have resulted in a disallowed < implicit dependency on a current capture sequence < from hipStreamLegacy.

hipErrorCapturedEvent

< The operation is not permitted on an event which was last < recorded in a capturing stream.

hipErrorStreamCaptureWrongThread

< A stream capture sequence not initiated with < the hipStreamCaptureModeRelaxed argument to < hipStreamBeginCapture was passed to < hipStreamEndCapture in a different thread.

hipErrorGraphExecUpdateFailure

< This error indicates that the graph update < not performed because it included changes which < violated constraintsspecific to instantiated graph < update.

hipErrorUnknown

hipErrorRuntimeMemory

< HSA runtime memory call returned error. Typically not seen < in production systems.

hipErrorRuntimeOther

< HSA runtime call other than memory returned error. Typically < not seen in production systems.

hipErrorTbd

< Marker that more error codes are needed.

Implementations

impl hipError_t

pub const hipErrorMemoryAllocation: hipError_t = hipError_t::hipErrorOutOfMemory

impl hipError_t

pub const hipErrorInitializationError: hipError_t = hipError_t::hipErrorNotInitialized

impl hipError_t

pub const hipErrorMapBufferObjectFailed: hipError_t = hipError_t::hipErrorMapFailed

impl hipError_t

pub const hipErrorInvalidResourceHandle: hipError_t = hipError_t::hipErrorInvalidHandle

Trait Implementations

impl Clone for hipError_t

fn clone(&self) -> hipError_t

Returns a copy of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for hipError_t

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

Formats the value using the given formatter.

impl Hash for hipError_t

fn hash<__H>(&self, state: &mut __H)where __H: Hasher,

Feeds this value into the given Hasher.

fn hash_slice<H>(data: &[Self], state: &mut H)where H: Hasher, Self: Sized,

Feeds a slice of this type into the given Hasher.

impl Ord for hipError_t

fn cmp(&self, other: &hipError_t) -> Ordering

This method returns an Ordering between self and other.

fn max(self, other: Self) -> Selfwhere Self: Sized,

Compares and returns the maximum of two values.

fn min(self, other: Self) -> Selfwhere Self: Sized,

Compares and returns the minimum of two values.

fn clamp(self, min: Self, max: Self) -> Selfwhere Self: Sized + PartialOrd<Self>,

Restrict a value to a certain interval.

impl PartialEq<hipError_t> for hipError_t

fn eq(&self, other: &hipError_t) -> bool

This method tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

This method tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl PartialOrd<hipError_t> for hipError_t

fn partial_cmp(&self, other: &hipError_t) -> Option<Ordering>

This method returns an ordering between self and other values if one exists.

fn lt(&self, other: &Rhs) -> bool

This method tests less than (for self and other) and is used by the < operator.

fn le(&self, other: &Rhs) -> bool

This method tests less than or equal to (for self and other) and is used by the <= operator.

fn gt(&self, other: &Rhs) -> bool

This method tests greater than (for self and other) and is used by the > operator.

fn ge(&self, other: &Rhs) -> bool

This method tests greater than or equal to (for self and other) and is used by the >= operator.

impl Copy for hipError_t

impl Eq for hipError_t

impl StructuralEq for hipError_t

impl StructuralPartialEq for hipError_t