Enum CudaError 

#[non_exhaustive]
pub enum CudaError {
    Unavailable {
        message: String,
    },
    Driver {
        operation: &'static str,
        code: c_int,
        name: String,
    },
    OutputTooSmall {
        required: usize,
        have: usize,
    },
    LengthTooLarge {
        len: usize,
    },
    HostAllocationFailed {
        bytes: usize,
    },
    HostAllocationTooLarge {
        requested: usize,
        cap: usize,
        what: &'static str,
    },
    LengthNotElementAligned {
        bytes: usize,
        element_size: usize,
    },
    ImageTooLarge {
        width: u32,
        height: u32,
        channels: usize,
    },
    StatePoisoned {
        message: String,
    },
    CompletionFailed {
        primary: Box<CudaError>,
        completion: Box<CudaError>,
    },
    ResourceReleaseFailed {
        primary: Box<CudaError>,
        release: Box<CudaError>,
    },
    KernelStatus {
        kernel: &'static str,
        code: u32,
        detail: u32,
    },
    InvalidArgument {
        message: String,
    },
    InternalInvariant {
        what: &'static str,
    },
}

Error returned by CUDA driver and J2K CUDA kernel helpers.

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.

Unavailable

CUDA driver library or device is unavailable.

Fields

message: String

Human-readable availability failure.

Driver

CUDA Driver API call failed.

Fields

operation: &'static str

Driver operation name.

code: c_int

Raw CUDA result code.

name: String

CUDA error name, when available.

OutputTooSmall

Host output buffer is too small for a device download.

Fields

required: usize

Required byte count.

have: usize

Provided byte count.

LengthTooLarge

Byte length cannot be represented by the kernel ABI.

Fields

len: usize

Byte length.

HostAllocationFailed

A host-side allocation needed by a CUDA operation could not be reserved.

Fields

bytes: usize

Requested host allocation size in bytes.

HostAllocationTooLarge

Simultaneously live host allocations would exceed the codec policy.

Fields

requested: usize

Aggregate requested host byte count, saturated on overflow.

cap: usize

Maximum permitted simultaneously live host bytes.

what: &'static str

Logical operation requiring the allocation.

LengthNotElementAligned

Device byte length is not aligned to the requested typed view element.

Fields

bytes: usize

Byte length.

element_size: usize

Requested element size.

ImageTooLarge

Image dimensions overflowed allocation or launch geometry.

Fields

width: u32

Image width.

height: u32

Image height.

channels: usize

Channel count.

StatePoisoned

Internal runtime state lock was poisoned.

Fields

message: String

Poison error message.

CompletionFailed

A CUDA operation failed and the follow-up completion check also failed.

Fields

primary: Box<CudaError>

Error returned by the original CUDA operation.

completion: Box<CudaError>

Error returned while establishing context-wide completion.

ResourceReleaseFailed

A CUDA operation failed and releasing its retained resources also failed.

Fields

primary: Box<CudaError>

Error returned by the original CUDA operation.

release: Box<CudaError>

Error returned while releasing retained resources.

KernelStatus

A J2K CUDA kernel reported a validated runtime failure.

Fields

kernel: &'static str

Kernel entry point or logical stage name.

code: u32

Kernel-defined status code.

detail: u32

Kernel-defined detail code.

InvalidArgument

Caller supplied arguments that cannot be represented by this runtime API.

Fields

message: String

Human-readable validation failure.

InternalInvariant

Validated host-side planning state contradicted materialized launch data.

Fields

what: &'static str

Stable description of the failed invariant.

Implementations

impl CudaError

pub fn is_unavailable(&self) -> bool

True when the error means the CUDA driver or device is unavailable.

Trait Implementations

impl Debug for CudaError

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

Formats the value using the given formatter.

impl Display for CudaError

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

Formats the value using the given formatter.

impl Error for CudaError

fn source(&self) -> Option<&(dyn Error + 'static)>

Returns the lower-level source of this error, if any.

fn description(&self) -> &str

👎Deprecated since 1.42.0:

use the Display impl or to_string()

fn cause(&self) -> Option<&dyn Error>

👎Deprecated since 1.33.0:

replaced by Error::source, which can support downcasting

fn provide<'a>(&'a self, request: &mut Request<'a>)

🔬This is a nightly-only experimental API. (error_generic_member_access)

Provides type-based access to context intended for error reports.