test: Instructions benchmark - using multiple captures (#176)

## What?

Uses multiple captures for the instructions benchmark.

## Why?

Results in more concise / maintainable benchmark code.

Author: slowli

Cargo.lock

@@ -68,7 +68,7 @@ serde_json = "1.0"
 clap = { version = "4.5.51", features = ["derive"] }
 test-casing = "0.1.3"
 version-sync = "0.9.2"
-yab = { version = "0.1.0", git = "https://github.com/slowli/yab.git", rev = "83df3d9b4509c255f42300368c844f5ad3f03abb" }
+yab = { version = "0.1.0", git = "https://github.com/slowli/yab.git", rev = "efaa2fd6088a6ad52911806e56609dd29106c225" }
 
 [features]
 default = ["std", "curve25519-dalek"]

Cargo.toml

@@ -4,6 +4,7 @@ use elastic_elgamal::{
     group::{Curve25519Subgroup, Generic, Group, Ristretto},
 };
 use rand_chacha::ChaChaRng;
+use yab::{BenchmarkId, captures};
 
 trait BenchmarkedGroup: Group {
     const NAME: &'static str;
@@ -23,51 +24,42 @@ impl BenchmarkedGroup for Generic<k256::Secp256k1> {
 
 fn bench_group<G: BenchmarkedGroup>(bencher: &mut yab::Bencher) {
     let group = G::NAME;
-    bencher.bench_with_capture(format!("{group}/encrypt"), |capture| {
-        let mut rng = ChaChaRng::from_seed([5; 32]);
-        let keypair: Keypair<G> = Keypair::generate(&mut rng);
-        let message = G::generate_scalar(&mut rng);
-        capture.measure(|| keypair.public().encrypt(message, &mut rng));
-    });
-
-    bencher.bench_with_capture(format!("{group}/decrypt"), |capture| {
-        let mut rng = ChaChaRng::from_seed([5; 32]);
-        let keypair: Keypair<G> = Keypair::generate(&mut rng);
-        let message = G::generate_scalar(&mut rng);
-        let ciphertext = keypair.public().encrypt(message, &mut rng);
-        capture.measure(|| keypair.secret().decrypt_to_element(ciphertext));
-    });
-
-    bencher.bench_with_capture(format!("{group}/zero_prove"), |capture| {
-        let mut rng = ChaChaRng::from_seed([5; 32]);
-        let keypair: Keypair<G> = Keypair::generate(&mut rng);
-        capture.measure(|| keypair.public().encrypt_zero(&mut rng));
-    });
-
-    bencher.bench_with_capture(format!("{group}/zero_verify"), |capture| {
-        let mut rng = ChaChaRng::from_seed([5; 32]);
-        let keypair: Keypair<G> = Keypair::generate(&mut rng);
-        let (ciphertext, proof) = keypair.public().encrypt_zero(&mut rng);
-        capture
-            .measure(|| keypair.public().verify_zero(ciphertext, &proof))
-            .unwrap();
-    });
-
-    for val in [false, true] {
-        bencher.bench_with_capture(format!("{group}/bool_prove/{val}"), |capture| {
+    bencher.bench_with_captures(
+        group,
+        captures!(|[encrypt, decrypt]| {
             let mut rng = ChaChaRng::from_seed([5; 32]);
             let keypair: Keypair<G> = Keypair::generate(&mut rng);
-            capture.measure(|| keypair.public().encrypt_bool(val, &mut rng));
-        });
+            let message = G::generate_scalar(&mut rng);
+            let ciphertext = encrypt.measure(|| keypair.public().encrypt(message, &mut rng));
+            decrypt.measure(|| keypair.secret().decrypt_to_element(ciphertext));
+        }),
+    );
 
-        bencher.bench_with_capture(format!("{group}/bool_verify/{val}"), |capture| {
+    bencher.bench_with_captures(
+        format!("{group}/zero"),
+        captures!(|[prove, verify]| {
             let mut rng = ChaChaRng::from_seed([5; 32]);
             let keypair: Keypair<G> = Keypair::generate(&mut rng);
-            let (ciphertext, proof) = keypair.public().encrypt_bool(val, &mut rng);
-            capture
-                .measure(|| keypair.public().verify_bool(ciphertext, &proof))
-                .unwrap();
-        });
+            let (ciphertext, proof) = prove.measure(|| keypair.public().encrypt_zero(&mut rng));
+            verify
+                .measure(|| keypair.public().verify_zero(ciphertext, &proof))
+                .unwrap()
+        }),
+    );
+
+    for val in [false, true] {
+        bencher.bench_with_captures(
+            BenchmarkId::new(format!("{group}/bool"), val),
+            captures!(|[prove, verify]| {
+                let mut rng = ChaChaRng::from_seed([5; 32]);
+                let keypair: Keypair<G> = Keypair::generate(&mut rng);
+                let (ciphertext, proof) =
+                    prove.measure(|| keypair.public().encrypt_bool(val, &mut rng));
+                verify
+                    .measure(|| keypair.public().verify_bool(ciphertext, &proof))
+                    .unwrap();
+            }),
+        );
     }
 }