Add thunderdome to benches
2 files changed, 140 insertions(+), 58 deletions(-)

M Cargo.toml
M benches/bench_basic.rs
M Cargo.toml +1 -0
@@ 22,6 22,7 @@ criterion = "0.3"
 slotmap = "0.4"
 handy = "0.1"
 generational-arena = "0.2"
+thunderdome = "0.4"
 
 [[bench]]
 name = "bench_basic"

          
M benches/bench_basic.rs +139 -58
@@ 4,28 4,25 @@ 
 //! `criterion.rs`.  They may be interesting, maybe even slightly
 //! useful, but do not take them as authorative.
 
-#[macro_use]
-extern crate criterion;
+use criterion::{black_box, criterion_group, criterion_main, BenchmarkId, Criterion};
 
-use criterion::black_box;
-use criterion::BenchmarkId;
-use criterion::Criterion;
-
+use generational_arena as ga;
 use genmap;
 use handy;
 use slotmap;
-use generational_arena as ga;
+use thunderdome;
+
+const KB: usize = 1024;
+const SIZES: [usize; 3] = [KB, 4 * KB, 16 * KB];
 
 fn insert_elems(c: &mut Criterion) {
-    static KB: usize = 1024;
-
     let mut group = c.benchmark_group("add_many");
-    for size in [KB, 2 * KB, 4 * KB, 8 * KB, 16 * KB].iter() {
+    for size in SIZES.iter() {
         group.bench_with_input(BenchmarkId::new("genmap", size), size, |b, &size| {
             b.iter(|| {
                 let map = &mut genmap::GenMap::default();
                 for i in 0..size {
-                    map.insert(i);
+                    map.insert(black_box(i));
                 }
             });
         });

          
@@ 34,7 31,7 @@ fn insert_elems(c: &mut Criterion) {
             b.iter(|| {
                 let map = &mut slotmap::SlotMap::new();
                 for i in 0..size {
-                    map.insert(i);
+                    map.insert(black_box(i));
                 }
             });
         });

          
@@ 43,7 40,7 @@ fn insert_elems(c: &mut Criterion) {
             b.iter(|| {
                 let map = &mut slotmap::dense::DenseSlotMap::new();
                 for i in 0..size {
-                    map.insert(i);
+                    map.insert(black_box(i));
                 }
             });
         });

          
@@ 52,15 49,27 @@ fn insert_elems(c: &mut Criterion) {
             b.iter(|| {
                 let map = &mut handy::HandleMap::new();
                 for i in 0..size {
-                    map.insert(i);
+                    map.insert(black_box(i));
                 }
             });
         });
