Struct LoggingScheduler

pub struct LoggingScheduler<'a, S, L, N> { /* private fields */ }

Implementations

impl<'a, S, L, N> LoggingScheduler<'a, S, L, N>

pub fn new(scheduler: S) -> Self

pub fn with_identifier(self, id: impl ToString) -> Self

pub fn with_out_file<W: Write + 'a>(self, out_file: W) -> Self

Examples found in repository

examples/simple.rs (lines 51-58)

fn simplify_with(
    s: &str,
    scheduler: impl RewriteScheduler<SimpleLanguage, ()> + 'static,
    path: impl AsRef<Path>,
) {
    // parse the expression, the type annotation tells it which Language to use
    let expr: RecExpr<SimpleLanguage> = s.parse().unwrap();

    let mut egraph = EGraph::new(());
    let root = egraph.add_expr(&expr);

    // simplify the expression using a Runner, which creates an e-graph with
    // the given expression and runs the given rules over it
    Runner::default()
        .with_scheduler(
            LoggingScheduler::from(scheduler)
                .with_out_file(
                    OpenOptions::new()
                        .write(true)
                        .create(true)
                        .truncate(true)
                        .open(path.as_ref())
                        .unwrap(),
                )
                .with_logging_enabled(true)
                .with_recorder(recorders::Timestamp::new(Instant::now()))
                .with_recorder(recorders::NumberENodes)
                .with_recorder(recorders::NumberEClasses)
                .with_recorder(recorders::BestProgram::new_with(|| AstSize, root)),
        )
        .with_egraph(egraph)
        .run(&make_rules());

    println!("Wrote {:?}", path.as_ref());
}

pub fn with_logging_enabled(self, enabled: bool) -> Self

Examples found in repository

examples/simple.rs (line 59)

fn simplify_with(
    s: &str,
    scheduler: impl RewriteScheduler<SimpleLanguage, ()> + 'static,
    path: impl AsRef<Path>,
) {
    // parse the expression, the type annotation tells it which Language to use
    let expr: RecExpr<SimpleLanguage> = s.parse().unwrap();

    let mut egraph = EGraph::new(());
    let root = egraph.add_expr(&expr);

    // simplify the expression using a Runner, which creates an e-graph with
    // the given expression and runs the given rules over it
    Runner::default()
        .with_scheduler(
            LoggingScheduler::from(scheduler)
                .with_out_file(
                    OpenOptions::new()
                        .write(true)
                        .create(true)
                        .truncate(true)
                        .open(path.as_ref())
                        .unwrap(),
                )
                .with_logging_enabled(true)
                .with_recorder(recorders::Timestamp::new(Instant::now()))
                .with_recorder(recorders::NumberENodes)
                .with_recorder(recorders::NumberEClasses)
                .with_recorder(recorders::BestProgram::new_with(|| AstSize, root)),
        )
        .with_egraph(egraph)
        .run(&make_rules());

    println!("Wrote {:?}", path.as_ref());
}

pub fn with_recorder<D: Recorder<L, N> + 'a>(self, datum: D) -> Self

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

Examples found in repository

examples/simple.rs (line 60)

fn simplify_with(
    s: &str,
    scheduler: impl RewriteScheduler<SimpleLanguage, ()> + 'static,
    path: impl AsRef<Path>,
) {
    // parse the expression, the type annotation tells it which Language to use
    let expr: RecExpr<SimpleLanguage> = s.parse().unwrap();

    let mut egraph = EGraph::new(());
    let root = egraph.add_expr(&expr);

    // simplify the expression using a Runner, which creates an e-graph with
    // the given expression and runs the given rules over it
    Runner::default()
        .with_scheduler(
            LoggingScheduler::from(scheduler)
                .with_out_file(
                    OpenOptions::new()
                        .write(true)
                        .create(true)
                        .truncate(true)
                        .open(path.as_ref())
                        .unwrap(),
                )
                .with_logging_enabled(true)
                .with_recorder(recorders::Timestamp::new(Instant::now()))
                .with_recorder(recorders::NumberENodes)
                .with_recorder(recorders::NumberEClasses)
                .with_recorder(recorders::BestProgram::new_with(|| AstSize, root)),
        )
        .with_egraph(egraph)
        .run(&make_rules());

    println!("Wrote {:?}", path.as_ref());
}

pub fn identifier(&mut self, id: impl ToString) -> &mut Self

pub fn out_file(&mut self, out_file: impl Write + 'a) -> &mut Self

pub fn logging_enabled(&mut self, enabled: bool) -> &mut Self

pub fn record<D: Recorder<L, N> + 'a>(&mut self, datum: D) -> &mut Self

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

Trait Implementations

impl<'a, S, L, N> From<S> for LoggingScheduler<'a, S, L, N>

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

fn from(value: S) -> Self

Converts to this type from the input type.

impl<'a, S, L, N> RewriteScheduler<L, N> for LoggingScheduler<'a, S, L, N>

where S: RewriteScheduler<L, N>, L: Language + Display, N: Analysis<L>,

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

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

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

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

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.