Struct tract_core::optim::OptimizerSession

pub struct OptimizerSession<'o> { /* private fields */ }

Implementations

impl<'o> OptimizerSession<'o>

pub fn optimize(&mut self, model: &mut TypedModel) -> TractResult<()>

Examples found in repository

src/optim/mod.rs (line 73)

    pub fn optimize(&self, model: &mut TypedModel) -> TractResult<()> {
        self.session().optimize(model)
    }

src/model/typed.rs (line 153)

    pub fn declutter(&mut self) -> TractResult<()> {
        crate::optim::Optimizer::declutter().session().optimize(self)
    }

    /// Perform optimization passes on the model, using a given optimizer session.
    pub fn optimize_with_session(&mut self, session: &mut OptimizerSession) -> TractResult<()> {
        session.optimize(self)
    }

src/ops/scan/mir.rs (line 69)

    fn declutter_body(
        &self,
        session: &mut OptimizerSession,
        model: &TypedModel,
        node: &TypedNode,
    ) -> TractResult<Option<TypedModelPatch>> {
        if !self.decluttered {
            let mut new = self.clone();
            let mut body = self.body.clone();
            session.optimize(&mut body)?;
            new.body = body;
            new.decluttered = true;
            Ok(Some(TypedModelPatch::replace_single_op(model, node, &node.inputs, new)?))
        } else {
            Ok(None)
        }
    }

pub fn run_all_passes(
    &mut self,
    i: usize,
    model: &mut TypedModel
) -> TractResult<()>

Examples found in repository

src/optim/mod.rs (line 94)

    pub fn optimize(&mut self, model: &mut TypedModel) -> TractResult<()> {
        model.check_consistency().context("during optimizer preflight check")?;
        model.compact().context("during optimizer preflight compaction")?;
        for i in 0.. {
            let old = self.counter;
            self.run_all_passes(i, model)?;
            if old == self.counter {
                return Ok(());
            }
            model.compact()?;
        }
        unreachable!()
    }

pub fn run_one_pass_outer(
    &mut self,
    i: usize,
    p: &mut dyn TypedPass,
    model: &mut TypedModel
) -> TractResult<()>

Examples found in repository

src/optim/mod.rs (line 106)

    pub fn run_all_passes(&mut self, i: usize, model: &mut TypedModel) -> TractResult<()> {
        let mut passes = self.optimizer.passes.clone();
        for p in passes.iter_mut() {
            self.run_one_pass_outer(i, p.as_mut(), model)
                .with_context(|| format!("running pass {:?}", p))?;
            model.compact()?;
            model
                .check_consistency()
                .with_context(|| format!("consistency check after pass {:?}", p))?;
        }
        Ok(())
    }

pub fn run_one_pass_inner(
    &mut self,
    i: usize,
    p: &mut dyn TypedPass,
    model: &mut TypedModel
) -> TractResult<()>

Examples found in repository

src/optim/mod.rs (line 124)

    pub fn run_one_pass_outer(
        &mut self,
        i: usize,
        p: &mut dyn TypedPass,
        model: &mut TypedModel,
    ) -> TractResult<()> {
        loop {
            let old_counter = self.counter;
            self.run_one_pass_inner(i, p, model)?;
            if self.counter == old_counter {
                return Ok(());
            }
            model.compact().with_context(|| format!("after pass {:?}", p))?;
        }
    }

Trait Implementations

impl<'o> Debug for OptimizerSession<'o>

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

Formats the value using the given formatter.