Struct Plan 

pub struct Plan {
    pub calls: usize,
    pub rate: f64,
    pub most_in_flight: usize,
}

How much load to apply.

Fields

calls: usize

How many calls to place in total.

rate: f64

How many to start per second.

The arrival rate, not the concurrency: a rate of 50 with calls lasting two seconds settles at about a hundred in progress. Driving by rate rather than by concurrency is what makes a run reproducible — a harness that keeps N in flight speeds up when the system under test slows down, which is the opposite of a load test.

most_in_flight: usize

The most to have in progress at once, whatever the rate says.

A backstop, not a target. Without it, a system that has stopped answering entirely accumulates every call the plan asks for and the harness runs out of sockets before the thing it is testing does.

Implementations

impl Plan

pub fn new(calls: usize, rate: f64) -> Self

A plan placing this many calls at this rate.

pub fn interval(&self) -> Duration

The gap between two calls starting.

rate is a public field, so it can be anything a caller can write — and Duration::from_secs_f64 panics on NaN or on a value too large to represent. A denormal rate such as 1e-300 reaches the second case. A load harness that panics on its own configuration is not a load harness, so both collapse to “as fast as possible”, which is what a nonsensical rate most nearly means.

Trait Implementations

impl Clone for Plan

fn clone(&self) -> Plan

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for Plan

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

Formats the value using the given formatter.

impl Copy for Plan