Struct WindowReport 

pub struct WindowReport {
    pub wall_ms: Vec<f64>,
    pub steps: Vec<usize>,
    pub delivered_ms: Vec<f64>,
    pub delivered_batches: Vec<usize>,
    pub fill_ms: Vec<f64>,
    pub delivered_coherent: bool,
    pub sync_ms: f64,
}

One reduce window’s observations, the event-shaped timing feed for ElChe::report_window. Built by the coordinator from its window ledger once per averaging cycle; owned values because it is a message, not a view.

Carries BOTH timing scales so the scale-selection policy (the mixed-scale inversion guard) lives in ElChe, next to the relative allocation model it protects:

• compute-only (wall_ms, steps) — always coherent across ranks;
• marginal delivered (delivered_ms, delivered_batches) — carries data + transport cost; a rank without a delivered sample this window has (0.0, 0).

delivered_coherent is the caller’s attestation that the delivered scale is safe to use at all: the mode rides the delivered feed AND every alive mover has a delivered sample this window. The caller owns that predicate because it owns membership (dead ranks) and the ledger; ElChe owns what to do with it — feeding a PARTIAL delivered set would compare incomparable scales and invert the allocation (see WindowReport::select_feed).

Fields

wall_ms: Vec<f64>

Per-rank compute-only wall (ms) this window.

steps: Vec<usize>

Per-rank step counts this window (matched divisor for wall_ms).

delivered_ms: Vec<f64>

Per-rank marginal delivered wall (ms) this window.

delivered_batches: Vec<usize>

Per-rank marginal delivered batch counts (matched divisor for delivered_ms).

fill_ms: Vec<f64>

Per-rank first-batch fill excess (ms) — the window-pressure growth signal.

delivered_coherent: bool

The delivered scale is coherent this window (mode supports it AND every alive mover has a delivered sample).

sync_ms: f64

Duration (ms) of the sync that closed the window.

Implementations

impl WindowReport

pub fn select_feed(&self) -> (Vec<f64>, Vec<usize>)

The (ms, batches) pair ElChe schedules on this window — the scale-selection policy. ElChe’s allocation is RELATIVE, so the per-rank scale must be uniform within a window: when the delivered scale is not coherent, EVERY rank feeds the compute scale (a uniformly compute-fed window is coherent; the next window returns to delivered). When coherent, ranks with a delivered sample feed delivered cost; ranks without one are non-movers by the caller’s attestation and fall back to their (empty) compute pair, contributing (0, 0) on either scale.

Trait Implementations

impl Clone for WindowReport

fn clone(&self) -> WindowReport

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for WindowReport

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

Formats the value using the given formatter.