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
151
152
153
154
155
//! `jemalloc`'s run-time configuration for profiling-specific settings.
//!
//! These settings are controlled by the `MALLOC_CONF` environment variable.
option! {
lg_prof_interval[ str: b"opt.lg_prof_interval\0", non_str: 2 ] => libc::ssize_t |
ops: r |
docs:
/// Average interval (log base 2) between memory profile dumps, as measured in bytes of
/// allocation activity.
///
/// The actual interval between dumps may be sporadic because
/// decentralized allocation counters are used to avoid synchronization bottlenecks.
///
/// Profiles are dumped to files named according to the pattern
/// \<prefix\>.\<pid\>.\<seq\>.i\<iseq\>.heap, where \<prefix\> is controlled by the
/// opt.prof_prefix and prof.prefix options. By default, interval-triggered profile dumping is
/// disabled (encoded as -1).
///
/// # Examples
///
/// ```
/// # #[global_allocator]
/// # static ALLOC: tikv_jemallocator::Jemalloc = tikv_jemallocator::Jemalloc;
/// #
/// # fn main() {
/// use tikv_jemalloc_ctl::profiling;
/// let lg_prof_interval = profiling::lg_prof_interval::read().unwrap();
/// println!("average interval between memory profile dumps: {}", lg_prof_interval);
/// # }
/// ```
mib_docs: /// See [`lg_prof_interval`].
}
option! {
lg_prof_sample[ str: b"opt.lg_prof_sample\0", non_str: 2 ] => libc::size_t |
ops: r |
docs:
/// Average interval (log base 2) between allocation samples, as measured in bytes of
/// allocation activity. Increasing the sampling interval decreases profile fidelity, but also
/// decreases the computational overhead.
///
/// The default sample interval is 512 KiB (2^19 B).
///
/// # Examples
///
/// ```
/// # #[global_allocator]
/// # static ALLOC: tikv_jemallocator::Jemalloc = tikv_jemallocator::Jemalloc;
/// #
/// # fn main() {
/// use tikv_jemalloc_ctl::profiling;
/// let lg_prof_sample = profiling::lg_prof_sample::read().unwrap();
/// println!("average interval between allocation samples: {}", lg_prof_sample);
/// # }
/// ```
mib_docs: /// See [`lg_prof_sample`].
}
option! {
prof_final[ str: b"opt.prof_final\0", non_str: 2 ] => bool |
ops: r |
docs:
/// Use an atexit(3) function to dump final memory usage to a file named according to the
/// pattern \<prefix\>.\<pid\>.\<seq\>.f.heap, where \<prefix\> is controlled by the opt.prof_prefix
/// and prof.prefix options.
///
/// Note that atexit() may allocate memory during application initialization and then deadlock
/// internally when jemalloc in turn calls `atexit()`, so this option is not universally usable
/// (though the application can register its own `atexit()` function with equivalent
/// functionality).
///
/// This option is disabled by default.
///
/// # Examples
///
/// ```
/// # #[global_allocator]
/// # static ALLOC: tikv_jemallocator::Jemalloc = tikv_jemallocator::Jemalloc;
/// #
/// # fn main() {
/// use tikv_jemalloc_ctl::profiling;
/// let prof_final = profiling::prof_final::read().unwrap();
/// println!("dump final memory usage to file: {}", prof_final);
/// # }
/// ```
mib_docs: /// See [`prof_final`].
}
option! {
prof[ str: b"opt.prof\0", non_str: 2 ] => bool |
ops: r |
docs:
/// Memory profiling enabled/disabled.
///
/// If enabled, profile memory allocation activity.
///
/// See the `opt.prof_active` option for on-the-fly activation/deactivation.
///
/// See the `opt.lg_prof_sample` option for probabilistic sampling control.
///
/// See the `opt.prof_accum` option for control of cumulative sample reporting.
///
/// See the `opt.lg_prof_interval` option for information on interval-triggered profile
/// dumping, the `opt.prof_gdump` option for information on high-water-triggered profile
/// dumping, and the `opt.prof_final` option for final profile dumping.
///
/// Profile output is compatible with the jeprof command, which is based on the pprof that is
/// developed as part of the gperftools package. See `HEAP PROFILE FORMAT` for heap profile
/// format documentation.
///
/// # Examples
///
/// ```
/// # #[global_allocator]
/// # static ALLOC: tikv_jemallocator::Jemalloc = tikv_jemallocator::Jemalloc;
/// #
/// # fn main() {
/// use tikv_jemalloc_ctl::profiling;
/// let prof = profiling::prof::read().unwrap();
/// println!("is memory profiling enabled: {}", prof);
/// # }
/// ```
mib_docs: /// See [`prof`].
}
option! {
prof_leak[ str: b"opt.prof_leak\0", non_str: 2 ] => bool |
ops: r |
docs:
/// Leak reporting enabled/disabled.
///
/// If enabled, use an `atexit(3)` function to report memory leaks detected by allocation
/// sampling.
///
/// See the opt.prof option for information on analyzing heap profile output.
///
/// Works only when combined with `opt.prof_final`, otherwise does nothing.
///
/// This option is disabled by default.
///
/// # Examples
///
/// ```
/// # #[global_allocator]
/// # static ALLOC: tikv_jemallocator::Jemalloc = tikv_jemallocator::Jemalloc;
/// #
/// # fn main() {
/// use tikv_jemalloc_ctl::profiling;
/// let prof_leak = profiling::prof_leak::read().unwrap();
/// println!("is leak reporting enabled: {}", prof_leak);
/// # }
/// ```
mib_docs: /// See [`prof_leak`].
}