Struct LimiterConfig 

pub struct LimiterConfig {
    pub enabled: bool,
    pub min_concurrency: usize,
    pub max_concurrency: usize,
    pub window_ops: usize,
    pub min_window_ops: usize,
    pub success_target: f64,
    pub timeout_ceiling: f64,
    pub latency_inflation_factor: f64,
    pub latency_ewma_alpha: f64,
    pub slow_start_ramp_threshold: usize,
    pub latency_decrease_enabled: bool,
    pub retain_increase_credit_on_decrease: bool,
}

Per-limiter configuration. Carries the shared adaptive parameters plus the channel-specific max_concurrency. Held behind an Arc so cloning a Limiter is a refcount bump rather than a struct copy (avoids allocating AdaptiveConfig-worth of bytes per chunk in hot loops).

Fields

enabled: bool

min_concurrency: usize

max_concurrency: usize

window_ops: usize

min_window_ops: usize

success_target: f64

timeout_ceiling: f64

latency_inflation_factor: f64

latency_ewma_alpha: f64

slow_start_ramp_threshold: usize

While current < slow_start_ramp_threshold, a Decrease halves the cap but does NOT permanently exit slow-start — the next healthy window can double the cap back up. Above the threshold, a Decrease exits slow-start and the controller transitions to classic AIMD (+1 per healthy window).

0 (the default) reproduces the original behaviour: any Decrease at any cap permanently exits slow-start. The fetch channel sets this to its max_concurrency so download concurrency keeps doubling toward the ceiling instead of crawling +1 per window — additive growth simply cannot reach a useful cap on a fast-but-lossy link before the file finishes. See AdaptiveController::new.

latency_decrease_enabled: bool

When false, the p95-latency-vs-baseline comparison never triggers a Decrease (it still updates the baseline). The fetch channel disables it because chunk_get’s observed latency includes the internal retry sleep and slow retry-sweep for the chunks that needed one, so a window with a couple of retry-path chunks has a wildly inflated p95 that is retry variance, not congestion. Genuine fetch congestion still surfaces as a rising Ok(None) (Timeout) rate, which the timeout_ceiling check catches.

retain_increase_credit_on_decrease: bool

When true, a Decrease does NOT reset samples_since_increase, so evidence already accrued toward the next Increase survives a transient Decrease instead of being zeroed.

The default (false) reproduces the original asymmetric gate: an Increase needs a full fresh window_ops of samples, a Decrease needs only min_window_ops, AND a Decrease resets the increase counter. On a channel where decreases fire faster than a full increase window can accrue, that combination permanently starves growth — the store cap sat pinned at its cold-start floor of 8 for a whole 530-chunk upload (V2-554). The store channel sets this true so a few-percent shortfall rate can no longer deny the cap its next doubling: the accrued increase credit persists across the transient Decrease, and the next genuinely healthy window (evaluate returns Increase) can act on it. Sustained unhealthiness still holds the cap down because evaluate keeps returning Decrease — this only stops isolated dips from zeroing progress.

Trait Implementations

impl Clone for LimiterConfig

fn clone(&self) -> LimiterConfig

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for LimiterConfig

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

Formats the value using the given formatter.