Struct ControllerDriver 

pub struct ControllerDriver { /* private fields */ }

Shared, live bridge between a pure AdaptiveController and the running transfer backends.

The controller is &mut and deterministic; this wrapper owns it behind a Mutex (tick is infrequent, so contention is negligible) and adds the impure parts the controller deliberately omits: a real monotonic clock, a live CpuSampler + RSS sampler, the manifest’s p95 object size, and the application of each Decision to the shared AdaptiveGate (concurrency) and — for the network backends — a rate-limiter setter + display Meter.

Both transfer paths use it identically:

• every completed/failed op calls record_op with its measured OpSample;
• a lightweight driver (a tokio interval task for the async path, a std::thread for the rayon path) periodically calls tick, which samples CPU/RSS, advances the controller, resizes the gate, and reports the new limit/rate.

The driver is Clone (the controller, gate, sampler and the rate/limit appliers are all shared via Arc).

Implementations

impl ControllerDriver

pub fn new( policy: AdaptivePolicy, gate: AdaptiveGate, p95_obj_size: u64, rate_applier: Option<Arc<dyn Fn(Option<u64>) + Send + Sync>>, meter: Option<Arc<Meter>>, ) -> Self

Builds a driver around a fresh controller for policy, the shared gate, the manifest’s p95_obj_size, an optional rate_applier (the backend’s live rate-limit setter; None for the rate-less local store), and an optional display meter.

pub fn record_op(&self, sample: OpSample)

Records one completed/failed op into the shared controller.

pub fn tick(&self) -> Decision

Advances the controller one interval: samples CPU/RSS, ticks with the injected monotonic clock + p95 object size, then applies the resulting Decision to the gate (concurrency), the rate applier (byte-rate), and the display meter. Returns the decision for tests/inspection.

now (the monotonic clock), CPU and RSS are the driver’s only impure inputs; all are sampled here. Determinism-sensitive tests should instead drive tick_with, supplying every impure input explicitly so the controller’s time- and load-dependent arms (cooldown, re-probe, CPU guardrails) never depend on the machine’s current clock or load.

The returned Decision is advisory (the live gate/rate/meter are already updated as a side effect); callers may ignore it — hence not #[must_use].

pub fn tick_with( &self, now: MonoTime, cpu_pct: Option<f64>, rss: Option<u64>, ) -> Decision

Fully time-/load-injectable sibling of tick: advances the controller using the caller-supplied monotonic now, CPU percentage and RSS instead of sampling the driver’s real epoch / live CpuSampler / RSS sampler. The gate / rate / meter application step is byte-for-byte identical to tick, so this drives the same live wiring — only the impure inputs are injected.

This is the injectable seam (mirroring the controller’s own tick(now, cpu, rss, …) and the crate’s injected-clock/sleeper convention in crate::retry): it lets determinism-sensitive tests cross the controller’s time-dependent thresholds (the 15s post-congestion cooldown, the re-probe interval) and pin its CPU guardrails by advancing now and fixing cpu_pct explicitly — with ZERO dependence on the machine’s wall clock or current load (which is what made driving the live gate trajectory flaky under parallel test load). now must be monotonically non-decreasing across calls, exactly as epoch.elapsed() would be; cpu_pct/rss are Some(_) to assert a guardrail or None to skip it, exactly as the live samplers’ Options flow.

Like tick, the returned Decision is advisory and may be ignored (the gate/rate/meter are already applied).

Trait Implementations

impl Clone for ControllerDriver

fn clone(&self) -> ControllerDriver

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for ControllerDriver

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

Formats the value using the given formatter.