bashrs 6.66.0

Rust-to-Shell transpiler for deterministic bootstrap scripts
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
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136

#![allow(clippy::expect_used)]
#![allow(clippy::unwrap_used)] // Benchmarks can use unwrap() for simplicity
                               // Sprint 84 - Day 1: Makefile Performance Benchmarks
                               // Performance targets: <10ms (small), <50ms (medium), <100ms (large)

use bashrs::make_parser::{parse_makefile, purify_makefile};
use criterion::{criterion_group, criterion_main, BenchmarkId, Criterion};
use std::hint::black_box;

// Benchmark fixtures
const SMALL_MAKEFILE: &str = include_str!("fixtures/small.mk");
const MEDIUM_MAKEFILE: &str = include_str!("fixtures/medium.mk");
const LARGE_MAKEFILE: &str = include_str!("fixtures/large.mk");

/// Benchmark parsing only (without purification)
fn benchmark_parse(c: &mut Criterion) {
    let mut group = c.benchmark_group("parse");

    group.bench_with_input(
        BenchmarkId::new("small", "46 lines"),
        &SMALL_MAKEFILE,
        |b, makefile| b.iter(|| parse_makefile(black_box(makefile))),
    );

    group.bench_with_input(
        BenchmarkId::new("medium", "174 lines"),
        &MEDIUM_MAKEFILE,
        |b, makefile| b.iter(|| parse_makefile(black_box(makefile))),
    );

    group.bench_with_input(
        BenchmarkId::new("large", "2021 lines"),
        &LARGE_MAKEFILE,
        |b, makefile| b.iter(|| parse_makefile(black_box(makefile))),
    );

    group.finish();
}

/// Benchmark purification only (without parsing)
fn benchmark_purify(c: &mut Criterion) {
    let mut group = c.benchmark_group("purify");

    // Pre-parse the Makefiles
    let small_ast = parse_makefile(SMALL_MAKEFILE).unwrap();
    let medium_ast = parse_makefile(MEDIUM_MAKEFILE).unwrap();
    let large_ast = parse_makefile(LARGE_MAKEFILE).unwrap();

    group.bench_with_input(
        BenchmarkId::new("small", "46 lines"),
        &small_ast,
        |b, ast| b.iter(|| purify_makefile(black_box(ast))),
    );

    group.bench_with_input(
        BenchmarkId::new("medium", "174 lines"),
        &medium_ast,
        |b, ast| b.iter(|| purify_makefile(black_box(ast))),
    );

    group.bench_with_input(
        BenchmarkId::new("large", "2021 lines"),
        &large_ast,
        |b, ast| b.iter(|| purify_makefile(black_box(ast))),
    );

    group.finish();
}

/// Benchmark end-to-end workflow (parse + purify)
fn benchmark_end_to_end(c: &mut Criterion) {
    let mut group = c.benchmark_group("end_to_end");

    // Set performance targets
    // Target: <10ms (small), <50ms (medium), <100ms (large)

    group.bench_with_input(
        BenchmarkId::new("small", "46 lines"),
        &SMALL_MAKEFILE,
        |b, makefile| {
            b.iter(|| {
                let ast = parse_makefile(black_box(makefile)).unwrap();
                purify_makefile(&ast)
            })
        },
    );

    group.bench_with_input(
        BenchmarkId::new("medium", "174 lines"),
        &MEDIUM_MAKEFILE,
        |b, makefile| {
            b.iter(|| {
                let ast = parse_makefile(black_box(makefile)).unwrap();
                purify_makefile(&ast)
            })
        },
    );

    group.bench_with_input(
        BenchmarkId::new("large", "2021 lines"),
        &LARGE_MAKEFILE,
        |b, makefile| {
            b.iter(|| {
                let ast = parse_makefile(black_box(makefile)).unwrap();
                purify_makefile(&ast)
            })
        },
    );

    group.finish();
}

/// Benchmark individual purification analysis functions
fn benchmark_purify_analyses(c: &mut Criterion) {
    let mut group = c.benchmark_group("purify_analyses");

    // Use medium-sized Makefile for analysis benchmarks
    let medium_ast = parse_makefile(MEDIUM_MAKEFILE).unwrap();

    // Note: This benchmarks the full purification, which runs all 5 analyses
    // Individual analysis functions are not public, so we benchmark the complete purify
    group.bench_function("all_analyses", |b| {
        b.iter(|| purify_makefile(black_box(&medium_ast)))
    });

    group.finish();
}

criterion_group!(
    benches,
    benchmark_parse,
    benchmark_purify,
    benchmark_end_to_end,
    benchmark_purify_analyses,
);
criterion_main!(benches);