use std::collections::VecDeque;
use std::time::{Duration, Instant};
pub const LEDBAT_TARGET_DELAY: Duration = Duration::from_millis(100);
pub const LEDBAT_MIN_CWND: u32 = 2;
pub const LEDBAT_MAX_CWND: u32 = 1000;
pub const GAIN: f64 = 0.5;
const DEFAULT_MSS: u32 = 1500;
#[derive(Debug, Clone)]
pub struct LedbatController {
cwnd: u32,
bytes_in_flight: u32,
base_delay: Option<u64>,
current_delay: u64,
target_delay_us: u64,
last_send_time: Option<Instant>,
mss: u32,
delay_history: Vec<u64>,
max_history: usize,
base_delay_history: VecDeque<Option<u64>>,
base_delay_started: Instant,
base_delay_minute: u64,
}
impl Default for LedbatController {
fn default() -> Self {
Self::new()
}
}
impl LedbatController {
pub fn new() -> Self {
Self {
cwnd: LEDBAT_MIN_CWND * DEFAULT_MSS,
bytes_in_flight: 0,
base_delay: None,
current_delay: 0,
target_delay_us: LEDBAT_TARGET_DELAY.as_micros() as u64,
last_send_time: None,
mss: DEFAULT_MSS,
delay_history: Vec::with_capacity(60),
max_history: 60, base_delay_history: VecDeque::from([None; 10]),
base_delay_started: Instant::now(),
base_delay_minute: 0,
}
}
pub fn with_mss(mss: u32) -> Self {
let mss = mss.clamp(1, u32::MAX / LEDBAT_MAX_CWND);
Self {
cwnd: LEDBAT_MIN_CWND.saturating_mul(mss),
mss,
..Self::new()
}
}
pub fn with_target_delay(target_delay: Duration) -> Self {
Self {
target_delay_us: u64::try_from(target_delay.as_micros())
.unwrap_or(u64::MAX)
.max(1),
..Self::new()
}
}
pub fn get_window_size(&self) -> u32 {
self.cwnd
}
pub fn get_window_packets(&self) -> u32 {
self.cwnd / self.mss
}
pub fn get_bytes_in_flight(&self) -> u32 {
self.bytes_in_flight
}
pub fn get_base_delay(&self) -> Option<Duration> {
self.base_delay.map(Duration::from_micros)
}
pub fn get_current_delay(&self) -> Duration {
Duration::from_micros(self.current_delay)
}
pub fn get_queuing_delay(&self) -> Duration {
let queuing_us = self
.current_delay
.saturating_sub(self.base_delay.unwrap_or(0));
Duration::from_micros(queuing_us)
}
pub fn can_send(&self) -> bool {
self.bytes_in_flight < self.cwnd
}
pub fn available_window(&self) -> u32 {
self.cwnd.saturating_sub(self.bytes_in_flight)
}
pub fn on_data_sent(&mut self, bytes: u32) {
self.bytes_in_flight = self.bytes_in_flight.saturating_add(bytes);
self.last_send_time = Some(Instant::now());
}
pub fn on_ack_received(&mut self, timestamp_diff: u64, bytes_acked: u32) {
let flight_size_before_ack = self.bytes_in_flight;
self.update_delay(timestamp_diff);
let queuing_delay_us = self
.current_delay
.saturating_sub(self.base_delay.unwrap_or(self.current_delay));
let off_target =
(self.target_delay_us as f64 - queuing_delay_us as f64) / self.target_delay_us as f64;
let delta = GAIN * off_target * f64::from(bytes_acked) * f64::from(self.mss)
/ f64::from(self.cwnd.max(1));
let updated_cwnd = (f64::from(self.cwnd) + delta).max(0.0) as u32;
let max_allowed_cwnd = flight_size_before_ack.saturating_add(self.mss);
let min_cwnd = LEDBAT_MIN_CWND.saturating_mul(self.mss);
let max_cwnd = LEDBAT_MAX_CWND.saturating_mul(self.mss);
self.cwnd = updated_cwnd
.min(max_allowed_cwnd)
.max(min_cwnd)
.min(max_cwnd);
self.bytes_in_flight = self.bytes_in_flight.saturating_sub(bytes_acked);
}
pub fn update_delay(&mut self, delay_us: u64) {
self.current_delay = delay_us;
self.update_base_delay_at(delay_us, self.base_delay_started.elapsed().as_secs() / 60);
self.delay_history.push(delay_us);
if self.delay_history.len() > self.max_history {
self.delay_history.remove(0);
}
}
fn update_base_delay_at(&mut self, delay_us: u64, minute: u64) {
while self.base_delay_minute < minute {
self.base_delay_history.pop_front();
self.base_delay_history.push_back(None);
self.base_delay_minute += 1;
}
if let Some(current_minute) = self.base_delay_history.back_mut() {
*current_minute =
Some(current_minute.map_or(delay_us, |minimum| minimum.min(delay_us)));
}
self.base_delay = self.base_delay_history.iter().flatten().copied().min();
}
pub fn on_timeout(&mut self) {
self.cwnd = self.mss;
}
pub fn on_loss(&mut self) {
self.cwnd = (self.cwnd / 2).max(LEDBAT_MIN_CWND * self.mss);
}
pub fn reset(&mut self) {
self.cwnd = LEDBAT_MIN_CWND * self.mss;
self.bytes_in_flight = 0;
self.base_delay = None;
self.current_delay = 0;
self.last_send_time = None;
self.delay_history.clear();
self.base_delay_history = VecDeque::from([None; 10]);
self.base_delay_started = Instant::now();
self.base_delay_minute = 0;
}
pub fn is_slow_start(&self) -> bool {
false
}
pub fn get_target_delay(&self) -> Duration {
Duration::from_micros(self.target_delay_us)
}
pub fn time_since_last_send(&self) -> Option<Duration> {
self.last_send_time.map(|t| t.elapsed())
}
pub fn get_mss(&self) -> u32 {
self.mss
}
pub fn has_delay_samples(&self) -> bool {
!self.delay_history.is_empty()
}
pub fn delay_sample_count(&self) -> usize {
self.delay_history.len()
}
}
#[cfg(test)]
#[path = "congestion/tests.rs"]
mod tests;
#[cfg(test)]
#[path = "congestion/simulation.rs"]
mod simulation;