modify benchmarks to support either in-place or persistent

Author: nikomatsakis

src/unify/tests.rs

@@ -8,6 +8,10 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
+// Naming the benchmarks using uppercase letters helps them sort
+// better.
+#![allow(non_snake_case)]
+
 #[cfg(feature = "bench")]
 extern crate test;
 #[cfg(feature = "bench")]
@@ -112,16 +116,94 @@ fn big_array_bench_generic<S: UnificationStore<Key=UnitKey, Value=()>>(b: &mut B
 
 #[cfg(feature = "bench")]
 #[bench]
-fn big_array_bench_in_place(b: &mut Bencher) {
+fn big_array_bench_InPlace(b: &mut Bencher) {
     big_array_bench_generic::<InPlace<UnitKey>>(b);
 }
 
 #[cfg(all(feature = "bench", feature = "persistent"))]
 #[bench]
-fn big_array_bench_persistent(b: &mut Bencher) {
+fn big_array_bench_Persistent(b: &mut Bencher) {
     big_array_bench_generic::<Persistent<UnitKey>>(b);
 }
 
+#[cfg(feature = "bench")]
+fn big_array_bench_in_snapshot_generic<S: UnificationStore<Key=UnitKey, Value=()>>(b: &mut Bencher) {
+    let mut ut: UnificationTable<S> = UnificationTable::new();
+    let mut keys = Vec::new();
+    const MAX: usize = 1 << 15;
+
+    for _ in 0..MAX {
+        keys.push(ut.new_key(()));
+    }
+
+    b.iter(|| {
+        let snapshot = ut.snapshot();
+
+        for i in 1..MAX {
+            let l = keys[i - 1];
+            let r = keys[i];
+            ut.union(l, r);
+        }
+
+        for i in 0..MAX {
+            assert!(ut.unioned(keys[0], keys[i]));
+        }
+
+        ut.rollback_to(snapshot);
+    })
+}
+
+#[cfg(feature = "bench")]
+#[bench]
+fn big_array_bench_in_snapshot_InPlace(b: &mut Bencher) {
+    big_array_bench_in_snapshot_generic::<InPlace<UnitKey>>(b);
+}
+
+#[cfg(all(feature = "bench", feature = "persistent"))]
+#[bench]
+fn big_array_bench_in_snapshot_Persistent(b: &mut Bencher) {
+    big_array_bench_in_snapshot_generic::<Persistent<UnitKey>>(b);
+}
+
+#[cfg(feature = "bench")]
+fn big_array_bench_clone_generic<S: UnificationStore<Key=UnitKey, Value=()>>(b: &mut Bencher) {
+    let mut ut: UnificationTable<S> = UnificationTable::new();
+    let mut keys = Vec::new();
+    const MAX: usize = 1 << 15;
+
+    for _ in 0..MAX {
+        keys.push(ut.new_key(()));
+    }
+
+    b.iter(|| {
+        let saved_table = ut.clone();
+
+        for i in 1..MAX {
+            let l = keys[i - 1];
+            let r = keys[i];
+            ut.union(l, r);
+        }
+
+        for i in 0..MAX {
+            assert!(ut.unioned(keys[0], keys[i]));
+        }
+
+        ut = saved_table;
+    })
+}
+
+#[cfg(feature = "bench")]
+#[bench]
+fn big_array_bench_clone_InPlace(b: &mut Bencher) {
+    big_array_bench_clone_generic::<InPlace<UnitKey>>(b);
+}
+
+#[cfg(all(feature = "bench", feature = "persistent"))]
+#[bench]
+fn big_array_bench_clone_Persistent(b: &mut Bencher) {
+    big_array_bench_clone_generic::<Persistent<UnitKey>>(b);
+}
+
 #[test]
 fn even_odd() {
     all_modes! {