profi 0.1.2

Scope-based single and multithreaded profiling
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
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150

//! Contains all macro items, which should not be used by themselves.
//!
//! Always prefer the macros [`prof!`](crate::prof), [`prof_guard!`](crate::prof_guard) and [`print_on_exit!`](crate::print_on_exit).

#[cfg(feature = "enable")]
use crate::Str;
#[cfg(not(feature = "enable"))]
type Str = String;

#[cfg_attr(feature = "enable", derive(Debug))]
pub struct ScopeGuard {}

impl ScopeGuard {
    #[inline(always)]
    #[allow(unused)]
    pub fn new(name: impl Into<Str>) -> Self {
        #[cfg(feature = "enable")]
        crate::measure::THREAD_PROFILER.with_borrow_mut(|thread| thread.push(name.into()));
        Self {}
    }
}

impl Drop for ScopeGuard {
    fn drop(&mut self) {
        #[cfg(feature = "enable")]
        {
            // Do the measure as early as possible
            let time = minstant::Instant::now();
            crate::measure::THREAD_PROFILER.with_borrow_mut(|thread| {
                thread.pop(time);
            })
        }
    }
}

#[allow(dead_code)]
pub struct ProfiDrop<W: std::io::Write, F: Fn(&mut W)>(W, F);

impl<W, F> ProfiDrop<W, F>
where
    W: std::io::Write,
    F: Fn(&mut W),
{
    pub fn new(to: W, ondrop: F) -> Self {
        Self(to, ondrop)
    }
}

#[cfg(feature = "enable")]
impl<W, F> std::ops::Drop for ProfiDrop<W, F>
where
    W: std::io::Write,
    F: Fn(&mut W),
{
    fn drop(&mut self) {
        drop_threads();
        block_until_exited();
        print_timings_to(&mut self.0).unwrap();
        let s = &self.1;
        s(&mut self.0)
    }
}

#[inline(always)]
pub fn dbg_thread() {
    #[cfg(feature = "enable")]
    crate::measure::THREAD_PROFILER.with_borrow(|t| println!("{t:#?}"));
}

#[cfg(feature = "enable")]
fn drop_threads() {
    crate::measure::THREAD_PROFILER.with_borrow_mut(|t| {
        t.manual_drop(true);

        #[cfg(feature = "rayon")]
        {
            // Drop threads manually, as `rayon` never drops them
            let current = std::thread::current().id();

            rayon::broadcast(|t| {
                if std::thread::current().id() != current {
                    crate::measure::THREAD_PROFILER.with_borrow_mut(|t| t.manual_drop(false))
                }
            });
        }
    });
}

/// **Should not be used on its own, will be applied automatically with `print_on_exit!`.**
///
/// Blocks until all threads are dropped.
///
/// Must be used on [`print_on_exit!`](crate::print_on_exit) because sometimes the threads will drop *after* the main one, corrupting the results.
#[cfg(feature = "enable")]
fn block_until_exited() {
    // Wait for all threads to finish
    #[cfg(feature = "enable")]
    let mut threads = crate::measure::GLOBAL_PROFILER.threads.lock().unwrap();
    #[cfg(feature = "enable")]
    while *threads > 1 {
        threads = crate::measure::GLOBAL_PROFILER.cvar.wait(threads).unwrap();
    }
}

/// Prints the profiled timings to stdout.
///
/// If profiling the `main` function, you can use [`print_on_exit!`](crate::print_on_exit) instead.
///
/// It's recommended to only use it when all threads have exited and have been joined correctly, or you'll risk corrupt data.
#[inline(always)]
pub fn print_timings() -> std::io::Result<()> {
    #[cfg(feature = "enable")]
    crate::measure::GLOBAL_PROFILER.print_timings(std::io::stdout().lock())?;
    Ok(())
}
/// Prints the profiled timings to stderr.
///
/// If profiling the `main` function, you can use [`print_on_exit!`](crate::print_on_exit) instead.
///
/// It's recommended to only use it when all threads have exited and have been joined correctly, or you'll risk corrupt data.
#[inline(always)]
pub fn eprint_timings() -> std::io::Result<()> {
    #[cfg(feature = "enable")]
    crate::measure::GLOBAL_PROFILER.print_timings(std::io::stderr())?;
    Ok(())
}
/// Prints the profiled timings to the provided [`std::io::Write`].
///
/// If profiling the `main` function, you can use [`print_on_exit!`](crate::print_on_exit) instead.
///
/// It's recommended to only use it when all threads have exited and have been joined correctly, or you'll risk corrupt data.
#[inline(always)]
#[allow(unused)]
pub fn print_timings_to(to: impl std::io::Write) -> std::io::Result<()> {
    #[cfg(feature = "enable")]
    crate::measure::GLOBAL_PROFILER.print_timings(to)?;
    Ok(())
}

#[cfg(feature = "nightly")]
#[inline(always)]
pub const fn type_name_of(f: fn()) -> &'static str {
    std::any::type_name_of_val(&f)
}

#[cfg(not(feature = "nightly"))]
#[inline(always)]
pub fn type_name_of<T>(_: T) -> &'static str {
    std::any::type_name::<T>()
}