-        group.bench_with_input(BenchmarkId::new("generational_arena", size), size, |b, &size| {
+        group.bench_with_input(
+            BenchmarkId::new("generational_arena", size),
+            size,
+            |b, &size| {
+                b.iter(|| {
+                    let map = &mut ga::Arena::new();
+                    for i in 0..size {
+                        map.insert(black_box(i));
+                    }
+                });
+            },
+        );
+        group.bench_with_input(BenchmarkId::new("thunderdome", size), size, |b, &size| {
             b.iter(|| {
-                let map = &mut ga::Arena::new();
+                let map = &mut thunderdome::Arena::new();
                 for i in 0..size {
-                    map.insert(i);
+                    map.insert(black_box(i));
                 }
             });
         });

          
@@ 69,19 78,17 @@ fn insert_elems(c: &mut Criterion) {
 }
 
 fn insert_and_remove_elems(c: &mut Criterion) {
-    static KB: usize = 1024;
-
     let mut group = c.benchmark_group("add_remove_many");
-    for size in [KB, 2 * KB, 4 * KB, 8 * KB, 16 * KB].iter() {
+    for size in SIZES.iter() {
         group.bench_with_input(BenchmarkId::new("genmap", size), size, |b, &size| {
             let map = &mut genmap::GenMap::default();
             b.iter(|| {
                 let keys = &mut vec![];
                 for i in 0..size {
-                    keys.push(map.insert(i));
+                    keys.push(map.insert(black_box(i)));
                 }
                 for i in keys {
-                    map.remove(*i);
+                    map.remove(black_box(*i));
                 }
             })
         });

          
@@ 92,10 99,10 @@ fn insert_and_remove_elems(c: &mut Crite
             b.iter(|| {
                 let keys = &mut vec![];
                 for i in 0..size {
-                    keys.push(map.insert(i));
+                    keys.push(map.insert(black_box(i)));
                 }
                 for i in keys {
-                    map.remove(*i);
+                    map.remove(black_box(*i));
                 }
             });
         });

          
@@ 105,10 112,10 @@ fn insert_and_remove_elems(c: &mut Crite
             b.iter(|| {
                 let keys: &mut Vec<slotmap::DefaultKey> = &mut vec![];
                 for i in 0..size {
-                    keys.push(map.insert(i));
+                    keys.push(map.insert(black_box(i)));
                 }
                 for i in keys {
-                    map.remove(*i);
+                    map.remove(black_box(*i));
                 }
             });
         });

          
@@ 118,22 125,38 @@ fn insert_and_remove_elems(c: &mut Crite
             b.iter(|| {
                 let keys = &mut vec![];
                 for i in 0..size {
-                    keys.push(map.insert(i));
+                    keys.push(map.insert(black_box(i)));
                 }
                 for i in keys {
-                    map.remove(*i);
+                    map.remove(black_box(*i));
                 }
             });
         });
-        group.bench_with_input(BenchmarkId::new("generational_arena", size), size, |b, &size| {
-            let map = &mut ga::Arena::new();
+        group.bench_with_input(
+            BenchmarkId::new("generational_arena", size),
+            size,
+            |b, &size| {
+                let map = &mut ga::Arena::new();
+                b.iter(|| {
+                    let keys = &mut vec![];
+                    for i in 0..size {
+                        keys.push(map.insert(black_box(i)));
+                    }
+                    for i in keys {
+                        map.remove(black_box(*i));
+                    }
+                });
+            },
+        );
+        group.bench_with_input(BenchmarkId::new("thunderdome", size), size, |b, &size| {
+            let map = &mut thunderdome::Arena::new();
             b.iter(|| {
                 let keys = &mut vec![];
                 for i in 0..size {
-                    keys.push(map.insert(i));
+                    keys.push(map.insert(black_box(i)));
                 }
                 for i in keys {
-                    map.remove(*i);
+                    map.remove(black_box(*i));
                 }
             });
         });

          
@@ 142,10 165,8 @@ fn insert_and_remove_elems(c: &mut Crite
 }
 
 fn remove_elems(c: &mut Criterion) {
-    static KB: usize = 1024;
-
     let mut group = c.benchmark_group("remove_many");
-    for size in [KB, 2 * KB, 4 * KB, 8 * KB, 16 * KB].iter() {
+    for size in SIZES.iter() {
         group.bench_with_input(BenchmarkId::new("genmap", size), size, |b, &size| {
             let map = &mut genmap::GenMap::default();
             let keys = &mut vec![];

          
@@ 154,7 175,7 @@ fn remove_elems(c: &mut Criterion) {
             }
             b.iter(|| {
                 for i in keys.iter() {
-                    map.remove(*i);
+                    map.remove(black_box(*i));
                 }
             })
         });

          
@@ 168,7 189,7 @@ fn remove_elems(c: &mut Criterion) {
             }
             b.iter(|| {
                 for i in keys.iter() {
-                    map.remove(*i);
+                    map.remove(black_box(*i));
                 }
             });
         });

          
@@ 181,7 202,7 @@ fn remove_elems(c: &mut Criterion) {
             }
             b.iter(|| {
                 for i in keys.iter() {
-                    map.remove(*i);
+                    map.remove(black_box(*i));
                 }
             });
         });

          
@@ 194,32 215,46 @@ fn remove_elems(c: &mut Criterion) {
             }
             b.iter(|| {
                 for i in keys.iter() {
-                    map.remove(*i);
+                    map.remove(black_box(*i));
                 }
             });
         });
 
-        group.bench_with_input(BenchmarkId::new("generational_arena", size), size, |b, &size| {
-            let map = &mut ga::Arena::new();
+        group.bench_with_input(
+            BenchmarkId::new("generational_arena", size),
+            size,
+            |b, &size| {
+                let map = &mut ga::Arena::new();
+                let keys = &mut vec![];
+                for i in 0..size {
+                    keys.push(map.insert(i));
+                }
+                b.iter(|| {
+                    for i in keys.iter() {
+                        map.remove(black_box(*i));
+                    }
+                });
+            },
+        );
+        group.bench_with_input(BenchmarkId::new("thunderdome", size), size, |b, &size| {
+            let map = &mut thunderdome::Arena::default();
             let keys = &mut vec![];
             for i in 0..size {
                 keys.push(map.insert(i));
             }
             b.iter(|| {
                 for i in keys.iter() {
-                    map.remove(*i);
+                    map.remove(black_box(*i));
                 }
-            });
+            })
         });
     }
     group.finish();
 }
 
 fn insert_lookup_and_remove_elems(c: &mut Criterion) {
-    static KB: usize = 1024;
-
     let mut group = c.benchmark_group("add_lookup_remove_many");
-    for size in [KB, 2 * KB, 4 * KB, 8 * KB, 16 * KB].iter() {
+    for size in SIZES.iter() {
         group.bench_with_input(BenchmarkId::new("genmap", size), size, |b, &size| {
             let map = &mut genmap::GenMap::default();
             b.iter(|| {

          
@@ 284,8 319,27 @@ fn insert_lookup_and_remove_elems(c: &mu
             });
         });
 
-        group.bench_with_input(BenchmarkId::new("generational_arena", size), size, |b, &size| {
-            let map = &mut ga::Arena::new();
+        group.bench_with_input(
+            BenchmarkId::new("generational_arena", size),
+            size,
+            |b, &size| {
+                let map = &mut ga::Arena::new();
+                b.iter(|| {
+                    let keys = &mut vec![];
+                    for i in 0..size {
+                        keys.push(map.insert(i));
+                    }
+                    for i in keys.iter() {
+                        let _ = black_box(map.get(*i));
+                    }
+                    for i in keys {
+                        map.remove(*i);
+                    }
+                });
+            },
+        );
+        group.bench_with_input(BenchmarkId::new("thunderdome", size), size, |b, &size| {
+            let map = &mut thunderdome::Arena::new();
             b.iter(|| {
                 let keys = &mut vec![];
                 for i in 0..size {

          
@@ 304,10 358,8 @@ fn insert_lookup_and_remove_elems(c: &mu
 }
 
 fn lookup_elems(c: &mut Criterion) {
-    static KB: usize = 1024;
-
     let mut group = c.benchmark_group("lookup_many");
-    for size in [KB, 2 * KB, 4 * KB, 8 * KB, 16 * KB].iter() {
+    for size in SIZES.iter() {
         group.bench_with_input(BenchmarkId::new("genmap", size), size, |b, &size| {
             let map = &mut genmap::GenMap::default();
             let keys = &mut vec![];

          
@@ 360,8 412,24 @@ fn lookup_elems(c: &mut Criterion) {
             });
         });
 
-        group.bench_with_input(BenchmarkId::new("generational_arena", size), size, |b, &size| {
-            let map = &mut ga::Arena::new();
+        group.bench_with_input(
+            BenchmarkId::new("generational_arena", size),
+            size,
+            |b, &size| {
+                let map = &mut ga::Arena::new();
+                let keys = &mut vec![];
+                for i in 0..size {
+                    keys.push(map.insert(i));
+                }
+                b.iter(|| {
+                    for i in keys.iter() {
+                        let _ = black_box(map.get(*i));
+                    }
+                });
+            },
+        );
+        group.bench_with_input(BenchmarkId::new("thunderdome", size), size, |b, &size| {
+            let map = &mut thunderdome::Arena::new();
             let keys = &mut vec![];
             for i in 0..size {
                 keys.push(map.insert(i));

          
@@ 380,10 448,8 @@ fn lookup_elems(c: &mut Criterion) {
 /// Oh well, not gonna bother this instant!
 /// Just be aware that these are pretty darn stupid; don't take them seriously.
 fn iterate_full_list(c: &mut Criterion) {
-    static KB: usize = 1024;
-
     let mut group = c.benchmark_group("bench_iter");
-    for size in [KB, 2 * KB, 4 * KB, 8 * KB, 16 * KB].iter() {
+    for size in SIZES.iter() {
         group.bench_with_input(BenchmarkId::new("genmap", size), size, |b, &size| {
             let map = &mut genmap::GenMap::default();
             for i in 0..size {

          
@@ 434,8 500,23 @@ fn iterate_full_list(c: &mut Criterion) 
             });
         });
 
-        group.bench_with_input(BenchmarkId::new("generational_arena", size), size, |b, &size| {
-            let map = &mut ga::Arena::new();
+        group.bench_with_input(
+            BenchmarkId::new("generational_arena", size),
+            size,
+            |b, &size| {
+                let map = &mut ga::Arena::new();
+                for i in 0..size {
+                    map.insert(i);
+                }
+                b.iter(|| {
+                    for (i, _) in map.iter() {
+                        let _ = black_box(map.get(i));
+                    }
+                });
+            },
+        );
+        group.bench_with_input(BenchmarkId::new("thunderdome", size), size, |b, &size| {
+            let map = &mut thunderdome::Arena::new();
             for i in 0..size {
                 map.insert(i);
             }