Struct ExtensionExecutor 

pub struct ExtensionExecutor<B>
where
    B: TensorBackend + 'static,
{ /* private fields */ }

Runtime owner for backend-specific extension dispatch and caches.

Implementations

impl<B> ExtensionExecutor<B>

where B: TensorBackend + 'static,

pub fn new() -> ExtensionExecutor<B>

Create an executor with an empty registry and default cache limits.

Examples

use tenferro_runtime::ExtensionExecutor;
use tenferro_cpu::CpuBackend;

let executor = ExtensionExecutor::<CpuBackend>::new();
assert_eq!(executor.cache_stats().entries, 0);

pub fn with_parts( registry: ExtensionRegistry<B>, caches: ExtensionCacheStore, ) -> ExtensionExecutor<B>

Create an executor from explicit registry and cache store.

pub fn registry(&self) -> &ExtensionRegistry<B>

Borrow the runtime executor registry.

pub fn registry_mut(&mut self) -> &mut ExtensionRegistry<B>

Borrow the runtime executor registry mutably.

pub fn caches(&self) -> &ExtensionCacheStore

Borrow the extension cache store.

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

Borrow the extension cache store mutably.

pub fn execute( &mut self, backend: &mut B, op: &(dyn ExtensionOp + 'static), inputs: &[&Tensor], ) -> Result<Vec<Tensor>, Error>

Execute an extension using a registered runtime executor.

pub fn execute_reads( &mut self, backend: &mut B, op: &(dyn ExtensionOp + 'static), inputs: &[TensorRead<'_>], ) -> Result<Vec<Tensor>, Error>

Execute an extension using borrowed tensor reads.

Examples

use std::any::Any;
use std::hash::Hasher;
use std::sync::Arc;

use tenferro_cpu::CpuBackend;
use tenferro_ops::{ext_op::ExtensionOp, SymDim};
use tenferro_runtime::{
    DType, ExtensionExecutionContext, ExtensionExecutor, ExtensionRuntime, Tensor,
};
use tenferro_tensor::TensorRead;

#[derive(Clone, Debug)]
struct IdentityOp;

impl ExtensionOp for IdentityOp {
    fn family_id(&self) -> &'static str {
        "example.identity.v1"
    }

    fn payload_hash(&self, _hasher: &mut dyn Hasher) {}

    fn payload_eq(&self, other: &dyn ExtensionOp) -> bool {
        other.as_any().is::<IdentityOp>()
    }

    fn clone_arc(&self) -> Arc<dyn ExtensionOp> {
        Arc::new(self.clone())
    }

    fn as_any(&self) -> &dyn Any {
        self
    }

    fn input_count(&self) -> usize {
        1
    }

    fn output_count(&self) -> usize {
        1
    }

    fn infer_output_meta(
        &self,
        input_dtypes: &[DType],
        input_shapes: &[&[SymDim]],
    ) -> Vec<(DType, Vec<SymDim>)> {
        vec![(input_dtypes[0], input_shapes[0].to_vec())]
    }

    fn eager_execute(&self, inputs: &[&Tensor]) -> tenferro_tensor::Result<Vec<Tensor>> {
        Ok(vec![inputs[0].clone()])
    }
}

#[derive(Debug)]
struct IdentityRuntime;

impl ExtensionRuntime<CpuBackend> for IdentityRuntime {
    fn family_id(&self) -> &'static str {
        "example.identity.v1"
    }

    fn execute(
        &self,
        op: &dyn ExtensionOp,
        inputs: &[&Tensor],
        _ctx: &mut ExtensionExecutionContext<'_, CpuBackend>,
    ) -> tenferro_tensor::Result<Vec<Tensor>> {
        op.eager_execute(inputs)
    }

    fn execute_reads(
        &self,
        op: &dyn ExtensionOp,
        inputs: &[TensorRead<'_>],
        ctx: &mut ExtensionExecutionContext<'_, CpuBackend>,
    ) -> tenferro_tensor::Result<Vec<Tensor>> {
        let materialized_inputs: Vec<Tensor> = inputs
            .iter()
            .map(TensorRead::to_tensor)
            .collect::<tenferro_tensor::Result<_>>()?;
        let input_refs: Vec<&Tensor> = materialized_inputs.iter().collect();
        self.execute(op, &input_refs, ctx)
    }
}

let mut executor = ExtensionExecutor::<CpuBackend>::new();
executor.registry_mut().register(Arc::new(IdentityRuntime))?;
let input = Tensor::from_vec_col_major(vec![2], vec![1.0_f64, 2.0]).unwrap();
let read = TensorRead::from_tensor(&input);
let mut backend = CpuBackend::new();

let outputs = executor.execute_reads(&mut backend, &IdentityOp, &[read])?;

assert_eq!(outputs[0].as_slice::<f64>().unwrap(), &[1.0, 2.0]);

pub fn clear_caches(&mut self)

Clear every runtime extension cache entry.

pub fn cache_stats(&self) -> CacheStats

Return extension cache stats for all entries.

pub fn cache_limits(&self) -> ExtensionCacheLimits

Return the extension cache retention limits.

pub fn set_cache_limits(&mut self, limits: ExtensionCacheLimits)

Replace extension cache retention limits.

Trait Implementations

impl<B> Debug for ExtensionExecutor<B>

where B: TensorBackend + 'static,

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

Formats the value using the given formatter.

impl<B> Default for ExtensionExecutor<B>

where B: TensorBackend + 'static,

fn default() -> ExtensionExecutor<B>

Returns the “default value” for a type.