vor 0.2.1

Cross-platform performance instrumentation with an in-app egui panel and live system and GPU metrics.
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

//! End-to-end smoke test: `#[profile]` expands, puffin captures the
//! scope, frame buffer reads it back. Catches breakage in the
//! proc-macro path that compile-only checks miss.

#[vor::profile]
fn foo() {
    std::thread::sleep(std::time::Duration::from_micros(100));
}

#[test]
fn macro_chain_records_scopes() {
    vor::enable();
    let view = puffin::GlobalFrameView::default();
    foo();
    vor::frame_mark();
    foo();
    vor::frame_mark();

    let view = view.lock();
    assert!(puffin::are_scopes_on());
    assert!(view.recent_frames().count() > 0);
    assert!(!view.scope_collection().scopes_by_id().is_empty());

    let mut total_scopes = 0usize;
    for f in view.recent_frames() {
        let unpacked = f.unpacked().unwrap();
        for stream in unpacked.thread_streams.values() {
            total_scopes += puffin::Reader::from_start(&stream.stream)
                .read_top_scopes()
                .unwrap()
                .len();
        }
    }
    assert!(total_scopes > 0);
}

struct Widget;

#[vor::all_functions]
impl Widget {
    fn work(&self) {
        std::thread::sleep(std::time::Duration::from_micros(100));
    }

    // Must compile despite the non-const scope openers `all_functions`
    // would otherwise inject.
    const fn answer() -> u32 {
        42
    }

    // Must compile (the `skip` attribute is consumed) and emit nothing.
    // Non-const body so this exercises `skip`, not const-elision.
    #[vor::skip]
    fn untracked(&self) {
        std::thread::yield_now();
    }
}

#[test]
fn all_functions_instruments_methods() {
    vor::enable();
    let view = puffin::GlobalFrameView::default();
    let widget = Widget;
    widget.work();
    widget.untracked();
    vor::frame_mark();
    assert_eq!(Widget::answer(), 42);

    let view = view.lock();
    let mut total_scopes = 0usize;
    for f in view.recent_frames() {
        let unpacked = f.unpacked().unwrap();
        for stream in unpacked.thread_streams.values() {
            total_scopes += puffin::Reader::from_start(&stream.stream)
                .read_top_scopes()
                .unwrap()
                .len();
        }
    }
    assert!(total_scopes > 0);
}

#[test]
fn io_acc_round_trip() {
    vor::record_io(123_456, 1024);
    vor::record_io(7_654_321, 2048);
    let tick = vor::drain_io();
    assert_eq!(tick.elapsed_ns, 123_456 + 7_654_321);
    assert_eq!(tick.bytes, 1024 + 2048);
    let after = vor::drain_io();
    assert_eq!(after.elapsed_ns, 0);
    assert_eq!(after.bytes, 0);
}