use std::time::{Duration, Instant};
const INITIAL_PACING_RATE: f64 = 1_000_000.0; const MIN_PACING_RATE: f64 = 10_000.0;
const MAX_PACING_RATE: f64 = 100_000_000.0; const MAX_BURST_BYTES: f64 = 65_535.0;
const MIN_RTT_WINDOW: Duration = Duration::from_secs(10);
const RTT_INFLATION_THRESHOLD: f64 = 1.25;
const MAX_PACE_SLEEP: Duration = Duration::from_millis(10);
pub struct CongestionCtrl {
srtt_us: Option<u64>,
min_rtt_us: u64,
min_rtt_window_start: Instant,
pacing_rate: f64,
tokens: f64,
last_refill: Instant,
}
impl CongestionCtrl {
pub fn new() -> Self {
let now = Instant::now();
Self {
srtt_us: None,
min_rtt_us: u64::MAX,
min_rtt_window_start: now,
pacing_rate: INITIAL_PACING_RATE,
tokens: MAX_BURST_BYTES,
last_refill: now,
}
}
pub fn on_rtt_sample(&mut self, rtt_us: u64) {
self.srtt_us = Some(match self.srtt_us {
None => rtt_us,
Some(srtt) => (srtt - (srtt >> 3)) + (rtt_us >> 3),
});
let window_expired = self.min_rtt_window_start.elapsed() >= MIN_RTT_WINDOW;
if rtt_us < self.min_rtt_us || window_expired {
self.min_rtt_us = rtt_us;
self.min_rtt_window_start = Instant::now();
}
self.update_pacing_rate();
}
#[allow(clippy::cast_precision_loss)]
fn update_pacing_rate(&mut self) {
let Some(srtt) = self.srtt_us else { return };
if self.min_rtt_us == 0 || self.min_rtt_us == u64::MAX {
return;
}
let inflation = srtt as f64 / self.min_rtt_us as f64;
if inflation > RTT_INFLATION_THRESHOLD {
self.pacing_rate = (self.pacing_rate * 0.75).max(MIN_PACING_RATE);
} else {
self.pacing_rate = (self.pacing_rate * 1.05).min(MAX_PACING_RATE);
}
}
#[allow(clippy::cast_precision_loss)]
pub fn consume(&mut self, bytes: usize) -> Option<Duration> {
let now = Instant::now();
let elapsed = now.duration_since(self.last_refill).as_secs_f64();
self.last_refill = now;
self.tokens = (self.tokens + self.pacing_rate * elapsed).min(MAX_BURST_BYTES);
self.tokens -= bytes as f64;
if self.tokens < 0.0 {
let raw = (-self.tokens) / self.pacing_rate;
Some(Duration::from_secs_f64(raw).min(MAX_PACE_SLEEP))
} else {
None
}
}
pub fn pacing_rate(&self) -> f64 {
self.pacing_rate
}
pub fn srtt(&self) -> Option<Duration> {
self.srtt_us.map(Duration::from_micros)
}
#[allow(clippy::cast_precision_loss)]
pub fn congestion_factor(&self) -> Option<f64> {
let srtt = self.srtt_us?;
if self.min_rtt_us == 0 || self.min_rtt_us == u64::MAX {
return None;
}
Some(srtt as f64 / self.min_rtt_us as f64)
}
}