pbt 0.4.21

Property-based testing with `derive` macros, aware of mutual induction & instantiability.
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

//! Generation throughput benchmarks.
//!
//! Requires Valgrind and `gungraun-runner` on `PATH`; `nix develop` provides both.
//! Run with: `cargo bench -p pbt --bench generation`.

#![expect(
    missing_docs,
    reason = "Gungraun's benchmark entry-point macros generate undocumented public items"
)]
#![expect(
    clippy::exit,
    reason = "Gungraun owns the benchmark process entry point"
)]

use {
    core::{hint::black_box, iter},
    gungraun::{
        Callgrind, EventKind, LibraryBenchmarkConfig, library_benchmark, library_benchmark_group,
        main,
    },
    pbt::{Pbt, WyRand, pbt::arbitrary, size::Size},
};

/// Base number of generated terms per benchmark case.
const N_CASES: usize = 1_000;

/// Fixed PRNG seed used for every benchmark case.
const SEED: u64 = 0x1337_5eed_f00d_cafe;

/// Lambda-calculus terms using de Bruijn indices for variables.
#[derive(Clone, Debug, Eq, PartialEq, Pbt)]
enum LambdaCalculus {
    /// Function application.
    Application(Box<Self>, Box<Self>),
    /// Lambda abstraction.
    Lambda(Box<Self>),
    /// De Bruijn variable index.
    Variable(usize),
}

/// Deterministic generation-size schedule.
#[derive(Clone, Copy)]
enum SizeSchedule {
    /// [`N_CASES`] terms at a fixed size of 1,000.
    Large,
    /// First [`N_CASES`] normal search sizes.
    Small,
}

/// Warm lazy generation state outside the measured region.
fn setup_schedule(schedule: SizeSchedule) -> SizeSchedule {
    // Run once to let `pbt` populate its global registry.
    generate_lambda_calculus_batch(iter::once(Size::new(1_000)));

    schedule
}

/// Generate one deterministic batch of lambda-calculus terms for a size schedule.
#[expect(
    clippy::panic,
    reason = "lambda-calculus terms are structurally instantiable; a failure here is a benchmark setup bug"
)]
fn generate_lambda_calculus_batch(sizes: impl Iterator<Item = Size>) {
    let mut prng = WyRand::new(SEED);
    for size in sizes {
        let Some(term) = arbitrary::<LambdaCalculus>(&mut prng, size) else {
            panic!("lambda-calculus generation unexpectedly failed");
        };
        let _term = black_box(term);
    }
}

#[library_benchmark]
#[bench::small(args = (SizeSchedule::Small), setup = setup_schedule)]
#[bench::large(args = (SizeSchedule::Large), setup = setup_schedule)]
fn lambda_calculus_generation(schedule: SizeSchedule) {
    match schedule {
        SizeSchedule::Small => {
            generate_lambda_calculus_batch(Size::expanding().take(const { 10 * N_CASES }));
        }
        SizeSchedule::Large => {
            generate_lambda_calculus_batch(iter::repeat_with(|| Size::new(1_000)).take(N_CASES));
        }
    }
}

library_benchmark_group!(
    name = generation;
    max_parallel = 1;
    benchmarks = lambda_calculus_generation
);
main!(
    config = LibraryBenchmarkConfig::default()
        .tool(Callgrind::default().format([EventKind::Ir, EventKind::TotalRW]));
    library_benchmark_groups = generation
);