Struct FallbackOp 

pub struct FallbackOp<R>
where
    R: FusionRuntime,
{ /* private fields */ }

One operation of an optimization’s block, runnable on its own.

A fallback is unfused work in the middle of a fused block: an optimization that cannot serve part of what it replaced runs those operations directly instead. So it carries the operation’s IR alongside the operation, because running it has to apply the same rule the unfused path applies — an operation whose input a failure claims does not run, and its outputs take that failure. Without it the fallback would be the one place left where a claimed tensor still reaches a kernel.

Implementations

impl<R> FallbackOp<R>

where R: FusionRuntime,

pub fn execute( &self, handles: &mut HandleContainer<<R as FusionRuntime>::FusionHandle>, )

Run it — unless a failure claims one of its inputs, in which case its outputs take that failure, one hop further down, and no kernel runs.

A panic out of the operation is left to the caller: a fallback runs inside the optimization’s own catch_unwind, which claims the whole block’s write set, and that is the honest report for a fused unit that stopped part way.

A fallback that skips or reports gets there by a different road to the same place. Both return normally, so neither stops the optimization — it goes on launching the kernels around this operation, and they write their outputs from bytes it never produced. So the failure is reported back to the execution, which claims the block’s whole write set once the optimization returns. Nothing is claimed twice that matters: the claim carries this same failure, so a read below any of it names one cause.

Trait Implementations

impl<R> Clone for FallbackOp<R>

where R: FusionRuntime,

fn clone(&self) -> FallbackOp<R>

Returns a duplicate of the value.

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

Performs copy-assignment from source.