Move Criterion benches into separate benches crate

Cargo.toml

@@ -1,10 +1,10 @@
 [workspace]
+resolver = "3"
 members = [
     "ghash",
     "poly1305",
     "polyval"
 ]
-resolver = "2"
 
 [patch.crates-io]
 polyval = { path = "./polyval" }

benches/Cargo.toml

@@ -0,0 +1,24 @@
+[package]
+name = "benches"
+version = "0.0.0"
+authors = ["RustCrypto Developers"]
+license = "Apache-2.0 OR MIT"
+description = "Criterion benchmarks of the universal-hashes crates"
+edition = "2021"
+publish = false
+
+[workspace]
+
+[dependencies]
+polyval = { path = "../polyval/" }
+
+criterion = "0.8"
+criterion-cycles-per-byte = { version = "0.8", optional = true }
+
+[features]
+cpb = ["dep:criterion-cycles-per-byte"]
+
+[[bench]]
+name = "polyval"
+path = "src/polyval.rs"
+harness = false

benches/README.md

@@ -0,0 +1,10 @@
+# Criterion Benchmarks
+
+This crate contains [`criterion`]-based benchmarks of the universal-hashes crates.
+
+Supports cycles-per-byte benchmarks behind the `cpb` crate feature.
+Read the [`criterion-cycles-per-byte`] docs for additional information
+about supported targets and proper configuration of such measurements.
+
+[`criterion`]: https://github.com/criterion-rs/criterion.rs
+[`criterion-cycles-per-byte`]: https://github.com/criterion-rs/criterion-cycles-per-byte

benches/src/polyval.rs

@@ -0,0 +1,31 @@
+//! POLYVAL benchmarks.
+use criterion::{criterion_group, criterion_main, BenchmarkId, Throughput};
+use polyval::{universal_hash::UniversalHash, Polyval};
+
+mod utils;
+use utils::{config, Benchmarker};
+
+fn bench(c: &mut Benchmarker) {
+    let mut group = c.benchmark_group("polyval");
+
+    for size in &[10, 100, 1000, 10000] {
+        let buf = vec![0u8; *size];
+
+        group.throughput(Throughput::Bytes(*size as u64));
+
+        group.bench_function(BenchmarkId::new("update_padded", size), |b| {
+            let mut polyval = Polyval::new(&Default::default());
+            b.iter(|| polyval.update_padded(&buf));
+        });
+    }
+
+    group.finish();
+}
+
+criterion_group!(
+    name = benches;
+    config = config();
+    targets = bench
+);
+
+criterion_main!(benches);

benches/src/utils.rs

@@ -0,0 +1,17 @@
+use criterion::Criterion;
+
+#[cfg(not(feature = "cpb"))]
+pub type Benchmarker = Criterion;
+
+#[cfg(feature = "cpb")]
+pub type Benchmarker = Criterion<criterion_cycles_per_byte::CyclesPerByte>;
+
+#[cfg(not(feature = "cpb"))]
+pub fn config() -> Benchmarker {
+    Criterion::default()
+}
+
+#[cfg(feature = "cpb")]
+pub fn config() -> Benchmarker {
+    Criterion::default().with_measurement(criterion_cycles_per_byte::CyclesPerByte)
+}

ghash/benches/ghash.rs

@@ -23,7 +23,7 @@ macro_rules! bench {
     };
 }
 
-bench!(bench1_10, 10);
-bench!(bench2_100, 100);
-bench!(bench3_1000, 1000);
-bench!(bench3_10000, 10000);
+bench!(bench_ghash_1_10, 10);
+bench!(bench_ghash_2_100, 100);
+bench!(bench_ghash_3_1000, 1000);
+bench!(bench_ghash_3_10000, 10000);

poly1305/benches/poly1305.rs

@@ -26,7 +26,7 @@ macro_rules! bench {
     };
 }
 
-bench!(bench1_10, 10);
-bench!(bench2_100, 100);
-bench!(bench3_1000, 1000);
-bench!(bench3_10000, 10000);
+bench!(bench_poly1305_1_10, 10);
+bench!(bench_poly1305_2_100, 100);
+bench!(bench_poly1305_3_1000, 1000);
+bench!(bench_poly1305_4_10000, 10000);

polyval/Cargo.toml

@@ -30,14 +30,8 @@ cpufeatures = "0.3"
 hex-literal = "1"
 
 [target.'cfg(any(unix, windows))'.dev-dependencies]
-criterion = "0.7"
 proptest = "1.9"
 
-[[bench]]
-name = "polyval"
-path = "benches/polyval.rs"
-harness = false
-
 [lints.rust]
 missing_copy_implementations = "warn"
 missing_debug_implementations = "warn"

polyval/benches/polyval.rs

@@ -1,31 +1,31 @@
 //! POLYVAL benchmarks.
 
-#![allow(missing_docs)]
+#![feature(test)]
 
-use criterion::{BenchmarkId, Criterion, Throughput, criterion_group, criterion_main};
-use polyval::{Polyval, universal_hash::UniversalHash};
-
-fn bench(c: &mut Criterion) {
-    let mut group = c.benchmark_group("polyval");
-
-    for size in &[10, 100, 1000, 10000] {
-        let buf = vec![0u8; *size];
-
-        group.throughput(Throughput::Bytes(*size as u64));
+extern crate test;
 
-        group.bench_function(BenchmarkId::new("update_padded", size), |b| {
-            let mut polyval = Polyval::new(&Default::default());
-            b.iter(|| polyval.update_padded(&buf));
-        });
-    }
-
-    group.finish();
+use polyval::{Polyval, universal_hash::UniversalHash};
+use test::Bencher;
+
+// TODO(tarcieri): move this into the `universal-hash` crate
+macro_rules! bench {
+    ($name:ident, $bs:expr) => {
+        #[bench]
+        fn $name(b: &mut Bencher) {
+            let key = Default::default();
+            let mut m = Polyval::new(&key);
+            let data = [0; $bs];
+
+            b.iter(|| {
+                m.update_padded(&data);
+            });
+
+            b.bytes = $bs;
+        }
+    };
 }
 
-criterion_group!(
-    name = benches;
-    config = Criterion::default();
-    targets = bench
-);
-
-criterion_main!(benches);
+bench!(bench_polyval_1_10, 10);
+bench!(bench_polyval_2_100, 100);
+bench!(bench_polyval_3_1000, 1000);
+bench!(bench_polyval_4_10000, 10000);