pprof-alloc 0.2.0

Allocation profiling and Linux memory telemetry for Rust services.
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

#[cfg(not(all(
	feature = "frame-pointer",
	target_os = "linux",
	any(target_arch = "x86_64", target_arch = "aarch64")
)))]
use backtrace::trace;
#[cfg(all(
	feature = "frame-pointer",
	target_os = "linux",
	any(target_arch = "x86_64", target_arch = "aarch64")
))]
use frame_pointer::trace;

use itertools::Itertools;
use serde::Serialize;
use smallvec::SmallVec;
use std::fmt;
use std::hash::{Hash, Hasher};

#[cfg(not(all(
	feature = "frame-pointer",
	target_os = "linux",
	any(target_arch = "x86_64", target_arch = "aarch64")
)))]
mod backtrace;
#[cfg(all(
	feature = "frame-pointer",
	target_os = "linux",
	any(target_arch = "x86_64", target_arch = "aarch64")
))]
mod frame_pointer;

const SOFT_MAX_DEPTH: usize = 128;

#[derive(Clone, Copy, Debug, PartialEq, Eq, Serialize)]
pub enum CaptureMode {
	FramePointer,
	Backtrace,
}

#[cfg(all(
	feature = "frame-pointer",
	target_os = "linux",
	any(target_arch = "x86_64", target_arch = "aarch64")
))]
pub const fn capture_mode() -> CaptureMode {
	CaptureMode::FramePointer
}

#[cfg(not(all(
	feature = "frame-pointer",
	target_os = "linux",
	any(target_arch = "x86_64", target_arch = "aarch64")
)))]
pub const fn capture_mode() -> CaptureMode {
	CaptureMode::Backtrace
}

#[derive(Clone)]
struct UnresolvedFrames(SmallVec<[u64; SOFT_MAX_DEPTH]>);

impl From<SmallVec<[u64; SOFT_MAX_DEPTH]>> for UnresolvedFrames {
	fn from(x: SmallVec<[u64; SOFT_MAX_DEPTH]>) -> Self {
		Self(x)
	}
}

#[derive(Clone)]
pub struct HashedBacktrace {
	inner: UnresolvedFrames,
	hash: u64,
}

impl fmt::Debug for HashedBacktrace {
	fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
		let address = self.inner.0.iter().map(|x| format!("{:#x}", x)).join(" ");
		f.write_str(&address)
	}
}

impl HashedBacktrace {
	pub fn capture() -> Self {
		let bt = trace();
		let mut hasher = ahash::AHasher::default();
		bt.0.iter().for_each(|x| hasher.write_u64(*x));
		let hash = hasher.finish();
		Self { inner: bt, hash }
	}
	pub fn addrs(&self) -> Vec<u64> {
		self.inner.0.iter().copied().collect_vec()
	}
}

impl PartialEq for HashedBacktrace {
	fn eq(&self, other: &Self) -> bool {
		self.hash == other.hash && self.inner.0 == other.inner.0
	}
}

impl Eq for HashedBacktrace {}

impl Hash for HashedBacktrace {
	fn hash<H: Hasher>(&self, state: &mut H) {
		self.inner.0.iter().for_each(|x| state.write_u64(*x));
	}
}