Struct WindowController 

pub struct WindowController {
    cfg: FlowControlConfig,
    cwnd: usize,
    inflight: usize,
    ai_accumulated_size: usize,
}

Pure AIMD send-window controller. Holds no I/O; every state transition is a plain method so the invariants are exhaustively unit-testable. Byte-based (not frame-based) so it is agnostic to frame sizing.

Fields

cfg: FlowControlConfig

cwnd: usize

Current congestion window in bytes, always within [min_window_size, max_window_size].

inflight: usize

Bytes sent but not yet delivered or lost.

ai_accumulated_size: usize

Bytes delivered toward the next additive-increase step (Reno-style congestion avoidance).

Implementations

impl WindowController

pub fn new(cfg: FlowControlConfig) -> Self

Creates a controller with the window at the floor (min_window_size). The window can only grow from here via proven delivery — so before any honest signal, the peer cannot make it exceed min_window_size (invariant 1 & 3).

pub fn window(&self) -> usize

Current window size in bytes (for diagnostics/tests).

pub fn inflight(&self) -> usize

Current in-flight bytes (sent, not yet retired).

pub fn mode(&self) -> FlowControlMode

The active mode.

pub fn min_window_size(&self) -> usize

The configured minimum window (duplex floor / persist-probe size).

pub fn on_sent(&mut self, bytes: usize)

Records bytes admitted onto the wire. Increases the in-flight accounting only; never grows the window.

pub fn on_delivered(&mut self, bytes: usize)

The only path that grows the window. Retires bytes of proven-delivered data and performs Reno congestion avoidance: roughly +ai_step per fully-delivered window, capped at max_window_size.

pub fn on_lost(&mut self, bytes: usize)

Retires bytes of proven-lost data and multiplicatively decreases the window (never below min_window_size). Loss recovery itself (retransmission) is the reliable socket’s job.

pub fn apply_delivery(&mut self, d: Delivered)

Applies a batched Delivered observation from a DeliverySignal.

pub fn apply_backoff(&mut self, b: Backoff)

Applies a SURB-supply backoff. Down-only: Soft multiplicatively decreases, Hard collapses to the floor. Never grows the window.

pub fn effective_window_for(&self, ceiling: usize) -> usize

Effective window against a raw ceiling value (bytes): min(cwnd, ceiling), but never below min_window_size (duplex floor). The ceiling can only shrink the result — invariant 2 — and it does not mutate cwnd, so a transient dip is fully recovered the instant the ceiling lifts.

pub fn admissible_for(&self, ceiling: usize) -> usize

Bytes admissible now against a raw ceiling value: effective_window − inflight (saturating).

pub fn effective_window(&self, supply: &impl SupplyConstraint) -> usize

Effective window against a SupplyConstraint (convenience wrapper over effective_window_for).

pub fn admissible(&self, supply: &impl SupplyConstraint) -> usize

Bytes that may be admitted right now against supply. Zero means park until delivery retires in-flight bytes (or the ceiling lifts).

fn decrease(&mut self, factor: f64)

Multiplicative decrease helper, flooring at min_window_size.

Trait Implementations

impl Clone for WindowController

fn clone(&self) -> WindowController

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for WindowController

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

Formats the value using the given formatter.