Struct ExtensionExecutionContext 

pub struct ExtensionExecutionContext<'a, B>
where
    B: Engine + ?Sized,
{ /* private fields */ }

Backend and cache state passed to one prepared extension execution.

Extension crates should obtain this value from their hidden [crate::PreparedOperationExecutor] bridge and use it only for the duration of that call.

Examples

use tenferro_cpu::CpuEngine;
use tenferro_tensor::{Tensor, TensorElementwise, TensorRead};
use tenferro_runtime::{
    ExtensionCacheSelector, ExtensionCacheStore, ExtensionExecutionContext,
};

let mut engine = CpuEngine::serial();
let mut caches = ExtensionCacheStore::new();
let mut context = ExtensionExecutionContext::new(&mut engine, &mut caches);
let lhs = Tensor::from_vec_col_major(vec![2], vec![1.0_f64, 2.0]).unwrap();
let rhs = Tensor::from_vec_col_major(vec![2], vec![3.0_f64, 4.0]).unwrap();
let output = context
    .backend_mut()
    .add_read(TensorRead::from_tensor(&lhs), TensorRead::from_tensor(&rhs))
    .unwrap();

assert_eq!(output.as_slice::<f64>().unwrap(), &[4.0, 6.0]);
assert_eq!(context.caches().stats(ExtensionCacheSelector::All).entries, 0);

The context cannot outlive the engine and cache state it borrows.

use tenferro_cpu::CpuEngine;
use tenferro_runtime::{ExtensionCacheStore, ExtensionExecutionContext};

fn leak_context() -> ExtensionExecutionContext<'static, CpuEngine> {
    let mut engine = CpuEngine::serial();
    let mut caches = ExtensionCacheStore::new();
    ExtensionExecutionContext::new(&mut engine, &mut caches)
}

Implementations

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

where B: Engine + ?Sized,

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 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: Engine + ?Sized,

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

Formats the value using the given formatter.