Enum IoError 

pub enum IoError {
    BufferTooBig {
        size: u64,
        backtrace: BackTrace,
    },
    OutOfMemory {
        size: u64,
        backtrace: BackTrace,
    },
    PageUpdateForbidden {
        size: u64,
        backtrace: BackTrace,
    },
    PageSizesExhausted {
        size: u64,
        backtrace: BackTrace,
    },
    UnsupportedStrides {
        backtrace: BackTrace,
    },
    NotFound {
        backtrace: BackTrace,
        reason: Reason,
    },
    StorageHandleNotFound {
        reason: Reason,
        backtrace: BackTrace,
    },
    StorageMappingFailed {
        size: u64,
        source: Box<IoError>,
        backtrace: BackTrace,
    },
    DevicePoisoned(DevicePoison),
    Unknown {
        description: String,
        backtrace: BackTrace,
    },
    UnsupportedIoOperation {
        backtrace: BackTrace,
    },
}

Error returned from create/read/write functions. Due to async execution not all errors are able to be caught, so some IO errors will still panic.

Variants

BufferTooBig

Buffer size exceeds the max available

Fields

size: u64

The size of the buffer in bytes.

backtrace: BackTrace

The captured backtrace.

OutOfMemory

The device had no memory left for this allocation.

Unlike IoError::BufferTooBig (the allocation can never fit), this describes the device at one moment: pool pages whose slices have all been dropped are still resident, and the frees that would release them may not have reached the driver yet. Reclaiming and retrying is a reasonable response, which is why a storage backend must not report a driver out-of-memory as BufferTooBig: that tells every caller the allocation is hopeless when it is merely untimely.

Fields

size: u64

The size of the failed allocation in bytes.

backtrace: BackTrace

The captured backtrace.

PageUpdateForbidden

No room for the allocation in the pages the memory holds, and the reservation was not allowed to add one.

A stream recording a graph reserves this way: an allocation would become part of the recording, and a hardware graph holding one cannot be relaunched. The warmup before a capture is what leaves the pools holding what the recorded run asks for.

Fields

size: u64

The size of the allocation in bytes.

backtrace: BackTrace

The captured backtrace.

PageSizesExhausted

An allocation needs pages of a new size, and the memory already holds as many page sizes as it keeps track of.

Every size a workload grew through keeps a pool until what lives on it is freed or relocated. A cleanup relocates what it can, so reclaiming and retrying is a reasonable response.

Fields

size: u64

The size of the allocation in bytes.

backtrace: BackTrace

The captured backtrace.

UnsupportedStrides

Strides aren’t supported for this copy operation on this runtime

Fields

backtrace: BackTrace

The backtrace.

NotFound

Memory wasn’t found in the memory pool

Fields

backtrace: BackTrace

The backtrace.

reason: Reason

The reason the handle is invalid.

StorageHandleNotFound

The storage backend holds no allocation for a handle’s storage id.

One layer below IoError::NotFound: there the memory manager could not route a binding to a slice, here the routing succeeded and the allocation the slice names is gone. A handle outliving its page, or a storage id a deallocation retired, reaches the storage this way.

Fields

reason: Reason

Which id was looked up, and in which storage.

backtrace: BackTrace

The backtrace.

StorageMappingFailed

An allocation carved lazily under a DryRun could not be given real device backing when it was finally resolved.

Distinct from the same failure at reservation time, and the distinction is what a caller acts on: the memory was promised earlier, by a pass that measured a plan without paying for it, and is only now being charged for. A plan whose replay hits this was measured against more device memory than the replay has — warm the tune caches first, or measure a smaller one.

Fields

size: u64

The size of the allocation that could not be backed, in bytes.

source: Box<IoError>

Why the device allocation failed.

backtrace: BackTrace

The backtrace.

DevicePoisoned(DevicePoison)

The device is poisoned: a kernel faulted in a way the driver makes sticky (an illegal address, a trap, a hardware fault, etc.)

Unknown

Unknown error happened during execution

Fields

description: String

Details of the error

backtrace: BackTrace

The backtrace.

UnsupportedIoOperation

The current IO operation is not supported

Fields

backtrace: BackTrace

The backtrace.

Implementations

impl IoError

pub fn is_device_poisoned(&self) -> bool

Whether the device that emitted the error is poisoned.

pub fn may_succeed_after_reclaim(&self) -> bool

Whether reclaiming memory could still make this allocation succeed.

Out of memory right now is not out of memory for good: pool pages whose slices have all been dropped are still resident, and the frees that would release them may sit in a deferred drop queue. A transient peak — a model build holding float weights while their quantized copies allocate, an autotune sample on a full device — is rescued by a reclaim and a second attempt.

A buffer larger than any page the device can hold is the exception. It never fits, so reclaiming would only spend the time. So is an allocation while a graph records, where nothing may be released.

Trait Implementations

impl Clone for IoError

fn clone(&self) -> Self

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for IoError

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for IoError

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Display for IoError

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

Formats the value using the given formatter.

impl Error for IoError

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.

impl From<DevicePoison> for IoError

fn from(source: DevicePoison) -> Self

Converts to this type from the input type.

impl From<IoError> for ServerError

fn from(source: IoError) -> Self

Converts to this type from the input type.

impl Serialize for IoError

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.