Struct ExtensionExecutionContext 

pub struct ExtensionExecutionContext<'a, B>
where
    B: TensorBackend,
{ /* private fields */ }

Backend and cache state passed to one extension execution.

Implementations

impl<'a, B> ExtensionExecutionContext<'a, B>

where B: TensorBackend,

pub fn new( backend: &'a mut B, caches: &'a mut ExtensionCacheStore, ) -> ExtensionExecutionContext<'a, B>

Build a context from externally-owned backend and cache state.

pub fn backend(&self) -> &B

Borrow the backend for non-mutating inspection.

pub fn backend_mut(&mut self) -> &mut B

Borrow the backend mutably for extension execution.

pub fn caches(&self) -> &ExtensionCacheStore

Borrow the extension runtime cache store.

pub fn caches_mut(&mut self) -> &mut ExtensionCacheStore

Borrow the extension runtime cache store mutably.

pub fn execute_core_exec_program_unsegmented( &mut self, program: &ExecProgram, inputs: Vec<Tensor>, ) -> Result<Vec<Tensor>, Error>

where B: 'static,

Execute a core-only execution program one instruction at a time.

This is for extension runtimes that lower their own operation into a temporary ExecProgram containing only core tensor ops. Nested ExecOp::Extension instructions are rejected so extension dispatch cannot bypass the owning runtime registry.

Examples

use tenferro_cpu::CpuBackend;
use tenferro_ops::dim_expr::DimExpr;
use tenferro_runtime::extension::{ExecInstruction, ExecOp, ExecProgram};
use tenferro_runtime::{DType, ExtensionCacheStore, ExtensionExecutionContext, Tensor};

let program = ExecProgram {
    instructions: vec![ExecInstruction {
        op: ExecOp::Add,
        input_slots: vec![0, 1],
        output_slots: vec![2],
        dtype: DType::F64,
        output_shapes: vec![vec![]].into(),
        output_extents: vec![vec![]].into(),
        last_use: vec![true, true],
    }],
    input_slots: vec![0, 1],
    output_slots: vec![2],
    n_slots: 3,
};
let lhs = Tensor::from_vec_col_major(vec![], vec![1.0_f64]).unwrap();
let rhs = Tensor::from_vec_col_major(vec![], vec![2.0_f64]).unwrap();

let mut backend = CpuBackend::new();
let mut caches = ExtensionCacheStore::new();
let mut ctx = ExtensionExecutionContext::new(&mut backend, &mut caches);
let outputs = ctx
    .execute_core_exec_program_unsegmented(&program, vec![lhs, rhs])
    .unwrap();
assert_eq!(outputs[0].as_slice::<f64>().unwrap(), &[3.0]);

pub fn parts_mut(&mut self) -> (&mut B, &mut ExtensionCacheStore)

Borrow backend and extension cache store as disjoint mutable parts.

Trait Implementations

impl<B> Debug for ExtensionExecutionContext<'_, B>

where B: TensorBackend,

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

Formats the value using the given formatter.