Trait egg::RewriteScheduler

pub trait RewriteScheduler<L, N>
where
    L: Language,
    N: Analysis<L>,
{
    // Provided methods
    fn can_stop(&mut self, iteration: usize) -> bool { ... }
    fn search_rewrite<'a>(
        &mut self,
        iteration: usize,
        egraph: &EGraph<L, N>,
        rewrite: &'a Rewrite<L, N>
    ) -> Vec<SearchMatches<'a, L>> { ... }
    fn search_rewrites<'a>(
        &mut self,
        iteration: usize,
        egraph: &EGraph<L, N>,
        rewrites: &[&'a Rewrite<L, N>],
        limits: &RunnerLimits
    ) -> RunnerResult<Vec<Vec<SearchMatches<'a, L>>>> { ... }
    fn apply_rewrite(
        &mut self,
        iteration: usize,
        egraph: &mut EGraph<L, N>,
        rewrite: &Rewrite<L, N>,
        matches: Vec<SearchMatches<'_, L>>
    ) -> usize { ... }
}

A way to customize how a Runner runs Rewrites.

This gives you a way to prevent certain Rewrites from exploding the EGraph and dominating how much time is spent while running the Runner.

Provided Methods

fn can_stop(&mut self, iteration: usize) -> bool

Whether or not the Runner is allowed to say it has saturated.

This is only called when the runner is otherwise saturated. Default implementation just returns true.

fn search_rewrite<'a>( &mut self, iteration: usize, egraph: &EGraph<L, N>, rewrite: &'a Rewrite<L, N> ) -> Vec<SearchMatches<'a, L>>

A hook allowing you to customize rewrite searching behavior. Useful to implement rule management.

Default implementation just calls Rewrite::search.

fn search_rewrites<'a>( &mut self, iteration: usize, egraph: &EGraph<L, N>, rewrites: &[&'a Rewrite<L, N>], limits: &RunnerLimits ) -> RunnerResult<Vec<Vec<SearchMatches<'a, L>>>>

A hook allowing you to customize rewrite searching behavior across rewrites.

Default implementation calls Self::search_rewrite for each rewrite, and checks RunnerLimits::check_limits after each.

Returning an error will stop the runner.

You might use this to implement parallel rule application:

pub struct ParallelRewriteScheduler;
impl RewriteScheduler<SymbolLang, ()> for ParallelRewriteScheduler {
    fn search_rewrites<'a>(
        &mut self,
        iteration: usize,
        egraph: &EGraph<SymbolLang, ()>,
        rewrites: &[&'a Rewrite<SymbolLang, ()>],
        _limits: &RunnerLimits,
    ) -> RunnerResult<Vec<Vec<SearchMatches<'a, SymbolLang>>>> {
        // this implementation just ignores the limits
        // fake `par_map` to enforce Send + Sync, in real life use rayon
        fn par_map<T, F, T2>(slice: &[T], f: F) -> Vec<T2>
        where
            T: Send + Sync,
            F: Fn(&T) -> T2 + Send + Sync,
            T2: Send + Sync,
        {
            slice.iter().map(f).collect()
        }
        Ok(par_map(rewrites, |rw| rw.search(egraph)))
    }
}

fn apply_rewrite( &mut self, iteration: usize, egraph: &mut EGraph<L, N>, rewrite: &Rewrite<L, N>, matches: Vec<SearchMatches<'_, L>> ) -> usize

A hook allowing you to customize rewrite application behavior. Useful to implement rule management.

Default implementation just calls Rewrite::apply and returns number of new applications.

Implementors

impl<L, N> RewriteScheduler<L, N> for BackoffScheduler

where L: Language, N: Analysis<L>,

impl<L, N> RewriteScheduler<L, N> for SimpleScheduler

where L: Language, N: Analysis<L>,