ssb 0.1.1

Simple benchmarking for Rust, with hierarchical call tree, based on fastrace.
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

use fastrace::Span;
use ssb::{Bench, BenchReport};

fn phase1(n: u64) -> u64 {
    let _s = Span::enter_with_local_parent("phase1");
    (0..n).fold(0u64, |acc, x| acc.wrapping_add(x))
}

fn phase2(x: u64) -> u64 {
    let _s = Span::enter_with_local_parent("phase2");
    x.wrapping_mul(31)
}

fn compute(n: u64) -> u64 {
    phase2(phase1(n))
}

#[test]
fn report_contains_expected_spans() {
    let report = Bench::new("compute")
        .no_auto_save()
        .iterations(20)
        .warmup(5)
        .run(|| compute(1_000));

    // Total span (the benchmark name) must be present
    assert!(report.spans.contains_key("compute"), "missing total span");
    assert!(report.spans.contains_key("phase1"), "missing phase1 span");
    assert!(report.spans.contains_key("phase2"), "missing phase2 span");

    // All spans should have been observed in every iteration.
    // The loop also respects min_run_seconds, so count may exceed the
    // requested iteration count — just verify the spans are consistent.
    let total_count = report.spans["compute"].count;
    assert!(
        total_count >= 20,
        "expected at least 20 iterations, got {total_count}"
    );
    assert_eq!(report.spans["phase1"].count, total_count);
    assert_eq!(report.spans["phase2"].count, total_count);

    // Sanity: total >= phase1 + phase2 (overhead exists but shouldn't be negative)
    let total_mean = report.spans["compute"].mean_ns;
    let phases_mean = report.spans["phase1"].mean_ns + report.spans["phase2"].mean_ns;
    assert!(
        total_mean >= phases_mean,
        "total ({total_mean:.0} ns) < sum of phases ({phases_mean:.0} ns)"
    );
}

#[test]
fn stats_are_ordered() {
    let report = Bench::new("compute")
        .no_auto_save()
        .iterations(50)
        .warmup(5)
        .run(|| compute(500));

    for (name, s) in &report.spans {
        assert!(s.min_ns <= s.mean_ns as u64, "{name}: min > mean");
        assert!(s.mean_ns <= s.max_ns as f64, "{name}: mean > max");
        assert!(s.p95_ns <= s.max_ns as f64, "{name}: p95 > max");
    }
}

#[test]
fn save_and_load_roundtrip() {
    let dir = tempfile::tempdir().unwrap();
    let path = dir.path().join("report.json");

    let original = Bench::new("compute")
        .no_auto_save()
        .iterations(10)
        .warmup(2)
        .run(|| compute(100));

    original.save(&path).unwrap();
    let loaded = BenchReport::load(&path).unwrap();

    assert_eq!(original.name, loaded.name);
    assert_eq!(original.iterations, loaded.iterations);
    assert_eq!(original.spans.len(), loaded.spans.len());
    for (k, orig_stats) in &original.spans {
        let loaded_stats = &loaded.spans[k];
        assert_eq!(orig_stats.count, loaded_stats.count);
        // f64 round-trips through JSON with enough precision for our purposes
        assert!((orig_stats.mean_ns - loaded_stats.mean_ns).abs() < 1.0);
    }
}

#[test]
fn comparison_smoke_test() {
    let baseline = Bench::new("compute")
        .no_auto_save()
        .iterations(10)
        .warmup(2)
        .run(|| compute(100));

    let current = Bench::new("compute")
        .no_auto_save()
        .iterations(10)
        .warmup(2)
        .run(|| compute(100));

    // Should not panic
    current.compare(&baseline).print();
}