criterion

benches/allmessages.rs

@@ -1,15 +1,12 @@
 #![allow(dead_code)]
 #![allow(unused_imports)]
 #![allow(unused_variables)]
-#![feature(test)]
-
-extern crate test;
 
+use criterion::{black_box, criterion_group, criterion_main, Criterion};
 use pretty_assertions::assert_eq;
 use std::fs;
 
 use std::collections::{HashMap, HashSet};
-use test::Bencher;
 use tf_demo_parser::demo::message::Message;
 use tf_demo_parser::demo::packet::datatable::{ParseSendTable, SendTableName};
 use tf_demo_parser::demo::packet::stringtable::StringTableEntry;
@@ -27,28 +24,36 @@ impl MessageHandler for AllMessages {
     }
 
     fn handle_message(&mut self, message: &Message, tick: u32) {
-        test::black_box(message);
+        black_box(message);
     }
 
     fn into_output(self, state: &ParserState) -> Self::Output {
-        test::black_box(true)
+        black_box(true)
     }
 }
 
-fn bench_all(input_file: &str, b: &mut Bencher) {
+fn bench_all(input_file: &str, b: &mut Criterion) {
     let file = fs::read(input_file).expect("Unable to read file");
     let demo = Demo::new(&file);
     let stream = demo.get_stream();
-    b.iter(|| {
-        let _ = test::black_box(
-            DemoParser::new_with_analyser(stream.clone(), AllMessages)
-                .parse()
-                .unwrap(),
-        );
+    b.bench_function("bench_all", |b| {
+        b.iter(|| {
+            let _ = black_box(
+                DemoParser::new_with_analyser(stream.clone(), AllMessages)
+                    .parse()
+                    .unwrap(),
+            );
+        })
     });
 }
 
-#[bench]
-fn all_test_gully(b: &mut Bencher) {
+fn all_test_gully(b: &mut Criterion) {
     bench_all("test_data/gully.dem", b);
 }
+
+criterion_group! {
+    name = benches;
+    config = Criterion::default().sample_size(10);
+    targets = all_test_gully
+}
+criterion_main!(benches);

benches/bench.rs

@@ -1,29 +1,27 @@
-#![feature(test)]
-
-extern crate test;
-
+use criterion::{black_box, criterion_group, criterion_main, Criterion};
 use std::fs;
-
-use test::Bencher;
 use tf_demo_parser::{Demo, DemoParser, Stream};
 
-fn bench_file(input_file: &str, b: &mut Bencher) {
+fn bench_file(input_file: &str, b: &mut Criterion) {
     let file = fs::read(input_file).expect("Unable to read file");
     let demo = Demo::new(&file);
     let stream: Stream = demo.get_stream();
 
-    b.iter(|| {
-        let (_, state) = DemoParser::new(stream.clone()).parse().unwrap();
-        test::black_box(state);
-    })
+    b.bench_function(&format!("bench file {}", input_file), |b| {
+        b.iter(|| {
+            let (_, state) = DemoParser::new(stream.clone()).parse().unwrap();
+            black_box(state);
+        })
+    });
 }
 
-#[bench]
-fn bench_gully(b: &mut Bencher) {
+fn bench_gully(b: &mut Criterion) {
     bench_file("test_data/gully.dem", b);
 }
 
-#[bench]
-fn bench_comp(b: &mut Bencher) {
+fn bench_comp(b: &mut Criterion) {
     bench_file("test_data/comp.dem", b);
 }
+
+criterion_group!(benches, bench_comp, bench_gully);
+criterion_main!(benches);

benches/sendprop.rs

@@ -1,15 +1,12 @@
 #![allow(dead_code)]
 #![allow(unused_imports)]
 #![allow(unused_variables)]
-#![feature(test)]
-
-extern crate test;
 
+use criterion::{black_box, criterion_group, criterion_main, Criterion};
 use pretty_assertions::assert_eq;
 use std::fs;
 
 use std::collections::{HashMap, HashSet};
-use test::Bencher;
 use tf_demo_parser::demo::message::Message;
 use tf_demo_parser::demo::packet::datatable::{ParseSendTable, SendTableName};
 use tf_demo_parser::demo::packet::stringtable::StringTableEntry;
@@ -39,23 +36,27 @@ impl MessageHandler for SendPropAnalyser {
     }
 }
 
-fn flatten_bench(input_file: &str, b: &mut Bencher) {
+fn flatten_bench(input_file: &str, b: &mut Criterion) {
     let file = fs::read(input_file).expect("Unable to read file");
     let demo = Demo::new(&file);
     let stream = demo.get_stream();
     let (_, send_tables) = DemoParser::new_with_analyser(stream.clone(), SendPropAnalyser)
         .parse()
         .unwrap();
-    b.iter(|| {
-        let flat: Vec<_> = send_tables
-            .iter()
-            .map(|table| table.flatten_props(&send_tables))
-            .collect();
-        test::black_box(flat);
+    b.bench_function(&format!("flatten {}", input_file), |b| {
+        b.iter(|| {
+            let flat: Vec<_> = send_tables
+                .iter()
+                .map(|table| table.flatten_props(&send_tables))
+                .collect();
+            black_box(flat);
+        })
     });
 }
 
-#[bench]
-fn sendprop_test_gully(b: &mut Bencher) {
+fn sendprop_test_gully(b: &mut Criterion) {
     flatten_bench("test_data/gully.dem", b);
 }
+
+criterion_group!(benches, sendprop_test_gully);
+criterion_main!(benches);