Struct PacedBench 

pub struct PacedBench {
    pub streams: usize,
    pub deadline: Duration,
    pub wall: Duration,
    pub service: Vec<Duration>,
    pub added: Vec<Duration>,
    pub admissions: usize,
    pub starved: usize,
    pub admitting: Vec<Duration>,
}

What streams paced streams did against that clock: how long each turn took to run, and how late each one completed against the moment its input arrived. The second is what a real-time load is judged on – it holds the queueing a turn waited through as well as its own run.

Fields

streams: usize

deadline: Duration

wall: Duration

service: Vec<Duration>

One entry per turn, over every stream, sorted.

added: Vec<Duration>

One entry per turn, over every stream, sorted.

admissions: usize

Sessions admitted over the trial: one per stream without churn, and however many the holding time turned over with it.

starved: usize

Admissions which found every lane held and had to wait for one.

admitting: Vec<Duration>

What each admission waited between asking for a session and getting one, sorted. An autobatch runtime answers on its worker, between turns, so this holds the turn in flight as well as the lane’s own reset – it is the wait, not the cost of the reset. Read it at a quantile: every seat’s first admission lands in one storm at the start of the trial, so a mean over a short trial is mostly that storm.

Implementations

impl PacedBench

pub fn admissions_per_second(&self) -> f64

Sessions admitted per second: how fast the lanes turn over.

pub fn admission_quantile(&self, q: f64) -> Duration

The wait q of the admissions came in under, q in 0..1.

pub fn starve_fraction(&self) -> f64

The share of admissions which waited for a lane.

pub fn turns(&self) -> usize

pub fn turns_per_second(&self) -> f64

pub fn mean_service(&self) -> Duration

pub fn added_quantile(&self, q: f64) -> Duration

The added latency q of the turns came in under, q in 0..1.

pub fn late_fraction(&self) -> f64

The share of turns which completed past the deadline.

pub fn holds(&self, q: f64) -> bool

Whether this load held: the qth added latency met the deadline. A load which served nothing never holds.