Struct LazyExecutor 

pub struct LazyExecutor { /* private fields */ }

A lazy executor that caches computed tensors by node index.

All tensor operations are delegated to an inner Scirs2Exec; the cache layer sits above it and avoids redundant work when the same node is requested multiple times (e.g. during iterative training with a static graph).

Implementations

impl LazyExecutor

pub fn new() -> Self

Create a new LazyExecutor with an empty cache.

pub fn with_capacity(capacity: usize) -> Self

Create a LazyExecutor with a pre-allocated cache capacity.

pub fn invalidate_cache(&mut self)

Discard all cached tensors.

pub fn invalidate_node(&mut self, node_id: usize)

Remove a single node from the cache. The next access to that node will be a miss and will increment tensors_recomputed.

pub fn stats(&self) -> &LazyStats

Read-only reference to the accumulated statistics.

pub fn memory_estimate_for(&self, graph: &EinsumGraph) -> usize

Rough total memory estimate for all tensors currently held by graph.

Computed as number_of_nodes * average_cached_tensor_size — a simple heuristic based on what is already in the cache.

pub fn cached_count(&self) -> usize

Number of tensors currently in the cache.

impl LazyExecutor

pub fn get_cached(&mut self, node_id: usize) -> Option<Scirs2Tensor>

Retrieve a cached tensor for the given node index (if available).

This is the primary entry-point for lazy graph traversal: call this before scheduling a node for execution. On a hit the value is returned without calling any inner operations.

pub fn put_cached(&mut self, node_id: usize, tensor: Scirs2Tensor)

Store a tensor result for a node. Subsequent calls to get_cached(node_id) will return this value.

pub fn inner_mut(&mut self) -> &mut Scirs2Exec

Access the inner Scirs2Exec (e.g. to register input tensors).

Trait Implementations

impl Default for LazyExecutor

fn default() -> Self

Returns the “default value” for a type.

impl TlAutodiff for LazyExecutor

fn forward(&mut self, graph: &EinsumGraph) -> Result<Self::Tensor, Self::Error>

Execute the forward pass, caching every node output.

Node outputs are stored in self.cache keyed by their index in graph.nodes so that subsequent forward calls on the same (or an overlapping) graph reuse already-computed tensors.

fn backward( &mut self, graph: &EinsumGraph, loss: &Self::Tensor, ) -> Result<Self::Tape, Self::Error>

Execute the backward pass, delegating to the inner executor.

type Tape = ForwardTape

impl TlExecutor for LazyExecutor

type Tensor = ArrayBase<OwnedRepr<f64>, Dim<IxDynImpl>>

type Error = ExecutorError

fn einsum( &mut self, spec: &str, inputs: &[Self::Tensor], ) -> Result<Self::Tensor, Self::Error>

Execute an einsum operation on input tensors.

fn elem_op( &mut self, op: ElemOp, x: &Self::Tensor, ) -> Result<Self::Tensor, Self::Error>

Apply an element-wise unary operation.

fn elem_op_binary( &mut self, op: ElemOp, x: &Self::Tensor, y: &Self::Tensor, ) -> Result<Self::Tensor, Self::Error>

Apply an element-wise binary operation.

fn reduce( &mut self, op: ReduceOp, x: &Self::Tensor, axes: &[usize], ) -> Result<Self::Tensor, Self::Error>

Reduce a tensor along specified axes.