subms 0.8.0

The sub-millisecond perf harness for Rust. Zero-dependency std-only library that records timed samples per stage, computes percentiles, supports coordinated-omission correction, runs scale sweeps, and emits a stable JSON contract. Byte-equivalent to the Java sibling com.submillisecond:subms.
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
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133

//! Unit tests for `growth`, colocated (included via `#[path]` in growth.rs).

use super::*;

// A recipe whose on-disk footprint per round is scripted, so the verdict
// logic can be exercised deterministically. live_bytes is fixed (a flat
// working set); on_disk follows `disk[round-1]`.
struct ScriptedRecipe {
    disk: Vec<u64>,
    live: u64,
    class: SubMsGrowthClass,
    bound: f64,
    round: usize,
}
impl SubMsGrowthRecipe for ScriptedRecipe {
    fn name(&self) -> &str {
        "scripted"
    }
    fn rounds(&self) -> usize {
        self.disk.len()
    }
    fn ops_per_round(&self) -> usize {
        4
    }
    fn op(&mut self, round: usize, _i: usize) {
        self.round = round;
    }
    fn disk_bytes(&mut self) -> u64 {
        self.disk[self.round - 1]
    }
    fn live_bytes(&mut self) -> u64 {
        self.live
    }
    fn structures(&mut self) -> Vec<(String, u64)> {
        vec![("sstables".to_string(), self.round as u64)]
    }
    fn expected(&self) -> (SubMsGrowthClass, f64) {
        (self.class, self.bound)
    }
}

#[test]
fn amplification_bounded_holds_when_disk_tracks_live() {
    // on-disk stays within ~1.2x of a flat 1000-byte live set -> holds.
    let mut r = ScriptedRecipe {
        disk: vec![1000, 1100, 1050, 1200],
        live: 1000,
        class: SubMsGrowthClass::AmplificationBounded,
        bound: 3.0,
        round: 0,
    };
    let report = grow(&mut r, "rust");
    assert!(report.verdict.holds, "{}", report.verdict.summary);
    assert!((report.verdict.observed - 1.2).abs() < 1e-9);
    assert!(assert_growth_holds(&report).is_ok());
}

#[test]
fn amplification_bounded_breaches_when_disk_grows_but_live_flat() {
    // the leak shape: live flat at 1000, on-disk climbs to 21x -> breach.
    let mut r = ScriptedRecipe {
        disk: vec![1000, 5000, 12000, 21000],
        live: 1000,
        class: SubMsGrowthClass::AmplificationBounded,
        bound: 3.0,
        round: 0,
    };
    let report = grow(&mut r, "rust");
    assert!(!report.verdict.holds);
    assert!((report.verdict.observed - 21.0).abs() < 1e-9);
    assert!(assert_growth_holds(&report).is_err());
}

#[test]
fn plateau_holds_when_flat_and_breaches_when_climbing() {
    // Flat file (pre-allocated, then steady) -> holds even though absolute
    // size dwarfs the tiny live set.
    let mut flat = ScriptedRecipe {
        disk: vec![66_000, 66_000, 66_000, 66_000],
        live: 20,
        class: SubMsGrowthClass::PlateauBounded,
        bound: 1.5,
        round: 0,
    };
    let held = grow(&mut flat, "rust");
    assert!(held.verdict.holds, "{}", held.verdict.summary);

    // File that keeps climbing through the second half -> breach (a leak).
    // Baseline is the mid-point (round 3 here); last / mid = 16000 / 4000 = 4x.
    let mut climbing = ScriptedRecipe {
        disk: vec![1000, 2000, 4000, 16000],
        live: 20,
        class: SubMsGrowthClass::PlateauBounded,
        bound: 1.5,
        round: 0,
    };
    let leak = grow(&mut climbing, "rust");
    assert!(!leak.verdict.holds);
    assert!((leak.verdict.observed - 4.0).abs() < 1e-9);
}

#[test]
fn bounded_gates_on_peak_bytes() {
    let mut r = ScriptedRecipe {
        disk: vec![100, 128, 128, 128],
        live: 128,
        class: SubMsGrowthClass::Bounded,
        bound: 128.0,
        round: 0,
    };
    let report = grow(&mut r, "rust");
    assert!(report.verdict.holds);
}

#[test]
fn json_has_verdict_and_rounds() {
    let mut r = ScriptedRecipe {
        disk: vec![1000, 1100],
        live: 1000,
        class: SubMsGrowthClass::AmplificationBounded,
        bound: 3.0,
        round: 0,
    };
    let report = grow(&mut r, "rust");
    let mut buf: Vec<u8> = Vec::new();
    growth_to_json(&report, &mut buf).unwrap();
    let s = String::from_utf8(buf).unwrap();
    assert!(s.contains("\"kind\":\"growth\""));
    assert!(s.contains("\"class\":\"amplification_bounded\""));
    assert!(s.contains("\"holds\":true"));
    assert!(s.contains("\"sstables\":2"));
    assert!(s.contains("\"amplification\":"));
}