use std::time::Duration;
use super::rtt_window::RttWindow;
use super::timer::{ScanBudget, ScanTimer};
#[derive(Debug, Clone, Copy)]
pub struct AdaptiveDeadlineConfig {
pub max_budget: ScanBudget,
pub min_budget: ScanBudget,
pub silence_floor: Duration,
pub silence_ceiling: Duration,
pub jitter_multiplier: f64,
pub rtt_window_capacity: usize,
}
impl AdaptiveDeadlineConfig {
pub const fn new(
max_budget: ScanBudget,
min_budget: ScanBudget,
silence_floor: Duration,
silence_ceiling: Duration,
jitter_multiplier: f64,
rtt_window_capacity: usize,
) -> Self {
Self {
max_budget,
min_budget,
silence_floor,
silence_ceiling,
jitter_multiplier,
rtt_window_capacity,
}
}
pub fn allowing_for(self, probe_lifetime: Duration) -> Self {
Self {
max_budget: self.max_budget.with_base_at_least(probe_lifetime),
..self
}
}
}
pub struct AdaptiveDeadline {
timer: ScanTimer,
rtt_window: RttWindow,
silence_floor: Duration,
silence_ceiling: Duration,
jitter_multiplier: f64,
}
impl AdaptiveDeadline {
pub fn new(config: AdaptiveDeadlineConfig, target_count: usize) -> Self {
Self {
timer: ScanTimer::new(
config.max_budget.for_target_count(target_count),
config.min_budget.for_target_count(target_count),
),
rtt_window: RttWindow::new(config.rtt_window_capacity),
silence_floor: config.silence_floor,
silence_ceiling: config.silence_ceiling,
jitter_multiplier: config.jitter_multiplier,
}
}
pub fn mark_activity(&mut self) {
self.timer.mark_activity();
}
pub fn record_rtt(&mut self, rtt: Duration) {
self.rtt_window.record(rtt);
}
fn silence_tolerance(&self) -> Duration {
self.rtt_window.suggest_timeout(
self.jitter_multiplier,
self.silence_floor,
self.silence_ceiling,
)
}
pub fn has_expired(&self) -> bool {
self.timer.has_expired(self.silence_tolerance())
}
pub fn hard_deadline_passed(&self) -> bool {
self.timer.hard_deadline_passed()
}
pub fn time_until_next_tick(&self) -> Duration {
self.timer.time_until_next_tick(self.silence_tolerance())
}
}