Struct ByteBudgetController 

pub struct ByteBudgetController { /* private fields */ }

Available on crate feature governor only.

AIMD byte-budget lever with a memory HARD override.

See the module docs for the algorithm. observe() is the control step; byte_budget() and record_cap() are the cheap reads the recv loop consults. All state is interior-mutable and Sync.

Implementations

impl ByteBudgetController

pub fn new(cfg: ByteBudgetConfig, pressure: Arc<UnifiedPressure>) -> Self

Build a controller from config and a shared pressure latch.

The config is sanitised (ranges clamped, floors enforced); the budget starts at the sanitised start_bytes.

pub fn observe( &self, batch_bytes: u64, process_time: Duration, ingest_interval: Duration, )

Fold one observation into the control loop and update the budget.

batch_bytes is currently informational (the loop drives off timing, not size); process_time is how long the batch took to process and ingest_interval is the gap since the previous batch’s arrival.

Steps, in order:

1. EMA-smooth process_time and ingest_interval.
2. Compute rho = ema_process / ema_ingest. A zero (or sub-resolution) ingest_interval means arrivals are back-to-back faster than we process – treat rho as high (behind), which is the safe direction (shrink).
3. If memory says hold (the HARD override), multiplicative-decrease and return – memory never waits for the rho loop.
4. Otherwise AIMD on rho vs target_rho.
5. Clamp to [min_bytes, max_bytes].

pub fn byte_budget(&self) -> u64

Current byte budget. Always >= min_bytes, never 0.

pub fn record_cap(&self) -> usize

Poll-safety record cap (recv max count), independent of the byte budget. Always >= 1 so a tiny-record flood cannot blow the count even when many records fit inside the byte budget.

pub fn pressure(&self) -> &Arc<UnifiedPressure>

The shared pressure governor this controller drives off. Lets a caller (e.g. the governed driver) read the combined level for the pressure_ratio gauge without holding a second Arc.