benches: use criterion instead of bencher (#5981)

benches/spawn.rs

@@ -2,10 +2,7 @@
 //! This essentially measure the time to enqueue a task in the local and remote
 //! case.
 
-#[macro_use]
-extern crate bencher;
-
-use bencher::{black_box, Bencher};
+use criterion::{black_box, criterion_group, criterion_main, Criterion};
 
 async fn work() -> usize {
     let val = 1 + 1;
@@ -13,67 +10,77 @@ async fn work() -> usize {
     black_box(val)
 }
 
-fn basic_scheduler_spawn(bench: &mut Bencher) {
+fn basic_scheduler_spawn(c: &mut Criterion) {
     let runtime = tokio::runtime::Builder::new_current_thread()
         .build()
         .unwrap();
-    bench.iter(|| {
-        runtime.block_on(async {
-            let h = tokio::spawn(work());
-            assert_eq!(h.await.unwrap(), 2);
-        });
+
+    c.bench_function("basic_scheduler_spawn", |b| {
+        b.iter(|| {
+            runtime.block_on(async {
+                let h = tokio::spawn(work());
+                assert_eq!(h.await.unwrap(), 2);
+            });
+        })
     });
 }
 
-fn basic_scheduler_spawn10(bench: &mut Bencher) {
+fn basic_scheduler_spawn10(c: &mut Criterion) {
     let runtime = tokio::runtime::Builder::new_current_thread()
         .build()
         .unwrap();
-    bench.iter(|| {
-        runtime.block_on(async {
-            let mut handles = Vec::with_capacity(10);
-            for _ in 0..10 {
-                handles.push(tokio::spawn(work()));
-            }
-            for handle in handles {
-                assert_eq!(handle.await.unwrap(), 2);
-            }
-        });
+
+    c.bench_function("basic_scheduler_spawn10", |b| {
+        b.iter(|| {
+            runtime.block_on(async {
+                let mut handles = Vec::with_capacity(10);
+                for _ in 0..10 {
+                    handles.push(tokio::spawn(work()));
+                }
+                for handle in handles {
+                    assert_eq!(handle.await.unwrap(), 2);
+                }
+            });
+        })
     });
 }
 
-fn threaded_scheduler_spawn(bench: &mut Bencher) {
+fn threaded_scheduler_spawn(c: &mut Criterion) {
     let runtime = tokio::runtime::Builder::new_multi_thread()
         .worker_threads(1)
         .build()
         .unwrap();
-    bench.iter(|| {
-        runtime.block_on(async {
-            let h = tokio::spawn(work());
-            assert_eq!(h.await.unwrap(), 2);
-        });
+    c.bench_function("threaded_scheduler_spawn", |b| {
+        b.iter(|| {
+            runtime.block_on(async {
+                let h = tokio::spawn(work());
+                assert_eq!(h.await.unwrap(), 2);
+            });
+        })
     });
 }
 
-fn threaded_scheduler_spawn10(bench: &mut Bencher) {
+fn threaded_scheduler_spawn10(c: &mut Criterion) {
     let runtime = tokio::runtime::Builder::new_multi_thread()
         .worker_threads(1)
         .build()
         .unwrap();
-    bench.iter(|| {
-        runtime.block_on(async {
-            let mut handles = Vec::with_capacity(10);
-            for _ in 0..10 {
-                handles.push(tokio::spawn(work()));
-            }
-            for handle in handles {
-                assert_eq!(handle.await.unwrap(), 2);
-            }
-        });
+    c.bench_function("threaded_scheduler_spawn10", |b| {
+        b.iter(|| {
+            runtime.block_on(async {
+                let mut handles = Vec::with_capacity(10);
+                for _ in 0..10 {
+                    handles.push(tokio::spawn(work()));
+                }
+                for handle in handles {
+                    assert_eq!(handle.await.unwrap(), 2);
+                }
+            });
+        })
     });
 }
 
-bencher::benchmark_group!(
+criterion_group!(
     spawn,
     basic_scheduler_spawn,
     basic_scheduler_spawn10,
@@ -81,4 +88,4 @@ bencher::benchmark_group!(
     threaded_scheduler_spawn10,
 );
 
-bencher::benchmark_main!(spawn);
+criterion_main!(spawn);