Struct MemorySnapshot 

pub struct MemorySnapshot {
    pub total_bytes: u64,
    pub available: MetricState<u64>,
    pub used: MetricState<u64>,
    pub free: MetricState<u64>,
    pub usage: MetricState<Percent>,
    pub detail: MemoryDetail,
    pub swap: SwapSnapshot,
    pub semantics: MemorySemantics,
    pub cgroup_limit_bytes: MetricState<u64>,
    pub cgroup_used_bytes: MetricState<u64>,
}

System memory state.

Fields

total_bytes: u64

Total physical memory. Always known.

available: MetricState<u64>

Memory allocatable without reclaim pressure, per Self::semantics.

used: MetricState<u64>

total_bytes - available, per Self::semantics.

free: MetricState<u64>

Completely unused memory. Usually much smaller than available.

usage: MetricState<Percent>

Share of memory in use.

detail: MemoryDetail

The secondary breakdown.

swap: SwapSnapshot

Swap capacity and activity.

semantics: MemorySemantics

Which definition produced available and used.

cgroup_limit_bytes: MetricState<u64>

The cgroup memory limit, when running under one, alongside the host total in total_bytes.

§9.2 requires container limits to be exposed separately from host totals and both to be shown and labelled where observable.

cgroup_used_bytes: MetricState<u64>

The cgroup’s own memory usage, when running under one.

Inside a container, used is the host’s figure: /proc/meminfo is not namespaced, so a process in a 2 GiB group on a 64 GiB host sees the host’s 40 GiB and concludes it is nearly out of memory when it has used 300 MiB of its own allowance. This is the group’s figure, read from memory.current — the same counter the kernel compares against memory.max when it decides to OOM-kill, which is what makes it the number worth showing rather than a second opinion.

It counts reclaimable page cache, so it sits above what the group would need under pressure. That is a property of how the limit is enforced, not an inaccuracy: the kernel reclaims that cache before killing anything.

MetricState::Unsupported off Linux and outside a cgroup.

Implementations

impl MemorySnapshot

pub const fn warming_up(total_bytes: u64, semantics: MemorySemantics) -> Self

A snapshot with only the total known, for the first frame.

pub fn effective_limit_bytes(&self) -> u64

The memory ceiling that actually applies to this process tree.

Inside a container this is the cgroup limit, not the host total; §9.2 requires the distinction to be observable rather than silently folded into one number.

A stale reading counts here, which is the one place this crate deliberately breaks MetricState::fresh’s “use fresh values for calculations” rule. A limit is configuration, not a measurement: if the last successful read said 2 GiB and this tick’s read failed, the group is still limited to 2 GiB, and falling back to the host’s 64 would report 62 GiB of headroom that does not exist — wrong in the direction that gets a process OOM-killed by surprise. Keeping the retained value is wrong only if the limit changed in the last few seconds, and the row is marked stale either way.

pub fn is_memory_limited(&self) -> bool

Whether a cgroup limit, rather than the installed RAM, is the ceiling here.

Stale counts, for the reason Self::effective_limit_bytes gives.

pub fn effective_used_bytes(&self) -> MetricState<u64>

Bytes in use against Self::effective_limit_bytes.

The cgroup’s own usage where the platform reports it, the host’s used otherwise — so that the two halves of the ratio always come from the same place. Pairing a host used with a container limit is the specific mistake this exists to prevent: it reports 40 GiB of 2 GiB, or 2000%.

The unavailability is passed through rather than replaced, so a caller can say why there is no figure.

Trait Implementations

impl Clone for MemorySnapshot

fn clone(&self) -> MemorySnapshot

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Copy for MemorySnapshot

impl Debug for MemorySnapshot

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl PartialEq for MemorySnapshot

fn eq(&self, other: &MemorySnapshot) -> bool

Equality operator ==.

fn ne(&self, other: &Rhs) -> bool

Inequality operator !=.

impl StructuralPartialEq for MemorySnapshot