Add benchlib

Library for defining and measuring (micro)benchmarks.

Author: Kobzol

Cargo.lock

@@ -1,5 +1,5 @@
 [workspace]
-members = ["collector", "site", "database", "intern"]
+members = ["collector", "collector/benchlib", "site", "database", "intern"]
 exclude = ["collector/benchmarks", "rust/src"]
 
 [profile.release.package.site]

Cargo.toml

@@ -0,0 +1,18 @@
+[package]
+name = "benchlib"
+version = "0.1.0"
+edition = "2021"
+description = "Library for defining and measuring benchmarks of Rust code"
+
+# See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
+
+[dependencies]
+anyhow = "1.0.61"
+serde = { version = "1.0.143", features = ["derive"] }
+serde_json = "1.0.83"
+log = "0.4.17"
+env_logger = "0.9.0"
+clap = { version = "3.2", features = ["derive"] }
+
+[target.'cfg(unix)'.dependencies]
+perf-event = "0.4.7"

collector/benchlib/Cargo.toml

@@ -0,0 +1,90 @@
+use crate::cli::{parse_cli, Args, BenchmarkArgs};
+use crate::measure::benchmark_function;
+use crate::messages::BenchmarkResult;
+use log::LevelFilter;
+use std::collections::HashMap;
+
+/// Create a new benchmark suite. Use the closure argument to define benchmarks.
+pub fn benchmark_suite<F: FnOnce(&mut BenchmarkSuite)>(define_func: F) {
+    env_logger::Builder::from_default_env()
+        .filter_level(LevelFilter::Info)
+        .init();
+    let mut suite = BenchmarkSuite::new();
+    define_func(&mut suite);
+    suite.run().expect("Benchmark suite has failed");
+}
+
+#[derive(Default)]
+pub struct BenchmarkSuite {
+    benchmarks: HashMap<&'static str, BenchmarkWrapper>,
+}
+
+impl BenchmarkSuite {
+    pub fn new() -> Self {
+        Self::default()
+    }
+
+    /// Registers a single benchmark.
+    /// `func` should return a closure that will be benchmarked.
+    pub fn register<F: Fn() -> Bench + 'static, R, Bench: FnOnce() -> R + 'static>(
+        &mut self,
+        name: &'static str,
+        func: F,
+    ) {
+        // We want to monomorphize the target `func` and then wrap it in a Box, to avoid going
+        // through a vtable when we execute the benchmarked function.
+        let benchmark_func = Box::new(move || {
+            let bench_fn = func();
+            benchmark_function(name, bench_fn)
+        });
+        let benchmark_def = BenchmarkWrapper {
+            func: benchmark_func,
+        };
+        if self.benchmarks.insert(name, benchmark_def).is_some() {
+            panic!("Benchmark {} was registered twice", name);
+        }
+    }
+
+    /// Execute the benchmark suite. It will parse CLI arguments and decide what to do based on
+    /// them.
+    pub fn run(self) -> anyhow::Result<()> {
+        let args = parse_cli()?;
+        match args {
+            Args::Benchmark(args) => {
+                self.run_benchmark(args)?;
+            }
+        }
+
+        Ok(())
+    }
+
+    fn run_benchmark(self, args: BenchmarkArgs) -> anyhow::Result<()> {
+        let mut items: Vec<_> = self.benchmarks.into_iter().collect();
+        items.sort_unstable_by_key(|item| item.0);
+
+        let mut results: Vec<BenchmarkResult> = Vec::with_capacity(items.len());
+        for (name, def) in items {
+            for i in 0..args.iterations {
+                let result = (def.func)()?;
+                log::info!("Benchmark (run {i}) `{}` completed: {:?}", name, result);
+                results.push(result);
+            }
+        }
+
+        println!("{}", serde_json::to_string(&results)?);
+        Ok(())
+    }
+}
+
+struct BenchmarkWrapper {
+    func: Box<dyn Fn() -> anyhow::Result<BenchmarkResult>>,
+}
+
+/// Copied from `iai`, so that we don't have to use unstable features.
+pub fn black_box<T>(dummy: T) -> T {
+    unsafe {
+        let ret = std::ptr::read_volatile(&dummy);
+        std::mem::forget(dummy);
+        ret
+    }
+}