Enum LatencyDistribution 

pub enum LatencyDistribution {
    Uniform {
        start: Duration,
        end: Duration,
    },
    Exponential {
        min: Duration,
        mean: Duration,
    },
    Bimodal {
        fast_range: Range<Duration>,
        slow_range: Range<Duration>,
        slow_probability: f64,
    },
}

A pluggable latency distribution for per-operation latency sampling.

Replaces plain uniform Range<Duration> sampling so simulations can exercise the heavy P99 tail where timeout cascades, retry storms, and backpressure collapse live. All variants sample deterministically through the simulation RNG, so the same seed always yields the same sequence.

The default is Uniform, which samples identically to the historical sample_duration (one RNG draw, no extra draws), keeping default behavior unchanged.

References

• Exponential mirrors TigerBeetle’s random_int_exponential storage/network delay (packet_simulator.zig).
• Bimodal mirrors FoundationDB’s halfLatency fast/slow split (sim2.actor.cpp).

Variants

Uniform

Uniform latency in [start, end). Equivalent to the historical Range<Duration> sampling.

Fields

start: Duration

Inclusive lower bound.

end: Duration

Exclusive upper bound.

Exponential

Exponential latency with a minimum floor, modelling a long tail.

Samples min + mean * (-ln(u)) with u drawn uniformly from (0, 1], giving a mean delay of roughly min + mean. Note this is the additive form from the issue; TigerBeetle instead clamps with max(min, exp(mean)).

Fields

min: Duration

Minimum latency added to every sample.

mean: Duration

Mean of the exponential component (the tail scale).

Bimodal

Bimodal latency: a fast cluster most of the time, a slow tail rarely.

With probability slow_probability the sample is drawn uniformly from slow_range; otherwise from fast_range.

Fields

fast_range: Range<Duration>

Range sampled on the common, fast path.

slow_range: Range<Duration>

Range sampled on the rare, slow path.

slow_probability: f64

Probability in [0, 1] of taking the slow path.

Implementations

impl LatencyDistribution

pub fn uniform_bounds(&self) -> Option<(Duration, Duration)>

Return the (start, end) bounds when this is a Uniform distribution, otherwise None. Convenience for tests and reporting.

Trait Implementations

impl Clone for LatencyDistribution

fn clone(&self) -> LatencyDistribution

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for LatencyDistribution

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

Formats the value using the given formatter.

impl Default for LatencyDistribution

fn default() -> Self

Returns the “default value” for a type.

impl PartialEq for LatencyDistribution

fn eq(&self, other: &LatencyDistribution) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl StructuralPartialEq for LatencyDistribution