Struct ExtensionExecutor 

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

Runtime owner for backend-specific extension dispatch and caches.

Implementations

impl<B: TensorBackend + 'static> ExtensionExecutor<B>

pub fn new() -> Self

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, ) -> Self

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, inputs: &[&Tensor], ) -> Result<Vec<Tensor>>

Execute an extension using a registered runtime executor.

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

Execute an extension using borrowed tensor reads.

Examples

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

use tenferro_cpu::CpuBackend;
use tenferro_ops::{ext_op::{ExtensionOp, HostReference}, SymDim};
use tenferro_runtime::{DType, ExtensionExecutor, HostReferenceRuntime, 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 std::hash::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]],
    ) -> tenferro_tensor::Result<Vec<(DType, Vec<SymDim>)>> {
        Ok(vec![(input_dtypes[0], input_shapes[0].to_vec())])
    }

    fn host_reference(&self) -> Option<&dyn HostReference> {
        Some(self)
    }
}

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

let mut executor = ExtensionExecutor::<CpuBackend>::new();
executor
    .registry_mut()
    .register(Arc::new(HostReferenceRuntime::<CpuBackend>::new(
        "example.identity.v1",
    )))?;
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: TensorBackend + 'static> Debug for ExtensionExecutor<B>

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

Formats the value using the given formatter.

impl<B: TensorBackend + 'static> Default for ExtensionExecutor<B>

fn default() -> Self

Returns the “default value” for a type.