Enum ServerError 

pub enum ServerError {
    Validation {
        message: String,
        backtrace: BackTrace,
    },
    Generic {
        reason: String,
        backtrace: BackTrace,
    },
    NoDeviceTransport {
        operation: Collective,
        backtrace: BackTrace,
    },
    ForeignHandle {
        handle: String,
        client: String,
        backtrace: BackTrace,
    },
    ServiceMismatch {
        client: String,
        requested: String,
        backtrace: BackTrace,
    },
    Launch(LaunchError),
    Io(IoError),
    TornDown,
    Unwritten {
        failure: u64,
        claimed: u32,
        chain: Vec<String>,
        root: Box<ServerError>,
        backtrace: BackTrace,
    },
    Skipped,
    Several {
        errors: Vec<ServerError>,
        backtrace: BackTrace,
    },
}

Error that can happen asynchronously while executing registered kernels.

Variants

Validation

A runtime validation error

Fields

message: String

The details of the validation error.

backtrace: BackTrace

The backtrace for this error.

Generic

A generic runtime error.

Fields

reason: String

The details of the generic error.

backtrace: BackTrace

The backtrace for this error.

NoDeviceTransport

The runtime has no transport between its devices, so the collective was not run. Its own variant rather than a Generic reason, so a caller can tell a runtime that cannot do this apart from a collective that failed.

Fields

operation: Collective

The collective that was asked for.

backtrace: BackTrace

The backtrace for this error.

ForeignHandle

A handle from one service was handed to a client of another: memory coordinates mean nothing there, so nothing was run.

Fields

handle: String

The service whose memory the handle addresses.

client: String

The service the client reaches.

backtrace: BackTrace

The backtrace for this error.

ServiceMismatch

A caller named a server type the client does not reach. The client is erased over its server, so the type it is asked for is checked against the one it was built from, and nothing was run.

Fields

client: String

The service the client reaches.

requested: String

The server type the caller asked for.

backtrace: BackTrace

The backtrace for this error.

Launch(LaunchError)

A launch error happened

Io(IoError)

An IO error happened

TornDown

The work writing this buffer was torn down before it could say what went wrong: its write scope never reached the exit that names the real failure, which a panic mid-launch explains.

This is the provisional error every write scope enters with, so it carries no payload and captures no backtrace — a launch that succeeds mints one and drops it again, and paying a String and a stack walk per launch for the message nobody normally reads is the whole reason it is a variant rather than a Generic.

Unwritten

The bytes asked about were never written: the work that was going to write them failed, or was skipped downstream of a failure. chain walks from the buffer asked about back toward the root, newest skip first, and root is the failure that started it.

Fields

failure: u64

The failure’s id in the device’s error store, as printed by every other read that trips over the same failure.

claimed: u32

How many buffers the failure still claims.

chain: Vec<String>

The skip chain from the buffer asked about back toward the root.

root: Box<ServerError>

The failure that started it, backtrace included.

backtrace: BackTrace

Where the question was asked, so the lazy report and the read that tripped over it can be tied together.

Skipped

The work did not run, because an input it needed carried a failure.

The report is on the buffers: the work’s outputs claim the failure its inputs did, so a read of one of them names the root cause and the path back to it. This variant says only that the caller’s work was skipped, which is why it carries no payload — the failure the inputs held is not the caller’s to receive here, and minting a formatted message per skip would cost the loop that skips on every iteration.

Several

More than one thing went wrong at once, and the caller is owed all of them: a read naming buffers that several distinct failures claim, or a capture that was both doomed and abandoned.

Fields

errors: Vec<ServerError>

The failures, in the order they were found.

backtrace: BackTrace

The backtrace for this error.

Implementations

impl ServerError

pub fn no_device_transport(operation: Collective) -> ServerError

The error every collective returns on a runtime with no transport between devices.

pub fn is_refusal(&self) -> bool

Whether this is the kernel being refused before it ran, rather than something going wrong while running it.

The distinction a test harness or an autotuner needs: a kernel a backend cannot build at this configuration is a candidate to drop or a case to skip, while a fault, an out-of-memory or an IO failure is a defect that has to be reported. Answering it by reading the message is how a harness ends up accepting the second as the first.

Walks Several and Unwritten to the roots, because a read of an unwritten buffer reports the failure that stopped its writer and that is where the distinction lives. A group answers yes only when every root does: one real failure among refusals is still a real failure, and an empty group refuses nothing.

pub fn graph_state(reason: impl Into<String>) -> ServerError

A graph-capture call the stream’s lifecycle does not allow — a begin_capture without graph_prepare, a second overlapping capture, a replay of an unknown graph, or an operation a capture window cannot record. reason names the call and what was wrong with it.

pub fn graph_capture_unsupported() -> ServerError

The error the default (unsupported) graph-capture methods return, for a backend that has no graph support at all.

Trait Implementations

impl Clone for ServerError

fn clone(&self) -> ServerError

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for ServerError

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for ServerError

fn deserialize<__D>( __deserializer: __D, ) -> Result<ServerError, <__D as Deserializer<'de>>::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Display for ServerError

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

Formats the value using the given formatter.

impl Error for ServerError

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<&ServerError> for ProfileError

A failure during a profiling window invalidates the measurement, whatever the failure was. Every backend answers a launch, write or replay failure this way, so the conversion lives here rather than five times over.

fn from(error: &ServerError) -> ProfileError

Converts to this type from the input type.

impl From<Box<ServerError>> for ProfileError

fn from(source: Box<ServerError>) -> ProfileError

Converts to this type from the input type.

impl From<IoError> for ServerError

fn from(source: IoError) -> ServerError

Converts to this type from the input type.

impl From<LaunchError> for ServerError

fn from(source: LaunchError) -> ServerError

Converts to this type from the input type.

impl Serialize for ServerError

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

where __S: Serializer,

Serialize this value into the given Serde serializer.