Struct ExtensionExecutionContext 

pub struct ExtensionExecutionContext<'a, B>
where
    B: BackendSession + ?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::CpuBackend;
use tenferro_tensor::{BackendSessionHost, Tensor};
use tenferro_runtime::{
    ExtensionCacheSelector, ExtensionCacheStore, ExtensionExecutionContext,
};

let mut backend = CpuBackend::new();
let mut caches = ExtensionCacheStore::new();
backend.with_backend_session(|session| {
    let mut context = ExtensionExecutionContext::new(session, &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(&lhs, &rhs).unwrap();

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

A session borrow cannot escape the call that supplied it.

use tenferro_cpu::{with_cpu_exec_session, CpuBackend, CpuExecSession};
use tenferro_runtime::{ExtensionCacheStore, ExtensionExecutionContext};
use tenferro_tensor::BackendSessionHost;

fn leak_context<'a>(
    backend: &'a mut CpuBackend,
    caches: &'a mut ExtensionCacheStore,
) -> ExtensionExecutionContext<'a, CpuExecSession<'a>> {
    backend.with_backend_session(move |session| {
        with_cpu_exec_session(session, |cpu_session| {
            ExtensionExecutionContext::new(cpu_session, caches)
        })
        .unwrap()
    })
}

Implementations

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

where B: BackendSession + ?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: BackendSession + ?Sized,

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

Formats the value using the given formatter.