vendor/chalk-solve-0.14.0/src/solve/test/bench.rs

   1 //! Benchmarking tests.
   2
   3 extern crate test;
   4 use self::test::Bencher;
   5
   6 use crate::db::ChalkDatabase;
   7 use crate::query::{ProgramSolverChoice, ProgramText};
   8 use chalk_solve::SolverChoice;
   9 use ir;
  10 use std::sync::Arc;
  11
  12 use super::{assert_result, parse_and_lower_goal, parse_and_lower_program};
  13
  14 fn run_bench(
  15     program_text: &str,
  16     solver_choice: SolverChoice,
  17     goal_text: &str,
  18     bencher: &mut Bencher,
  19     expected: &str,
  20 ) {
  21     ChalkDatabase::with_program(Arc::new(program_text.to_string()), solver_choice, |db| {
  22         let program = db.lowered_program().unwrap();
  23         let env = db.environment().unwrap();
  24         ir::tls::set_current_program(&program, || {
  25             let goal = parse_and_lower_goal(&program, goal_text).unwrap();
  26             let peeled_goal = goal.into_peeled_goal();
  27
  28             // Execute once to get an expected result.
  29             let result = solver_choice.solve_root_goal(&env, &peeled_goal);
  30
  31             // Check expectation.
  32             assert_result(&result, expected);
  33
  34             // Then do it many times to measure time.
  35             bencher.iter(|| solver_choice.solve_root_goal(&env, &peeled_goal));
  36         });
  37     });
  38 }
  39
  40 const CYCLEY: &str = "
  41 trait AsRef<T> { }
  42 trait Clone { }
  43 trait Copy where Self: Clone { }
  44 trait Sized { }
  45
  46 struct i32 { }
  47 impl Copy for i32 { }
  48 impl Clone for i32 { }
  49 impl Sized for i32 { }
  50
  51 struct u32 { }
  52 impl Copy for u32 { }
  53 impl Clone for u32 { }
  54 impl Sized for u32 { }
  55
  56 struct Rc<T> { }
  57 impl<T> Clone for Rc<T> { }
  58 impl<T> Sized for Rc<T> { }
  59
  60 struct Box<T> { }
  61 impl<T> AsRef<T> for Box<T> where T: Sized { }
  62 impl<T> Clone for Box<T> where T: Clone { }
  63 impl<T> Sized for Box<T> { }
  64
  65 // Meant to be [T]
  66 struct Slice<T> where T: Sized { }
  67 impl<T> Sized for Slice<T> { }
  68 impl<T> AsRef<Slice<T>> for Slice<T> where T: Sized { }
  69
  70 struct Vec<T> where T: Sized { }
  71 impl<T> AsRef<Slice<T>> for Vec<T> where T: Sized { }
  72 impl<T> AsRef<Vec<T>> for Vec<T> where T: Sized { }
  73 impl<T> Clone for Vec<T> where T: Clone, T: Sized { }
  74 impl<T> Sized for Vec<T> where T: Sized { }
  75
  76 trait SliceExt
  77   where <Self as SliceExt>::Item: Clone
  78 {
  79   type Item;
  80 }
  81
  82 impl<T> SliceExt for Slice<T>
  83   where T: Clone
  84 {
  85   type Item = T;
  86 }
  87 ";
  88
  89 const CYCLEY_GOAL: &str = "
  90 forall<T> {
  91     if (
  92         <Slice<T> as SliceExt>::Item: Clone;
  93         <Slice<T> as SliceExt>::Item: Sized;
  94         T: Clone;
  95         T: Sized
  96     ) {
  97         T: Sized
  98     }
  99 }
 100 ";
 101
 102 #[bench]
 103 fn cycley_slg(b: &mut Bencher) {
 104     run_bench(
 105         CYCLEY,
 106         SolverChoice::SLG { max_size: 20 },
 107         CYCLEY_GOAL,
 108         b,
 109         "Unique",
 110     );
 111 }