Struct Timestamp 

pub struct Timestamp { /* private fields */ }

Implementations

impl Timestamp

pub fn new(start: Instant) -> Self

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());
}

Trait Implementations

impl Default for Timestamp

fn default() -> Self

Returns the “default value” for a type.

impl<L, N> Recorder<L, N> for Timestamp

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

fn identifier(&self) -> Cow<'static, str>

fn record_before_rewrite( &self, iteration: usize, egraph: &mut EGraph<L, N>, rewrite: &Rewrite<L, N>, matches: &[SearchMatches<'_, L>], ) -> Option<String>

fn record_after_rewrite( &self, iteration: usize, egraph: &mut EGraph<L, N>, rewrite: &Rewrite<L, N>, n_matches: usize, ) -> Option<String>

fn record_before_search<'r>( &self, iteration: usize, egraph: &'r EGraph<L, N>, rewrite: &'r Rewrite<L, N>, ) -> Option<String>

fn record_after_search<'r>( &self, iteration: usize, egraph: &'r EGraph<L, N>, rewrite: &'r Rewrite<L, N>, matches: &[SearchMatches<'_, L>], ) -> Option<String>