mirror of
https://forgejo.ellis.link/continuwuation/continuwuity.git
synced 2026-11-22 08:27:32 +00:00
refactor: Unify memory stats and create feature parity
This commit is contained in:
9 files changed
+259
-64
No files matched your search
@@ -82,6 +82,7 @@ Names below are as they appear in Prometheus. OTLP uses the dotted OpenTelemetry
|
||||
| `continuwuity_database_block_cache_bytes` | gauge | `column` | RocksDB block cache usage |
|
||||
| `continuwuity_cache_entries` | gauge | `name` | Entries in the auth chain and state info caches |
|
||||
| `continuwuity_jemalloc_memory_bytes` | gauge | `kind` | jemalloc statistics, only with the `jemalloc_stats` feature |
|
||||
| `continuwuity_mimalloc_memory_bytes` | gauge | `kind` | mimalloc statistics, only with the `mimalloc` feature |
|
||||
| `process_uptime_seconds` | gauge | | Time since the server started |
|
||||
| `process_cpu_time_seconds_total` | counter | `cpu_mode` | CPU time used by the process |
|
||||
| `process_memory_usage_bytes` | gauge | | Resident memory (Linux) |
|
||||
|
||||
@@ -1007,7 +1007,7 @@ impl crate::Context<'_> {
|
||||
pub(super) async fn memory_stats(&self, opts: Option<String>) -> Result {
|
||||
const OPTS: &str = "abcdefghijklmnopqrstuvwxyz";
|
||||
|
||||
let opts: String = OPTS
|
||||
let mut mapped_opts: String = OPTS
|
||||
.chars()
|
||||
.filter(|&c| {
|
||||
let allow_any = opts.as_ref().is_some_and(|opts| opts == "*");
|
||||
@@ -1018,7 +1018,11 @@ impl crate::Context<'_> {
|
||||
})
|
||||
.collect();
|
||||
|
||||
let stats = conduwuit::alloc::memory_stats(&opts).unwrap_or_default();
|
||||
if opts.as_ref().is_some_and(|opts| opts.contains('J')) {
|
||||
mapped_opts.push('J');
|
||||
}
|
||||
|
||||
let stats = conduwuit::alloc::memory_stats(&mapped_opts).unwrap_or_default();
|
||||
|
||||
self.write_str("```\n").await?;
|
||||
self.write_str(&stats).await?;
|
||||
|
||||
@@ -192,7 +192,8 @@ pub enum DebugCommand {
|
||||
///
|
||||
/// Optional argument is a character mask (a sequence of characters in any
|
||||
/// order) which enable additional extended statistics. Known characters are
|
||||
/// "abdeglmx". For convenience, a '*' will enable everything.
|
||||
/// "abdeglmx" and 'J' for JSON output. For convenience, a '*' will enable
|
||||
/// everything.
|
||||
MemoryStats {
|
||||
opts: Option<String>,
|
||||
},
|
||||
|
||||
@@ -1,5 +1,9 @@
|
||||
//! Default allocator with no special features
|
||||
|
||||
use arrayvec::ArrayVec;
|
||||
|
||||
pub(crate) fn metric() -> Option<(&'static str, &'static str)> { None }
|
||||
|
||||
/// Always returns Ok
|
||||
pub fn trim<I: Into<Option<usize>>>(_: I) -> crate::Result { Ok(()) }
|
||||
|
||||
@@ -12,4 +16,4 @@ pub fn memory_stats(_opts: &str) -> Option<String> { None }
|
||||
pub fn memory_usage() -> Option<String> { None }
|
||||
|
||||
#[must_use]
|
||||
pub fn memory_usage_stats() -> Option<[(&'static str, usize); 6]> { None }
|
||||
pub fn memory_usage_stats() -> Option<ArrayVec<(&'static str, usize), 6>> { None }
|
||||
+19
-11
@@ -103,22 +103,30 @@ fn _static_initialization() {
|
||||
}
|
||||
}
|
||||
|
||||
pub(crate) fn metric() -> Option<(&'static str, &'static str)> {
|
||||
Some((
|
||||
"continuwuity.jemalloc.memory",
|
||||
"jemalloc memory statistics, when built with jemalloc_stats",
|
||||
))
|
||||
}
|
||||
|
||||
#[must_use]
|
||||
#[cfg(feature = "jemalloc_stats")]
|
||||
pub fn memory_usage() -> Option<String> {
|
||||
use std::fmt::Write;
|
||||
|
||||
let mibs = |input: usize| {
|
||||
let whole = u32::try_from(input / (1024 * 1024)).unwrap_or(u32::MAX);
|
||||
let rem_kibs = u32::try_from((input / 1024) % 1024).unwrap_or_default();
|
||||
f64::from(whole) + f64::from(rem_kibs) / 1024.0
|
||||
};
|
||||
|
||||
let [allocated, active, mapped, metadata, resident, retained] =
|
||||
memory_usage_stats()?.map(|(_, bytes)| mibs(bytes));
|
||||
Some(format!(
|
||||
"allocated: {allocated:.2} MiB\nactive: {active:.2} MiB\nmapped: {mapped:.2} \
|
||||
MiB\nmetadata: {metadata:.2} MiB\nresident: {resident:.2} MiB\nretained: {retained:.2} \
|
||||
MiB\n"
|
||||
))
|
||||
let mut out = String::new();
|
||||
for (name, bytes) in memory_usage_stats()? {
|
||||
writeln!(out, "{name}: {:.2} MiB", mibs(bytes)).ok()?;
|
||||
}
|
||||
|
||||
Some(out)
|
||||
}
|
||||
|
||||
#[must_use]
|
||||
@@ -127,25 +135,25 @@ pub fn memory_usage() -> Option<String> { None }
|
||||
|
||||
#[must_use]
|
||||
#[cfg(feature = "jemalloc_stats")]
|
||||
pub fn memory_usage_stats() -> Option<[(&'static str, usize); 6]> {
|
||||
pub fn memory_usage_stats() -> Option<ArrayVec<(&'static str, usize), 6>> {
|
||||
use mallctl::stats;
|
||||
|
||||
// Advance the epoch; ensure latest stats are pulled in
|
||||
inc_epoch().ok()?;
|
||||
|
||||
Some([
|
||||
Some(ArrayVec::from([
|
||||
("allocated", stats::allocated::read().unwrap_or_default()),
|
||||
("active", stats::active::read().unwrap_or_default()),
|
||||
("mapped", stats::mapped::read().unwrap_or_default()),
|
||||
("metadata", stats::metadata::read().unwrap_or_default()),
|
||||
("resident", stats::resident::read().unwrap_or_default()),
|
||||
("retained", stats::retained::read().unwrap_or_default()),
|
||||
])
|
||||
]))
|
||||
}
|
||||
|
||||
#[must_use]
|
||||
#[cfg(not(feature = "jemalloc_stats"))]
|
||||
pub fn memory_usage_stats() -> Option<[(&'static str, usize); 6]> { None }
|
||||
pub fn memory_usage_stats() -> Option<ArrayVec<(&'static str, usize), 6>> { None }
|
||||
|
||||
struct StatsPrintState {
|
||||
buf: String,
|
||||
|
||||
+194
-47
@@ -1,68 +1,165 @@
|
||||
//! mimalloc allocator
|
||||
|
||||
use std::ptr;
|
||||
use std::{
|
||||
any::Any,
|
||||
ffi::{CStr, c_void},
|
||||
panic::{self, AssertUnwindSafe},
|
||||
ptr,
|
||||
};
|
||||
|
||||
use arrayvec::ArrayVec;
|
||||
use libmimalloc_sys as ffi;
|
||||
use mimalloc::MiMalloc;
|
||||
use serde::Deserialize;
|
||||
|
||||
#[global_allocator]
|
||||
static MIMALLOC: MiMalloc = MiMalloc;
|
||||
|
||||
#[derive(Deserialize)]
|
||||
struct StatCount {
|
||||
current: i64,
|
||||
peak: i64,
|
||||
}
|
||||
|
||||
#[derive(Deserialize)]
|
||||
struct Stats {
|
||||
reserved: StatCount,
|
||||
committed: StatCount,
|
||||
purged: i64,
|
||||
reset: i64,
|
||||
}
|
||||
|
||||
trait OutputFnChar {
|
||||
type Char;
|
||||
}
|
||||
|
||||
impl<C> OutputFnChar for Option<unsafe extern "C" fn(*const C, *mut c_void)> {
|
||||
type Char = C;
|
||||
}
|
||||
|
||||
type MiChar = <ffi::mi_output_fun as OutputFnChar>::Char;
|
||||
|
||||
struct StatsPrintState {
|
||||
buf: String,
|
||||
max_len: usize,
|
||||
panic: Option<Box<dyn Any + Send>>,
|
||||
}
|
||||
|
||||
pub(crate) fn metric() -> Option<(&'static str, &'static str)> {
|
||||
Some(("continuwuity.mimalloc.memory", "mimalloc memory statistics"))
|
||||
}
|
||||
|
||||
pub fn trim<I: Into<Option<usize>>>(_: I) -> crate::Result {
|
||||
// SAFETY: `mi_collect` is thread-safe and takes a single boolean flag.
|
||||
unsafe {
|
||||
ffi::mi_collect(true);
|
||||
}
|
||||
unsafe { ffi::mi_collect(true) };
|
||||
|
||||
Ok(())
|
||||
}
|
||||
|
||||
fn read_stats() -> Option<Stats> {
|
||||
let stats = MiMalloc::stats_json().ok()?;
|
||||
let json = stats.to_str().ok()?;
|
||||
serde_json::from_str(json).ok()
|
||||
}
|
||||
|
||||
fn non_neg_usize(value: i64) -> usize { usize::try_from(value.max(0)).unwrap_or(usize::MAX) }
|
||||
|
||||
fn mibs(input: usize) -> f64 {
|
||||
let whole = u32::try_from(input / (1024 * 1024)).unwrap_or(u32::MAX);
|
||||
let rem_kibs = u32::try_from((input / 1024) % 1024).unwrap_or_default();
|
||||
f64::from(whole) + f64::from(rem_kibs) / 1024.0
|
||||
}
|
||||
|
||||
#[must_use]
|
||||
pub fn memory_usage() -> Option<String> {
|
||||
let mut current_rss = 0;
|
||||
let mut peak_rss = 0;
|
||||
let mut current_commit = 0;
|
||||
let mut peak_commit = 0;
|
||||
|
||||
// SAFETY: All non-null out-pointers are valid writable `usize` stack slots;
|
||||
// null pointers are explicitly permitted by `mi_process_info`.
|
||||
unsafe {
|
||||
ffi::mi_process_info(
|
||||
ptr::null_mut(),
|
||||
ptr::null_mut(),
|
||||
ptr::null_mut(),
|
||||
&raw mut current_rss,
|
||||
&raw mut peak_rss,
|
||||
&raw mut current_commit,
|
||||
&raw mut peak_commit,
|
||||
ptr::null_mut(),
|
||||
);
|
||||
}
|
||||
|
||||
let mibs = |input: usize| {
|
||||
let whole = u32::try_from(input / (1024 * 1024)).unwrap_or(u32::MAX);
|
||||
let rem_kibs = u32::try_from((input / 1024) % 1024).unwrap_or_default();
|
||||
f64::from(whole) + f64::from(rem_kibs) / 1024.0
|
||||
};
|
||||
let stats = read_stats()?;
|
||||
|
||||
Some(format!(
|
||||
"current_rss: {:.2} MiB\npeak_rss: {:.2} MiB\ncurrent_commit: {:.2} MiB\npeak_commit: \
|
||||
{:.2} MiB\n",
|
||||
mibs(current_rss),
|
||||
mibs(peak_rss),
|
||||
mibs(current_commit),
|
||||
mibs(peak_commit),
|
||||
"reserved: {:.2} MiB\nreserved_peak: {:.2} MiB\ncommitted: {:.2} MiB\ncommitted_peak: \
|
||||
{:.2} MiB\npurged_total: {:.2} MiB\nreset_total: {:.2} MiB\n",
|
||||
mibs(non_neg_usize(stats.reserved.current)),
|
||||
mibs(non_neg_usize(stats.reserved.peak)),
|
||||
mibs(non_neg_usize(stats.committed.current)),
|
||||
mibs(non_neg_usize(stats.committed.peak)),
|
||||
mibs(non_neg_usize(stats.purged)),
|
||||
mibs(non_neg_usize(stats.reset)),
|
||||
))
|
||||
}
|
||||
|
||||
#[must_use]
|
||||
pub fn memory_usage_stats() -> Option<[(&'static str, usize); 6]> { None }
|
||||
pub fn memory_usage_stats() -> Option<ArrayVec<(&'static str, usize), 6>> {
|
||||
let stats = read_stats()?;
|
||||
let mut out = ArrayVec::new();
|
||||
out.extend([
|
||||
("reserved", non_neg_usize(stats.reserved.current)),
|
||||
("reserved_peak", non_neg_usize(stats.reserved.peak)),
|
||||
("committed", non_neg_usize(stats.committed.current)),
|
||||
("committed_peak", non_neg_usize(stats.committed.peak)),
|
||||
]);
|
||||
|
||||
Some(out)
|
||||
}
|
||||
|
||||
#[must_use]
|
||||
pub fn memory_stats(_opts: &str) -> Option<String> {
|
||||
MiMalloc::stats_json()
|
||||
.ok()
|
||||
.and_then(|stats| stats.to_str().ok().map(str::to_owned))
|
||||
pub fn memory_stats(opts: &str) -> Option<String> {
|
||||
const MAX_LENGTH: usize = 1_048_576;
|
||||
|
||||
if opts.contains('\0') {
|
||||
return None;
|
||||
}
|
||||
|
||||
if opts.contains('J') {
|
||||
let stats = MiMalloc::stats_json().ok()?;
|
||||
let json = String::from_utf8_lossy(stats.to_bytes());
|
||||
let end = json.floor_char_boundary(json.len().min(MAX_LENGTH));
|
||||
return json.get(..end).map(str::to_owned);
|
||||
}
|
||||
|
||||
let mut state = StatsPrintState {
|
||||
buf: String::new(),
|
||||
max_len: MAX_LENGTH,
|
||||
panic: None,
|
||||
};
|
||||
let opaque = ptr::from_mut(&mut state).cast::<c_void>();
|
||||
|
||||
// SAFETY: `state` remains live in this frame for the duration of
|
||||
// `mi_stats_print_out()`, which invokes `mi_stats_cb` synchronously.
|
||||
unsafe { ffi::mi_stats_print_out(Some(mi_stats_cb), opaque) };
|
||||
|
||||
if let Some(payload) = state.panic {
|
||||
panic::resume_unwind(payload);
|
||||
}
|
||||
|
||||
Some(state.buf)
|
||||
}
|
||||
|
||||
unsafe extern "C" fn mi_stats_cb(msg: *const MiChar, arg: *mut c_void) {
|
||||
// SAFETY: `arg` points to `StatsPrintState` on the caller's stack.
|
||||
let Some(state) = (unsafe { arg.cast::<StatsPrintState>().as_mut() }) else {
|
||||
return;
|
||||
};
|
||||
|
||||
if state.panic.is_some() || msg.is_null() || state.buf.len() >= state.max_len {
|
||||
return;
|
||||
}
|
||||
|
||||
// SAFETY: mimalloc guarantees `msg` is a valid NUL-terminated C string.
|
||||
let msg = unsafe { CStr::from_ptr(msg.cast()) };
|
||||
|
||||
if let Err(err) = panic::catch_unwind(AssertUnwindSafe(|| {
|
||||
let msg = String::from_utf8_lossy(msg.to_bytes());
|
||||
let remaining = state.max_len.saturating_sub(state.buf.len());
|
||||
if msg.len() <= remaining {
|
||||
state.buf.push_str(msg.as_ref());
|
||||
} else {
|
||||
if let Some(prefix) = msg.get(..msg.floor_char_boundary(remaining)) {
|
||||
state.buf.push_str(prefix);
|
||||
}
|
||||
state.max_len = state.buf.len();
|
||||
}
|
||||
})) {
|
||||
state.panic = Some(err);
|
||||
}
|
||||
}
|
||||
|
||||
#[cfg(test)]
|
||||
@@ -73,15 +170,65 @@ mod tests {
|
||||
fn trim_succeeds() { trim(None).expect("trim(None)"); }
|
||||
|
||||
#[test]
|
||||
fn memory_usage_returns_rss_and_commit() {
|
||||
let usage = memory_usage().expect("memory_usage");
|
||||
assert!(usage.contains("current_rss:"), "unexpected usage: {usage}");
|
||||
assert!(usage.contains("current_commit:"), "unexpected usage: {usage}");
|
||||
fn non_neg_usize_clamps_negative_values() {
|
||||
assert_eq!(non_neg_usize(-1), 0, "expected -1 to clamp to 0");
|
||||
assert_eq!(non_neg_usize(i64::MIN), 0, "expected i64::MIN to clamp to 0");
|
||||
assert_eq!(non_neg_usize(0), 0, "expected 0 to remain 0");
|
||||
assert_eq!(non_neg_usize(4096), 4096, "expected positive value unchanged");
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn memory_stats_returns_json() {
|
||||
let stats = memory_stats("").expect("memory_stats");
|
||||
assert!(stats.starts_with('{'), "expected JSON object, got: {stats}");
|
||||
fn memory_usage_stats_reports_allocator_bytes() {
|
||||
let buf = std::hint::black_box(vec![0_u8; 64 * 1024]);
|
||||
let stats = memory_usage_stats().expect("memory_usage_stats");
|
||||
drop(buf);
|
||||
|
||||
let keys: Vec<_> = stats.iter().map(|&(key, _)| key).collect();
|
||||
assert_eq!(
|
||||
keys,
|
||||
["reserved", "reserved_peak", "committed", "committed_peak"],
|
||||
"unexpected stat keys"
|
||||
);
|
||||
|
||||
for (key, bytes) in stats {
|
||||
assert!(bytes > 0, "expected {key} > 0, got {bytes}");
|
||||
}
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn memory_usage_returns_allocator_summary() {
|
||||
let usage = memory_usage().expect("memory_usage");
|
||||
for expected in [
|
||||
"reserved:",
|
||||
"reserved_peak:",
|
||||
"committed:",
|
||||
"committed_peak:",
|
||||
"purged_total:",
|
||||
"reset_total:",
|
||||
"MiB",
|
||||
] {
|
||||
assert!(usage.contains(expected), "missing {expected:?} in usage:\n{usage}");
|
||||
}
|
||||
assert!(!usage.contains("current_rss:"), "unexpected current_rss in usage:\n{usage}");
|
||||
assert!(!usage.contains("peak_rss:"), "unexpected peak_rss in usage:\n{usage}");
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn memory_stats_supports_text_json_and_rejects_nul() {
|
||||
assert!(memory_stats("invalid\0opts").is_none(), "expected NUL opts to return None");
|
||||
|
||||
for opts in ["", "abcdefghijklmnopqrstuvwxyz"] {
|
||||
let stats = memory_stats(opts).expect("memory_stats text");
|
||||
assert!(!stats.is_empty(), "expected non-empty stats for opts={opts:?}");
|
||||
assert!(!stats.starts_with('{'), "expected formatted text, got JSON:\n{stats}");
|
||||
assert!(stats.contains("reserved"), "missing reserved in stats:\n{stats}");
|
||||
assert!(stats.contains("committed"), "missing committed in stats:\n{stats}");
|
||||
}
|
||||
|
||||
let json = memory_stats("J").expect("memory_stats JSON");
|
||||
assert!(json.starts_with('{'), "expected JSON object, got:\n{json}");
|
||||
let parsed: serde_json::Value =
|
||||
serde_json::from_str(&json).expect("expected valid JSON from memory_stats(\"J\")");
|
||||
assert!(parsed.get("committed").is_some(), "expected committed field in JSON");
|
||||
}
|
||||
}
|
||||
@@ -4,16 +4,22 @@
|
||||
#[cfg(all(not(target_env = "msvc"), feature = "jemalloc"))]
|
||||
pub mod je;
|
||||
#[cfg(all(not(target_env = "msvc"), feature = "jemalloc"))]
|
||||
pub(crate) use je::metric;
|
||||
#[cfg(all(not(target_env = "msvc"), feature = "jemalloc"))]
|
||||
pub use je::{memory_stats, memory_usage, memory_usage_stats, trim};
|
||||
|
||||
// mimalloc
|
||||
#[cfg(all(feature = "mimalloc", any(target_env = "msvc", not(feature = "jemalloc"))))]
|
||||
pub mod mimalloc;
|
||||
#[cfg(all(feature = "mimalloc", any(target_env = "msvc", not(feature = "jemalloc"))))]
|
||||
pub(crate) use mimalloc::metric;
|
||||
#[cfg(all(feature = "mimalloc", any(target_env = "msvc", not(feature = "jemalloc"))))]
|
||||
pub use mimalloc::{memory_stats, memory_usage, memory_usage_stats, trim};
|
||||
|
||||
// default
|
||||
#[cfg(all(not(feature = "mimalloc"), any(target_env = "msvc", not(feature = "jemalloc"))))]
|
||||
pub mod default;
|
||||
#[cfg(all(not(feature = "mimalloc"), any(target_env = "msvc", not(feature = "jemalloc"))))]
|
||||
pub(crate) use default::metric;
|
||||
#[cfg(all(not(feature = "mimalloc"), any(target_env = "msvc", not(feature = "jemalloc"))))]
|
||||
pub use default::{memory_stats, memory_usage, memory_usage_stats, trim};
|
||||
@@ -196,9 +196,13 @@ fn register_process(meter: &Meter) {
|
||||
}
|
||||
|
||||
fn register_allocator(meter: &Meter) {
|
||||
let Some((name, description)) = crate::alloc::metric() else {
|
||||
return;
|
||||
};
|
||||
|
||||
meter
|
||||
.u64_observable_gauge("continuwuity.jemalloc.memory")
|
||||
.with_description("jemalloc memory statistics, when built with jemalloc_stats")
|
||||
.u64_observable_gauge(name)
|
||||
.with_description(description)
|
||||
.with_unit("By")
|
||||
.with_callback(|observer| {
|
||||
for (kind, bytes) in crate::alloc::memory_usage_stats().into_iter().flatten() {
|
||||
|
||||
@@ -38,3 +38,23 @@ async fn renders_prometheus_names() {
|
||||
}
|
||||
assert!(!body.contains("otel_scope_name"));
|
||||
}
|
||||
|
||||
#[tokio::test]
|
||||
#[cfg(all(feature = "mimalloc", any(target_env = "msvc", not(feature = "jemalloc"))))]
|
||||
async fn renders_mimalloc_memory_metric() {
|
||||
let (metrics, _provider) = metrics();
|
||||
let body = metrics.render().unwrap();
|
||||
|
||||
for expected in [
|
||||
"continuwuity_mimalloc_memory_bytes{kind=\"reserved\"}",
|
||||
"continuwuity_mimalloc_memory_bytes{kind=\"reserved_peak\"}",
|
||||
"continuwuity_mimalloc_memory_bytes{kind=\"committed\"}",
|
||||
"continuwuity_mimalloc_memory_bytes{kind=\"committed_peak\"}",
|
||||
] {
|
||||
assert!(body.contains(expected), "missing {expected:?} in:\n{body}");
|
||||
}
|
||||
assert!(
|
||||
!body.contains("continuwuity_jemalloc_memory_bytes"),
|
||||
"unexpected jemalloc metric in mimalloc build:\n{body}"
|
||||
);
|
||||
}
|
||||
Reference in new issue
Block a user