Remove define_benchmarks! macro.

It doesn't make the code any shorter. But it (a) obscures the two-level
closure structure, and (b) makes it less clear when things happen.

Author: nnethercote

collector/benchlib/src/benchmark.rs

@@ -105,24 +105,6 @@ impl BenchmarkGroup {
     }
 }
 
-/// Adds a single benchmark to the benchmark group.
-/// ```ignore
-/// use benchlib::define_benchmark;
-///
-/// define_benchmark!(group, my_bench, {
-///     || do_something()
-/// });
-/// ```
-#[macro_export]
-macro_rules! define_benchmark {
-    ($group:expr, $name:ident, $fun:expr) => {
-        let func = move || $fun;
-        $group.register_benchmark(stringify!($name), func);
-    };
-}
-
-pub use define_benchmark;
-
 /// Tests if the name of the benchmark passes through the include and exclude filters.
 /// Both filters can contain multiple comma-separated prefixes.
 pub fn passes_filter(name: &str, exclude: Option<&str>, include: Option<&str>) -> bool {

collector/runtime-benchmarks/bufreader/src/main.rs

@@ -1,9 +1,6 @@
-use std::io::{BufRead, BufReader, Write};
-
-use snap::{read::FrameDecoder, write::FrameEncoder};
-
 use benchlib::benchmark::{black_box, run_benchmark_group};
-use benchlib::define_benchmark;
+use snap::{read::FrameDecoder, write::FrameEncoder};
+use std::io::{BufRead, BufReader, Write};
 
 const BYTES: usize = 64 * 1024 * 1024;
 
@@ -12,7 +9,7 @@ fn main() {
     // The pattern we want is a BufReader which wraps a Read impl where one Read::read call will
     // never fill the whole BufReader buffer.
     run_benchmark_group(|group| {
-        define_benchmark!(group, bufreader_snappy, {
+        group.register_benchmark("bufreader_snappy", || {
             let data = vec![0u8; BYTES];
             move || {
                 let mut compressed = Vec::new();

collector/runtime-benchmarks/hashmap/src/main.rs

@@ -1,11 +1,10 @@
 use benchlib;
 use benchlib::benchmark::run_benchmark_group;
-use benchlib::define_benchmark;
 
 fn main() {
     run_benchmark_group(|group| {
         // Measures how long does it take to insert 10 thousand numbers into a `hashbrown` hashmap.
-        define_benchmark!(group, hashmap_insert_10k, {
+        group.register_benchmark("hashmap_insert_10k", || {
             let mut map = hashbrown::HashMap::with_capacity_and_hasher(
                 10000,
                 fxhash::FxBuildHasher::default(),

collector/runtime-benchmarks/nbody/src/main.rs

@@ -2,13 +2,12 @@
 //! Code taken from https://github.com/prestontw/rust-nbody
 
 use benchlib::benchmark::run_benchmark_group;
-use benchlib::define_benchmark;
 
 mod nbody;
 
 fn main() {
     run_benchmark_group(|group| {
-        define_benchmark!(group, nbody_10k, {
+        group.register_benchmark("nbody_10k", || {
             let mut nbody_10k = nbody::init(10000);
             || {
                 for _ in 0..10 {