vignette 0.1.0

A sampling profiler as a library. Particularly oriented towards shipping software where symbols need to be hydrated later.
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

extern crate threadinfo;
extern crate vignette;

extern crate serde;
extern crate serde_json;

use std::fs::File;
use std::process;
use std::{
    sync::{Arc, RwLock},
    thread::spawn,
};

use vignette::output::Outputter;
// TODO: Everything except profiler really should not be public and we instead want to register
// threads with the profiler? The thread iteration stuff is useful in general though and could be a
// separate crate/module.
use threadinfo::{current_thread, thread_iterator};
use vignette::Profiler;

fn fun_one(running2: Arc<RwLock<bool>>) {
    while *(running2.read().unwrap()) {
        let mut _sum = 0;
        for i in 1..10000 {
            _sum += i;
        }
    }
    println!("fun thread {:?}", current_thread().unwrap());
}

fn boring_one(running2: Arc<RwLock<bool>>) {
    while *(running2.read().unwrap()) {
        std::thread::sleep(std::time::Duration::from_millis(10));
    }
    println!("boring thread {:?}", current_thread().unwrap());
}

fn main() {
    // Spawn a bunch of threads, then sample them.
    let running = Arc::new(RwLock::new(true));
    let mut handles = Vec::new();
    for i in 0..2 {
        let running2 = running.clone();
        handles.push(if i % 2 == 0 {
            spawn(move || {
                boring_one(running2);
            })
        } else {
            spawn(move || {
                fun_one(running2);
            })
        })
    }

    println!("Spawned {} threads", handles.len());

    // Let both threads start.
    std::thread::sleep(std::time::Duration::from_millis(100));

    let profiler = Profiler::new();
    let mut session = profiler.session();

    for _ in 0..20 {
        let threads = thread_iterator().expect("threads");
        for thread in threads {
            // TODO: Kinda weird to leak this current thread detail out here.
            if thread.is_current_thread() {
                continue;
            }
            session.sample_thread(thread);
        }
    }

    {
        let mut val = running.write().expect("write lock");
        *val = false;
    }

    for handle in handles {
        handle.join().unwrap();
    }

    println!("Done sampling");

    let mut outputter = Outputter::new();
    let output_profile = outputter.output(session.finish());
    let filename = format!("{}.vignette", process::id());
    let file = File::create(&filename).unwrap();
    serde_json::to_writer_pretty(file, &output_profile).unwrap();
    println!("Wrote to {}", filename);
}