zenbench 0.1.8

Interleaved microbenchmarking with paired statistics, CI regression testing, and hardware-adaptive measurement
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111

//! Test the criterion compatibility layer.
//!
//! These tests verify that criterion-style API patterns work unchanged
//! through the zenbench compat layer.
#![cfg(feature = "criterion-compat")]

use zenbench::criterion_compat::*;
use zenbench::criterion_group;

fn bench_simple(c: &mut Criterion) {
    c.bench_function("fib_add", |b| b.iter(|| black_box(42u64 + 1)));
}

fn bench_group(c: &mut Criterion) {
    let mut group = c.benchmark_group("sorting");
    group.throughput(Throughput::Elements(100));
    group.bench_function("std_sort", |b| {
        b.iter(|| {
            let mut v: Vec<i32> = (0..100).rev().collect();
            v.sort();
            black_box(v)
        })
    });
    group.bench_function("sort_unstable", |b| {
        b.iter(|| {
            let mut v: Vec<i32> = (0..100).rev().collect();
            v.sort_unstable();
            black_box(v)
        })
    });
    group.finish();
}

fn bench_with_input(c: &mut Criterion) {
    let data: Vec<i32> = (0..1000).collect();
    c.bench_with_input(BenchmarkId::new("sum", 1000), &data, |b, input| {
        b.iter(|| black_box(input.iter().sum::<i32>()))
    });
}

fn bench_iter_batched(c: &mut Criterion) {
    let mut group = c.benchmark_group("batched");
    group.bench_function("with_setup", |b| {
        b.iter_batched(
            || (0..100).rev().collect::<Vec<i32>>(),
            |mut v| {
                v.sort();
                black_box(v)
            },
            BatchSize::SmallInput,
        )
    });
    group.bench_function("with_setup_ref", |b| {
        b.iter_batched_ref(
            || (0..100).rev().collect::<Vec<i32>>(),
            |v| {
                v.sort();
                black_box(v.len())
            },
            BatchSize::LargeInput,
        )
    });
    group.finish();
}

// Use the criterion macros
criterion_group!(
    benches,
    bench_simple,
    bench_group,
    bench_with_input,
    bench_iter_batched
);

// Can't use criterion_main! in a test (it generates main()),
// so test the group function directly.
#[test]
fn criterion_compat_runs_without_panic() {
    let criterion = benches();
    let suite = criterion.into_suite();
    let result = zenbench::run_gated(zenbench::GateConfig::disabled(), |s| {
        s.merge(suite);
        // Set low rounds for fast test
        // (can't set per-group config through compat layer easily)
    });
    // Should have run all groups
    assert!(
        result.comparisons.len() >= 3,
        "expected >= 3 groups, got {}",
        result.comparisons.len(),
    );
}

#[test]
fn benchmark_id_formatting() {
    let id = BenchmarkId::new("sort", 1000);
    assert_eq!(format!("{id}"), "sort/1000");

    let id2 = BenchmarkId::from_parameter("large");
    assert_eq!(format!("{id2}"), "large");
}

#[test]
fn batch_size_variants_exist() {
    // Just verify the enum variants compile
    let _ = BatchSize::SmallInput;
    let _ = BatchSize::LargeInput;
    let _ = BatchSize::PerIteration;
    let _ = BatchSize::NumBatches(10);
    let _ = BatchSize::NumIterations(1000);
}