delete some stuff

Author: ajpal

tests/bv128.rs

@@ -6,70 +6,3 @@ ruler::impl_bv!(128);
 
 #[path = "./recipes/bv4_fancy.rs"]
 pub mod bv4_fancy;
-
-#[cfg(test)]
-pub mod test {
-    use std::time::{Duration, Instant};
-
-    use crate::bv4_fancy::bv4_fancy_rules;
-
-    use ruler::{
-        enumo::{self, Ruleset},
-        logger,
-        recipe_utils::{recursive_rules, Lang},
-    };
-
-    use crate::Bv;
-
-    fn gen() -> (Ruleset<Bv>, Duration) {
-        let start = Instant::now();
-        let mut rules: Ruleset<Bv> = Ruleset::default();
-        let lang = Lang::new(
-            &["0", "1"],
-            &["a", "b", "c"],
-            &[&["~", "-"], &["&", "|", "*", "--", "+", "<<", ">>"]],
-        );
-        rules.extend(recursive_rules(
-            enumo::Metric::Atoms,
-            5,
-            lang.clone(),
-            Ruleset::default(),
-        ));
-
-        // too slow for 128
-        // let a6_canon = iter_metric(base_lang(2), "EXPR", enumo::Metric::Atoms, 6)
-        //     .plug("VAR", &Workload::new(lang.vars))
-        //     .plug("VAL", &Workload::empty())
-        //     .plug("OP1", &Workload::new(lang.uops))
-        //     .plug("OP2", &Workload::new(lang.bops))
-        //     .filter(Filter::Canon(vec![
-        //         "a".to_string(),
-        //         "b".to_string(),
-        //         "c".to_string(),
-        //     ]));
-        // let consts = Workload::new(["0", "1"]);
-        // let wkld = Workload::Append(vec![a6_canon, consts]);
-        // rules.extend(run_workload(
-        //     wkld,
-        //     rules.clone(),
-        //     Limits::rulefinding(),
-        //     true,
-        // ));
-
-        let duration = start.elapsed();
-        (rules, duration)
-    }
-
-    #[test]
-    fn compare() {
-        let domain = "BV128";
-        // Port the bv4 rules into domain
-        let actual_bv4_rules: Ruleset<_> = bv4_fancy_rules();
-        let ported_bv4_rules: Ruleset<Bv> = Ruleset::new(actual_bv4_rules.to_str_vec());
-
-        // Generate the rules directly
-        let (gen, gen_time): (Ruleset<Bv>, Duration) = gen();
-
-        logger::write_bv_derivability(domain, gen, gen_time, ported_bv4_rules)
-    }
-}

tests/bv64.rs

@@ -6,71 +6,3 @@ ruler::impl_bv!(64);
 
 #[path = "./recipes/bv4_fancy.rs"]
 pub mod bv4_fancy;
-
-#[cfg(test)]
-pub mod test {
-    use std::time::{Duration, Instant};
-
-    use crate::bv4_fancy::bv4_fancy_rules;
-
-    use ruler::{
-        enumo::{self, Filter, Ruleset, Workload},
-        logger,
-        recipe_utils::{base_lang, iter_metric, recursive_rules, run_workload, Lang},
-        Limits,
-    };
-
-    use crate::Bv;
-
-    fn gen() -> (Ruleset<Bv>, Duration) {
-        let start = Instant::now();
-        let mut rules: Ruleset<Bv> = Ruleset::default();
-        let lang = Lang::new(
-            &["0", "1"],
-            &["a", "b", "c"],
-            &[&["~", "-"], &["&", "|", "*", "--", "+", "<<", ">>"]],
-        );
-        rules.extend(recursive_rules(
-            enumo::Metric::Atoms,
-            5,
-            lang.clone(),
-            Ruleset::default(),
-        ));
-
-        let a6_canon = iter_metric(base_lang(2), "EXPR", enumo::Metric::Atoms, 6)
-            .plug("VAR", &Workload::new(lang.vars))
-            .plug("VAL", &Workload::empty())
-            .plug("OP1", &Workload::new(lang.ops[0].clone()))
-            .plug("OP2", &Workload::new(lang.ops[1].clone()))
-            .filter(Filter::Canon(vec![
-                "a".to_string(),
-                "b".to_string(),
-                "c".to_string(),
-            ]));
-        let consts = Workload::new(["0", "1"]);
-        let wkld = Workload::Append(vec![a6_canon, consts]);
-        rules.extend(run_workload(
-            wkld,
-            rules.clone(),
-            Limits::synthesis(),
-            Limits::minimize(),
-            true,
-        ));
-
-        let duration = start.elapsed();
-        (rules, duration)
-    }
-
-    #[test]
-    fn compare() {
-        let domain = "BV64";
-        // Port the bv4 rules into domain
-        let actual_bv4_rules: Ruleset<_> = bv4_fancy_rules();
-        let ported_bv4_rules: Ruleset<Bv> = Ruleset::new(actual_bv4_rules.to_str_vec());
-
-        // Generate the rules directly
-        let (gen, gen_time): (Ruleset<Bv>, Duration) = gen();
-
-        logger::write_bv_derivability(domain, gen, gen_time, ported_bv4_rules)
-    }
-}

tests/halide.rs

@@ -284,48 +284,3 @@ fn egg_to_z3<'a>(ctx: &'a z3::Context, expr: &[Pred]) -> z3::ast::Int<'a> {
 #[cfg(test)]
 #[path = "./recipes/halide.rs"]
 mod halide;
-
-mod test {
-    use crate::halide::halide_rules;
-    use crate::Pred;
-    use std::time::{Duration, Instant};
-
-    use ruler::{
-        enumo::{Filter, Metric, Ruleset, Workload},
-        logger,
-        recipe_utils::{recursive_rules, run_workload, Lang},
-        Limits,
-    };
-
-    #[test]
-    fn run() {
-        // Skip this test in github actions
-        if std::env::var("CI").is_ok() && std::env::var("SKIP_RECIPES").is_ok() {
-            return;
-        }
-
-        let start = Instant::now();
-        let all_rules = halide_rules();
-        let duration = start.elapsed();
-
-        // oopsla-halide-baseline branch
-        // Run on nightly 4/12/2023
-        // time cargo run --release --bin halide -- synth --iters 1 --use-smt
-        // real	0m2.707s
-        // user	0m2.681s
-        // sys	0m0.028s
-        let baseline: Ruleset<Pred> = Ruleset::from_file("baseline/halide.rules");
-        let oopsla_halide: Ruleset<Pred> = Ruleset::from_file("baseline/oopsla-halide.rules");
-        let oopsla_duration = Duration::from_secs_f32(3.354);
-
-        logger::write_baseline(&all_rules, "halide", &baseline, "halide", duration);
-
-        logger::write_baseline(
-            &oopsla_halide,
-            "oopsla halide (1 iter)",
-            &baseline,
-            "halide",
-            oopsla_duration,
-        );
-    }
-}