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

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

use super::*;
use std::thread;
use std::time::Duration;

#[test]
fn autostart_and_mark_captures_increasing_since_start() {
    let mut t = SubMsTimer::new("x");
    thread::sleep(Duration::from_millis(1));
    let a = t.mark("a");
    thread::sleep(Duration::from_millis(1));
    let b = t.mark("b");
    assert!(a > 0);
    assert!(b > a);
    assert_eq!(t.checkpoints().len(), 2);
    assert_eq!(t.checkpoints()[0].label, "a");
    assert_eq!(t.checkpoints()[1].label, "b");
    assert!(!t.checkpoints()[0].is_stop);
}

#[test]
fn stop_marks_is_stop_and_freezes_elapsed() {
    let mut t = SubMsTimer::new("x");
    thread::sleep(Duration::from_millis(1));
    t.stop("done");
    assert!(t.is_stopped());
    let e1 = t.elapsed_ns();
    thread::sleep(Duration::from_millis(2));
    let e2 = t.elapsed_ns();
    assert_eq!(e1, e2, "elapsed should freeze after stop");
    assert!(t.checkpoints().last().unwrap().is_stop);
}

#[test]
fn reset_clears_checkpoints() {
    let mut t = SubMsTimer::new("x");
    t.mark("a");
    t.mark("b");
    t.reset();
    assert!(t.checkpoints().is_empty());
    assert!(!t.is_stopped());
}

#[test]
fn lap_is_alias_of_mark() {
    let mut t = SubMsTimer::new("x");
    t.lap("a");
    assert_eq!(t.checkpoints().len(), 1);
    assert_eq!(t.checkpoints()[0].label, "a");
}

#[test]
fn print_emits_header_and_checkpoints() {
    let mut t = SubMsTimer::new("parse");
    t.mark("a");
    t.stop("done");
    let mut buf = Vec::new();
    t.print(&mut buf).unwrap();
    let out = String::from_utf8(buf).unwrap();
    assert!(out.contains("timer \"parse\""));
    assert!(out.contains("a"));
    assert!(out.contains("done *"));
}

// ---------------- static clock API ----------------

#[test]
fn nanos_now_returns_positive_increasing() {
    let a = SubMsTimer::nanos_now();
    thread::sleep(Duration::from_millis(1));
    let b = SubMsTimer::nanos_now();
    assert!(b > a, "monotonic: {} -> {}", a, b);
}

#[test]
fn tick_and_elapsed_ns_capture_positive_interval() {
    let t = SubMsTimer::tick();
    thread::sleep(Duration::from_millis(2));
    let ns = t.elapsed_ns();
    assert!(ns >= 1_000_000, "should be >= 1ms after sleep: {}", ns);
    assert!(
        ns < 100_000_000,
        "shouldn't be > 100ms on a healthy box: {}",
        ns
    );
}

#[test]
fn tick_is_reusable_for_multiple_reads() {
    let t = SubMsTimer::tick();
    thread::sleep(Duration::from_millis(1));
    let a = t.elapsed_ns();
    thread::sleep(Duration::from_millis(1));
    let b = t.elapsed_ns();
    assert!(b >= a, "second read >= first: {} -> {}", a, b);
}

#[test]
fn measure_ns_returns_elapsed_and_runs_closure() {
    let mut counter = 0;
    let ((), elapsed) = SubMsTimer::measure_ns(|| {
        counter += 1;
        thread::sleep(Duration::from_millis(1));
    });
    assert_eq!(counter, 1, "closure should run exactly once");
    assert!(
        elapsed >= 500_000,
        "elapsed should be at least 0.5ms: {}",
        elapsed
    );
}

#[test]
fn measure_ns_propagates_closure_return_value() {
    let (val, _ns) = SubMsTimer::measure_ns(|| 42);
    assert_eq!(val, 42);
}

#[test]
fn measure_ns_returns_zero_or_positive_for_noop() {
    let (_, elapsed) = SubMsTimer::measure_ns(|| {});
    assert!(
        elapsed < 1_000_000,
        "no-op shouldn't take >= 1ms: {}",
        elapsed
    );
}