Struct tract_core::plan::SimpleState

pub struct SimpleState<F, O, M, P> where
    F: Fact + Hash + Clone + 'static,
    O: Debug + Display + AsRef<dyn Op> + AsMut<dyn Op> + Clone + 'static + Hash,
    M: Borrow<Graph<F, O>> + Hash,
    P: Borrow<SimplePlan<F, O, M>>,  {
    pub states: Vec<Option<Box<dyn OpState>>>,
    pub session_state: SessionState,
    pub values: Vec<Option<TVec<Arc<Tensor>>>>,
    // some fields omitted
}

Fields

states: Vec<Option<Box<dyn OpState>>>

session_state: SessionState

values: Vec<Option<TVec<Arc<Tensor>>>>

Implementations

impl<F, O, M, P> SimpleState<F, O, M, P> where
    F: Fact + Hash + Clone + 'static,
    O: Debug + Display + AsRef<dyn Op> + AsMut<dyn Op> + Clone + 'static + Hash,
    M: Borrow<Graph<F, O>> + Hash,
    P: Borrow<SimplePlan<F, O, M>> + Clone, 

pub fn new(plan: P) -> TractResult<SimpleState<F, O, M, P>>

pub fn reset_wires(&mut self) -> TractResult<()>

Reset wires state.

pub fn reset_op_states(&mut self) -> TractResult<()>

Reset wires state.

pub fn run(&mut self, inputs: TVec<Tensor>) -> TractResult<TVec<Arc<Tensor>>>

pub fn run_plan_with_eval<Eval, E>(
    &mut self,
    inputs: TVec<Tensor>,
    eval: Eval
) -> TractResult<TVec<Arc<Tensor>>> where
    Eval: for<'a, 'b, 'c> FnMut(&'a mut SessionState, Option<&'b mut (dyn OpState + 'static)>, &'c Node<F, O>, TVec<Arc<Tensor>>) -> Result<TVec<Arc<Tensor>>, E>,
    E: Into<Error> + Send + Sync + 'static, 

pub fn set_inputs(&mut self, inputs: TVec<Tensor>) -> TractResult<()>

pub fn set_input(&mut self, input: usize, t: Tensor) -> TractResult<()>

pub fn take_outputs(&mut self) -> TractResult<Vec<Arc<Tensor>>>

pub fn set_values(&mut self, id: usize, values: TVec<Tensor>) -> TractResult<()>

pub fn set_value(&mut self, id: usize, value: Tensor) -> TractResult<()>

pub fn prepare_inputs(&self, node: usize) -> TractResult<TVec<Arc<Tensor>>>

pub fn compute_one(&mut self, node: usize) -> TractResult<()>

pub fn compute_one_with_inputs(
    &mut self,
    node: usize,
    inputs: TVec<Arc<Tensor>>
) -> TractResult<()>

pub fn compute_recursively(
    &mut self,
    node: usize
) -> TractResult<&[Arc<Tensor>]>

pub fn take_by_name(&mut self, name: &str) -> TractResult<TVec<Tensor>>

pub fn take(&mut self, id: usize) -> TractResult<TVec<Tensor>>

pub fn plan(&self) -> &SimplePlan<F, O, M>

pub fn model(&self) -> &Graph<F, O>

Trait Implementations

impl<F: Clone, O: Clone, M: Clone, P: Clone> Clone for SimpleState<F, O, M, P> where
    F: Fact + Hash + Clone + 'static,
    O: Debug + Display + AsRef<dyn Op> + AsMut<dyn Op> + Clone + 'static + Hash,
    M: Borrow<Graph<F, O>> + Hash,
    P: Borrow<SimplePlan<F, O, M>>, 

fn clone(&self) -> SimpleState<F, O, M, P>

Returns a copy of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl<F: Debug, O: Debug, M: Debug, P: Debug> Debug for SimpleState<F, O, M, P> where
    F: Fact + Hash + Clone + 'static,
    O: Debug + Display + AsRef<dyn Op> + AsMut<dyn Op> + Clone + 'static + Hash,
    M: Borrow<Graph<F, O>> + Hash,
    P: Borrow<SimplePlan<F, O, M>>, 

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

Formats the value using the given formatter.