Struct Measured 

pub(crate) struct Measured {
    pub(crate) cpu_ms: f64,
    pub(crate) wall_ms: f64,
    pub(crate) frames: u64,
    pub(crate) bytes: u64,
    pub(crate) turns: u64,
    pub(crate) messages: u64,
    pub(crate) asks: u32,
    pub(crate) pid: u32,
}

What one arm moved, and what it cost.

The denominator is not decoration: it is what tells a reader that the arm saw a conversation at all.

Fields

cpu_ms: f64

wall_ms: f64

frames: u64

bytes: u64

turns: u64

messages: u64

asks: u32

pid: u32

The PID this arm was charged to, echoed from --pid.

Echoed rather than verified: nothing here checks that the process owns the port, so a recycled PID is charged and then named as the server. It is an address for a reader to check, not a claim.

Implementations

impl Measured

pub(crate) fn report( &self, arm: &str, idle: &Measured, window: Option<f64>, ) -> String

The line one arm reports.

Every row carries the build it was MEASURED WITH, the PID it charged, and - on the idle row, which every other arm is charged against - the window ASKED FOR rather than the one the clock measured, so a reader recomputing the charge from a lifted row gets a number slightly under the printed one. The divisor is the idle arm’s own wall time, which no row prints; the gap is milliseconds normally and wider under load, which is when someone is most likely to be recomputing.

The client’s build moves two of the figures, and the charge is only as clean as the baseline. wall_ms is the client’s own and a debug client reads 2,695 ms where a release one reads 1,250 on the same server. charged_cpu_ms is cpu - idle_cpu * share, so where the idle arm reads 0.0 the charge is insensitive to that build; where the server has background work the baseline is non-zero, share moves with the client’s wall, and the charge moves with it.

Trait Implementations

impl Default for Measured

fn default() -> Self

Returns the “default value” for a type.