Struct ProcessCpuTracker 

pub struct ProcessCpuTracker { /* private fields */ }

Per-process CPU utilization from cumulative per-process CPU time (§8.3).

ProcessCpuTracker::observe returns the core-normalized value: one fully used core is 100%, so a process saturating four cores reads 400% and a single-threaded process on a 64-CPU machine still reads 100%. The other convention is applied on top by ProcessCpuTracker::observe_normalized, which delegates to the frozen CpuNormalization::apply rather than re-deriving the arithmetic.

Monotonic time

Unlike SystemCpuTracker, this divides by the elapsed interval, so the interval’s accuracy is the percentage’s accuracy. Callers must pass the snapshot’s monotonic captured_at; a wall-clock jump would otherwise scale every process on screen (§8.1). The interval is derived with Instant::saturating_duration_since, so it can never be negative.

Identity

One tracker follows one process. Callers must key trackers on crate::model::ProcessIdentity and not on a bare PID: a reused PID must start a fresh baseline rather than inherit the dead process’s CPU time (§26). super::KeyedProcessCpuTrackers encodes that.

Implementations

impl ProcessCpuTracker

pub const fn new() -> Self

Builds a tracker with no baseline.

pub const fn is_warming_up(&self) -> bool

Whether the next reading will be the first, and so warming up (§8.3).

pub const fn last_observed_at(&self) -> Option<Instant>

When the last reading was accepted, or None while warming up.

pub fn forget_baseline(&mut self)

Drops the baseline so the next reading warms up again.

pub fn observe( &mut self, cpu_time: Duration, at: Instant, ) -> MetricState<Percent>

Folds one cumulative process CPU time in and publishes core-normalized usage: one core = 100%, so the result may exceed 100% (§8.3).

pub fn observe_normalized( &mut self, cpu_time: Duration, at: Instant, normalization: CpuNormalization, logical_cpus: u16, ) -> MetricState<Percent>

Folds one reading in and publishes usage in the requested convention.

logical_cpus is only consulted for CpuNormalization::Machine. A zero CPU count leaves machine normalization undefined, and §4 forbids substituting a number for an undefined value, so that case reports UnavailableReason::ReadFailed — the CPU count is what failed to read.

Trait Implementations

impl Clone for ProcessCpuTracker

fn clone(&self) -> ProcessCpuTracker

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Copy for ProcessCpuTracker

impl Debug for ProcessCpuTracker

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

Formats the value using the given formatter.

impl Default for ProcessCpuTracker

fn default() -> ProcessCpuTracker

Returns the “default value” for a type.

impl DeltaTracker for ProcessCpuTracker

type Config = ()

Construction parameters shared by every tracker in one set.

type Reading = Duration

The cumulative reading folded in on each observation.

type Value = Percent

The value published when an observation succeeds.

fn with_config(_config: Self::Config) -> Self

Builds a tracker with no baseline yet.

fn observe_reading( &mut self, reading: Self::Reading, at: Instant, ) -> MetricState<Self::Value>

Folds one cumulative reading in, at monotonic time at.

fn last_observed_at(&self) -> Option<Instant>

When this tracker last accepted a reading, or None while warming up.

fn forget_baseline(&mut self)

Drops the baseline so the next reading warms up instead of producing a delta across a gap (§8.2).