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
|
//! Like `std::time::Instant`, but also measures memory & CPU cycles.
use std::{
fmt,
time::{Duration, Instant},
};
use crate::MemoryUsage;
pub struct StopWatch {
time: Instant,
#[cfg(target_os = "linux")]
counter: Option<perf_event::Counter>,
memory: Option<MemoryUsage>,
}
pub struct StopWatchSpan {
pub time: Duration,
pub instructions: Option<u64>,
pub memory: Option<MemoryUsage>,
}
impl StopWatch {
pub fn start() -> StopWatch {
#[cfg(target_os = "linux")]
let counter = {
let mut counter = perf_event::Builder::new()
.build()
.map_err(|err| eprintln!("Failed to create perf counter: {}", err))
.ok();
if let Some(counter) = &mut counter {
if let Err(err) = counter.enable() {
eprintln!("Failed to start perf counter: {}", err)
}
}
counter
};
let time = Instant::now();
StopWatch {
time,
#[cfg(target_os = "linux")]
counter,
memory: None,
}
}
pub fn memory(mut self, yes: bool) -> StopWatch {
if yes {
self.memory = Some(MemoryUsage::current());
}
self
}
pub fn elapsed(&mut self) -> StopWatchSpan {
let time = self.time.elapsed();
#[cfg(target_os = "linux")]
let instructions = self.counter.as_mut().and_then(|it| {
it.read().map_err(|err| eprintln!("Failed to read perf counter: {}", err)).ok()
});
#[cfg(not(target_os = "linux"))]
let instructions = None;
let memory = self.memory.map(|it| MemoryUsage::current() - it);
StopWatchSpan { time, instructions, memory }
}
}
impl fmt::Display for StopWatchSpan {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
write!(f, "{:.2?}", self.time)?;
if let Some(mut instructions) = self.instructions {
let mut prefix = "";
if instructions > 10000 {
instructions /= 1000;
prefix = "k"
}
if instructions > 10000 {
instructions /= 1000;
prefix = "m"
}
if instructions > 10000 {
instructions /= 1000;
prefix = "g"
}
write!(f, ", {}{}instr", instructions, prefix)?;
}
if let Some(memory) = self.memory {
write!(f, ", {}", memory)?;
}
Ok(())
}
}
|
