use std::process::Command;
#[cfg(target_os = "macos")]
use std::sync::Mutex;
use std::time::Duration;
#[derive(Debug, Clone, Copy, PartialEq)]
pub struct CpuUsage {
pub user: f32,
pub system: f32,
pub idle: f32,
}
pub fn parse_top_cpu(output: &str) -> Option<CpuUsage> {
let line = output
.lines()
.rfind(|l| l.trim_start().starts_with("CPU usage"))?;
let rest = line.split_once(':')?.1;
let field = |label: &str| -> Option<f32> {
rest.split(',')
.find(|part| part.trim_end().ends_with(label))?
.trim()
.split('%')
.next()?
.trim()
.parse()
.ok()
};
let user = field("user")?;
let system = field("sys")?;
let idle = field("idle")?;
if !(95.0..=105.0).contains(&(user + system + idle)) {
return None;
}
Some(CpuUsage { user, system, idle })
}
#[derive(Debug, Clone, Copy, PartialEq)]
pub struct VmStat {
pub page_size: u64,
pub free: u64,
pub active: u64,
pub inactive: u64,
pub speculative: u64,
pub wired: u64,
pub compressed: u64,
pub file_backed: u64,
}
impl VmStat {
pub fn used_bytes(&self) -> u64 {
(self.active + self.wired + self.compressed) * self.page_size
}
pub fn free_bytes(&self) -> u64 {
(self.free + self.speculative) * self.page_size
}
pub fn cached_bytes(&self) -> u64 {
self.file_backed * self.page_size
}
}
pub fn parse_vm_stat(output: &str) -> Option<VmStat> {
let page_size = output
.lines()
.next()
.and_then(|l| l.split("page size of ").nth(1))
.and_then(|s| s.split_whitespace().next())
.and_then(|s| s.parse::<u64>().ok())?;
let value = |label: &str| -> Option<u64> {
output
.lines()
.find(|l| l.trim_start().starts_with(label))
.and_then(|l| l.split_once(':'))
.map(|(_, v)| v.trim().trim_end_matches('.').replace(',', ""))
.and_then(|v| v.parse().ok())
};
Some(VmStat {
page_size,
free: value("Pages free")?,
active: value("Pages active")?,
inactive: value("Pages inactive")?,
speculative: value("Pages speculative")?,
wired: value("Pages wired down")?,
compressed: value("Pages occupied by compressor")?,
file_backed: value("File-backed pages")?,
})
}
#[derive(Debug, Clone, Copy, PartialEq)]
pub struct SwapUsage {
pub total: u64,
pub used: u64,
}
pub fn parse_swapusage(output: &str) -> Option<SwapUsage> {
let field = |label: &str| -> Option<u64> {
let after = output.split(&format!("{label} = ")).nth(1)?;
let token = after.split_whitespace().next()?;
let (number, suffix) = token.split_at(token.find(|c: char| c.is_alphabetic())?);
let value: f64 = number.parse().ok()?;
let scale = match suffix {
"K" | "k" => 1024.0,
"M" | "m" => 1024.0 * 1024.0,
"G" | "g" => 1024.0 * 1024.0 * 1024.0,
"T" | "t" => 1024.0 * 1024.0 * 1024.0 * 1024.0,
"B" | "b" | "" => 1.0,
_ => return None,
};
Some((value * scale) as u64)
};
Some(SwapUsage {
total: field("total")?,
used: field("used")?,
})
}
#[derive(Debug, Clone, Copy, PartialEq, Eq, Default)]
pub struct CoreTicks {
pub user: u64,
pub system: u64,
pub idle: u64,
pub nice: u64,
}
#[derive(Debug, Clone, Copy, PartialEq)]
pub struct CoreUsage {
pub user: f32,
pub nice: f32,
pub system: f32,
pub idle: f32,
}
impl CoreTicks {
pub fn percentages(&self) -> Option<CoreUsage> {
let total = self.user + self.system + self.idle + self.nice;
if total == 0 {
return None;
}
let pct = |v: u64| (v as f64 / total as f64 * 100.0) as f32;
Some(CoreUsage {
user: pct(self.user),
nice: pct(self.nice),
system: pct(self.system),
idle: pct(self.idle),
})
}
}
pub fn aggregate_ticks(cores: &[CoreTicks]) -> CoreTicks {
cores.iter().fold(CoreTicks::default(), |mut acc, c| {
acc.user = acc.user.saturating_add(c.user);
acc.system = acc.system.saturating_add(c.system);
acc.idle = acc.idle.saturating_add(c.idle);
acc.nice = acc.nice.saturating_add(c.nice);
acc
})
}
pub const PRIME_INTERVAL: Duration = Duration::from_millis(200);
#[cfg(target_os = "macos")]
static PREVIOUS_CORES: Mutex<Option<Vec<CoreTicks>>> = Mutex::new(None);
pub fn per_core_usage_between(
earlier: &[CoreTicks],
later: &[CoreTicks],
) -> Vec<Option<CoreUsage>> {
if earlier.len() != later.len() {
return vec![None; later.len()];
}
earlier
.iter()
.zip(later)
.map(|(before, now)| usage_between(before, now))
.collect()
}
pub fn usage_between(earlier: &CoreTicks, later: &CoreTicks) -> Option<CoreUsage> {
let delta = CoreTicks {
user: later.user.checked_sub(earlier.user)?,
system: later.system.checked_sub(earlier.system)?,
idle: later.idle.checked_sub(earlier.idle)?,
nice: later.nice.checked_sub(earlier.nice)?,
};
delta.percentages()
}
#[cfg(target_os = "macos")]
pub fn current_total_usage() -> crate::error::Result<(CoreUsage, Vec<Option<CoreUsage>>)> {
use crate::error::IronError;
let read = || -> crate::error::Result<Vec<CoreTicks>> {
per_core_ticks().ok_or_else(|| {
IronError::UnsupportedPlatform("host_processor_info returned no per-core ticks".into())
})
};
let mut previous = PREVIOUS_CORES
.lock()
.unwrap_or_else(|poisoned| poisoned.into_inner());
let baseline: Vec<CoreTicks> = match previous.as_ref() {
Some(prior) => prior.clone(),
None => {
let first = read()?;
std::thread::sleep(PRIME_INTERVAL);
first
}
};
for attempt in 0..2 {
if attempt > 0 {
std::thread::sleep(PRIME_INTERVAL);
}
let now = read()?;
let total = usage_between(&aggregate_ticks(&baseline), &aggregate_ticks(&now));
let cores = per_core_usage_between(&baseline, &now);
*previous = Some(now);
if let Some(usage) = total {
return Ok((usage, cores));
}
}
Err(IronError::Parse(
concat!(
"per-core tick counters gave no usable split: they did not advance, ",
"or went backwards, between reads"
)
.into(),
))
}
#[cfg(target_os = "macos")]
pub fn per_core_ticks() -> Option<Vec<CoreTicks>> {
use std::ptr;
let mut cpu_count: libc::natural_t = 0;
let mut info: libc::processor_info_array_t = ptr::null_mut();
let mut info_count: libc::mach_msg_type_number_t = 0;
let result = unsafe {
libc::host_processor_info(
libc::mach_host_self(),
libc::PROCESSOR_CPU_LOAD_INFO,
&mut cpu_count,
&mut info,
&mut info_count,
)
};
if result != libc::KERN_SUCCESS || info.is_null() {
return None;
}
let states = libc::CPU_STATE_MAX as usize;
let data =
unsafe { std::slice::from_raw_parts(info as *const libc::integer_t, info_count as usize) };
let mut cores = Vec::with_capacity(cpu_count as usize);
for i in 0..cpu_count as usize {
let base = i * states;
if base + states > data.len() {
break;
}
cores.push(CoreTicks {
user: data[base + libc::CPU_STATE_USER as usize].max(0) as u64,
system: data[base + libc::CPU_STATE_SYSTEM as usize].max(0) as u64,
idle: data[base + libc::CPU_STATE_IDLE as usize].max(0) as u64,
nice: data[base + libc::CPU_STATE_NICE as usize].max(0) as u64,
});
}
unsafe {
libc::vm_deallocate(
libc::mach_task_self(),
info as libc::vm_address_t,
info_count as usize * std::mem::size_of::<libc::integer_t>(),
);
}
Some(cores)
}
#[cfg(target_os = "macos")]
fn run(program: &str, args: &[&str]) -> Option<String> {
let output = Command::new(program).args(args).output().ok()?;
if !output.status.success() {
return None;
}
String::from_utf8(output.stdout).ok()
}
#[cfg(not(target_os = "macos"))]
#[allow(dead_code)]
fn run(_program: &str, _args: &[&str]) -> Option<String> {
let _ = Command::new("true");
None
}
pub fn sysctl_u64(name: &str) -> Option<u64> {
run("sysctl", &["-n", name])?.trim().parse().ok()
}
pub fn sysctl_string(name: &str) -> Option<String> {
run("sysctl", &["-n", name]).map(|s| s.trim().to_string())
}
pub fn cpu_usage() -> Option<CpuUsage> {
parse_top_cpu(&run("top", &["-l", "2", "-s", "1", "-n", "0"])?)
}
pub fn vm_stat() -> Option<VmStat> {
parse_vm_stat(&run("vm_stat", &[])?)
}
pub fn swap_usage() -> Option<SwapUsage> {
parse_swapusage(&run("sysctl", &["-n", "vm.swapusage"])?)
}
#[cfg(target_os = "macos")]
pub fn read_cpu_stats() -> crate::error::Result<crate::core::cpu::CpuStats> {
use crate::core::cpu::{CpuCore, CpuStats, CpuTotal};
let (total_usage, per_core) = current_total_usage()?;
let model = sysctl_string("machdep.cpu.brand_string").filter(|s| !s.is_empty());
let cores = per_core
.iter()
.enumerate()
.map(|(id, usage)| CpuCore {
id,
online: None,
governor: None,
frequency: None,
user: usage.map(|u| u.user),
nice: usage.map(|u| u.nice),
system: usage.map(|u| u.system),
idle: usage.map(|u| u.idle),
model: model.clone(),
})
.collect();
Ok(CpuStats {
cores,
total: CpuTotal {
user: total_usage.user,
nice: Some(total_usage.nice),
system: total_usage.system,
idle: total_usage.idle,
},
})
}
#[cfg(target_os = "macos")]
pub fn read_memory_stats() -> crate::error::Result<crate::core::memory::MemoryStats> {
use crate::core::memory::{MemoryStats, RamInfo, SwapInfo};
let vm = vm_stat().ok_or_else(|| {
crate::error::IronError::Parse("vm_stat produced no parseable output".into())
})?;
let total_bytes = sysctl_u64("hw.memsize").ok_or_else(|| {
crate::error::IronError::UnsupportedPlatform("hw.memsize was not readable".into())
})?;
let swap = swap_usage();
Ok(MemoryStats {
ram: RamInfo {
total: total_bytes / 1024,
used: vm.used_bytes() / 1024,
free: Some(vm.free_bytes() / 1024),
buffers: None,
cached: Some(vm.cached_bytes() / 1024),
shared: None,
lfb: None,
},
swap: SwapInfo {
total: swap.map(|s| s.total / 1024),
used: swap.map(|s| s.used / 1024),
cached: None,
},
emc: None,
iram: None,
})
}
#[cfg(test)]
mod tests {
use super::*;
const TOP_OUTPUT: &str = "Processes: 512 total, 2 running, 510 sleeping, 2841 threads
2026/08/06 21:14:02
Load Avg: 2.31, 2.55, 2.72
CPU usage: 4.76% user, 9.52% sys, 85.71% idle
SharedLibs: 512M resident, 88M data, 42M linkedit.
MemRegions: 123456 total, 4321M resident, 234M private, 1234M shared.
";
#[test]
fn top_cpu_line_is_split_into_user_system_and_idle() {
let usage = parse_top_cpu(TOP_OUTPUT).expect("parses");
assert!((usage.user - 4.76).abs() < 0.001);
assert!((usage.system - 9.52).abs() < 0.001);
assert!((usage.idle - 85.71).abs() < 0.001);
}
#[test]
fn a_missing_cpu_line_is_none_rather_than_zero_usage() {
assert!(parse_top_cpu("Processes: 512 total\nLoad Avg: 1.0\n").is_none());
assert!(parse_top_cpu("").is_none());
}
#[test]
fn an_implausible_split_is_rejected() {
let bad = "CPU usage: 4.00% user, 5.00% sys, 6.00% idle";
assert!(parse_top_cpu(bad).is_none());
}
const VM_STAT_OUTPUT: &str = "Mach Virtual Memory Statistics: (page size of 16384 bytes)
Pages free: 45678.
Pages active: 234567.
Pages inactive: 123456.
Pages speculative: 12345.
Pages throttled: 0.
Pages wired down: 98765.
Pages purgeable: 4321.
\"Translation faults\": 987654321.
Pages copy-on-write: 12345678.
Pages zero filled: 234567890.
Pages reactivated: 1234567.
Pages purged: 123456.
File-backed pages: 87654.
Anonymous pages: 270369.
Pages stored in compressor: 456789.
Pages occupied by compressor: 34567.
";
#[test]
fn vm_stat_reads_the_page_size_from_the_header() {
let vm = parse_vm_stat(VM_STAT_OUTPUT).expect("parses");
assert_eq!(vm.page_size, 16384, "Apple Silicon uses 16K pages");
}
#[test]
fn vm_stat_reads_each_page_count() {
let vm = parse_vm_stat(VM_STAT_OUTPUT).expect("parses");
assert_eq!(vm.free, 45678);
assert_eq!(vm.active, 234567);
assert_eq!(vm.inactive, 123456);
assert_eq!(vm.speculative, 12345);
assert_eq!(vm.wired, 98765);
assert_eq!(vm.compressed, 34567);
assert_eq!(vm.file_backed, 87654);
}
#[test]
fn compressed_pages_are_the_occupied_count_not_the_stored_count() {
let vm = parse_vm_stat(VM_STAT_OUTPUT).expect("parses");
assert_eq!(vm.compressed, 34567, "occupied, not the 456789 stored");
}
#[test]
fn used_memory_counts_active_wired_and_compressed() {
let vm = parse_vm_stat(VM_STAT_OUTPUT).expect("parses");
assert_eq!(vm.used_bytes(), (234567 + 98765 + 34567) * 16384);
assert_eq!(vm.free_bytes(), (45678 + 12345) * 16384);
assert_eq!(vm.cached_bytes(), 87654 * 16384);
}
#[test]
fn a_vm_stat_missing_a_line_is_rejected_rather_than_read_as_zero() {
let without: String = VM_STAT_OUTPUT
.lines()
.filter(|l| !l.starts_with("File-backed pages"))
.map(|l| format!("{l}\n"))
.collect();
assert!(parse_vm_stat(&without).is_none());
}
#[test]
fn a_vm_stat_without_a_page_size_header_is_rejected() {
assert!(parse_vm_stat("Pages free: 100.\n").is_none());
}
#[test]
fn swapusage_scales_by_the_suffix_it_reports() {
let swap =
parse_swapusage("total = 2048.00M used = 1024.50M free = 1023.50M (encrypted)")
.expect("parses");
assert_eq!(swap.total, 2048 * 1024 * 1024);
assert_eq!(swap.used, (1024.5 * 1024.0 * 1024.0) as u64);
}
#[test]
fn swapusage_handles_gigabyte_suffixes() {
let swap =
parse_swapusage("total = 8.00G used = 2.50G free = 5.50G (encrypted)").expect("ok");
assert_eq!(swap.total, 8 * 1024 * 1024 * 1024);
assert_eq!(swap.used, (2.5 * 1024.0 * 1024.0 * 1024.0) as u64);
}
#[test]
fn swap_disabled_reports_zero_rather_than_none() {
let swap = parse_swapusage("total = 0.00M used = 0.00M free = 0.00M").expect("parses");
assert_eq!(swap.total, 0);
assert_eq!(swap.used, 0);
}
#[test]
fn unparseable_swapusage_is_none() {
assert!(parse_swapusage("vm.swapusage: unavailable").is_none());
}
#[test]
fn ticks_become_percentages_of_that_core() {
let ticks = CoreTicks {
user: 250,
system: 150,
idle: 550,
nice: 50,
};
let usage = ticks.percentages().expect("has accumulated time");
assert!((usage.user - 25.0).abs() < 0.01);
assert!((usage.system - 15.0).abs() < 0.01);
assert!((usage.idle - 55.0).abs() < 0.01);
assert!((usage.nice - 5.0).abs() < 0.01);
assert!((usage.user + usage.nice + usage.system + usage.idle - 100.0).abs() < 0.01);
}
#[test]
fn a_core_with_no_ticks_is_none_rather_than_wholly_idle() {
assert_eq!(CoreTicks::default().percentages(), None);
}
#[test]
fn aggregate_sums_every_core() {
let cores = [
CoreTicks {
user: 10,
system: 20,
idle: 30,
nice: 40,
},
CoreTicks {
user: 1,
system: 2,
idle: 3,
nice: 4,
},
];
let total = aggregate_ticks(&cores);
assert_eq!(total.user, 11);
assert_eq!(total.system, 22);
assert_eq!(total.idle, 33);
assert_eq!(total.nice, 44);
}
#[test]
fn aggregating_saturates_rather_than_wrapping() {
let cores = [
CoreTicks {
user: u64::MAX,
..Default::default()
},
CoreTicks {
user: 100,
..Default::default()
},
];
assert_eq!(aggregate_ticks(&cores).user, u64::MAX);
}
#[test]
fn an_empty_core_list_aggregates_to_no_reading() {
assert_eq!(aggregate_ticks(&[]).percentages(), None);
}
fn since_boot() -> CoreTicks {
CoreTicks {
user: 1_804_512,
system: 912_377,
idle: 21_006_418,
nice: 3_921,
}
}
#[test]
fn usage_between_is_the_split_of_the_window_only() {
let earlier = since_boot();
let later = CoreTicks {
user: earlier.user + 250,
system: earlier.system + 150,
idle: earlier.idle + 550,
nice: earlier.nice + 50,
};
let usage = usage_between(&earlier, &later).expect("counters advanced");
assert!((usage.user - 25.0).abs() < 0.01);
assert!((usage.system - 15.0).abs() < 0.01);
assert!((usage.idle - 55.0).abs() < 0.01);
assert!((usage.nice - 5.0).abs() < 0.01);
let since_boot_idle = later.percentages().expect("has time").idle;
assert!(since_boot_idle > 70.0);
assert!((usage.idle - since_boot_idle).abs() > 10.0);
}
#[test]
fn per_core_splits_pair_each_core_with_its_own_earlier_reading() {
let core_a = since_boot();
let core_b = CoreTicks {
user: 9_000,
system: 1_000,
idle: 90_000,
nice: 0,
};
let later_a = CoreTicks {
user: core_a.user + 250,
system: core_a.system + 150,
idle: core_a.idle + 550,
nice: core_a.nice + 50,
};
let splits = per_core_usage_between(&[core_a, core_b], &[later_a, core_b]);
assert_eq!(splits.len(), 2);
let a = splits[0].expect("core A advanced");
assert!((a.user - 25.0).abs() < 0.01, "user {}", a.user);
assert!((a.idle - 55.0).abs() < 0.01, "idle {}", a.idle);
assert_eq!(splits[1], None);
}
#[test]
fn a_core_count_change_gives_no_per_core_split() {
let core = since_boot();
let later = CoreTicks {
user: core.user + 250,
system: core.system + 150,
idle: core.idle + 550,
nice: core.nice + 50,
};
assert_eq!(
per_core_usage_between(&[core], &[later, later]),
vec![None, None]
);
assert_eq!(per_core_usage_between(&[core, core], &[later]), vec![None]);
}
#[test]
fn a_zero_delta_is_no_split_rather_than_the_since_boot_figure() {
let earlier = since_boot();
assert_eq!(usage_between(&earlier, &earlier), None);
}
#[test]
fn a_counter_that_went_backwards_is_no_split() {
let earlier = since_boot();
let later = CoreTicks {
user: earlier.user - 1,
system: earlier.system + 400,
idle: earlier.idle + 600,
nice: earlier.nice,
};
assert_eq!(usage_between(&earlier, &later), None);
}
#[test]
fn top_takes_the_last_sample_not_the_since_boot_one() {
const TWO_SAMPLES: &str = "Processes: 498 total, 2 running, 496 sleeping, 2790 threads
2026/08/06 21:14:02
Load Avg: 2.31, 2.55, 2.72
CPU usage: 4.76% user, 9.52% sys, 85.71% idle
SharedLibs: 512M resident, 88M data, 42M linkedit.
MemRegions: 123456 total, 4321M resident, 234M private, 1234M shared.
Processes: 499 total, 3 running, 496 sleeping, 2793 threads
2026/08/06 21:14:03
Load Avg: 2.36, 2.56, 2.72
CPU usage: 31.25% user, 12.50% sys, 56.25% idle
SharedLibs: 512M resident, 88M data, 42M linkedit.
MemRegions: 123456 total, 4322M resident, 234M private, 1234M shared.
";
let usage = parse_top_cpu(TWO_SAMPLES).expect("parses");
assert!((usage.user - 31.25).abs() < 0.01);
assert!((usage.system - 12.5).abs() < 0.01);
assert!((usage.idle - 56.25).abs() < 0.01);
}
}