use std::sync::Mutex;
use super::watcher::{Clock, RealClock};
pub struct TokenBucket {
capacity: f64,
tokens: f64,
rate_per_ms: f64,
last_ms: u64,
}
impl TokenBucket {
pub fn new(rate_bytes_per_sec: u64, now_ms: u64) -> Self {
let capacity = rate_bytes_per_sec.max(1) as f64;
Self { capacity, tokens: capacity, rate_per_ms: capacity / 1000.0, last_ms: now_ms }
}
fn refill(&mut self, now_ms: u64) {
let dt = now_ms.saturating_sub(self.last_ms) as f64;
self.tokens = (self.tokens + dt * self.rate_per_ms).min(self.capacity);
self.last_ms = now_ms;
}
pub fn spend(&mut self, now_ms: u64, bytes: u64) -> u64 {
self.refill(now_ms);
let bytes = bytes as f64;
if self.tokens >= bytes {
self.tokens -= bytes;
return 0;
}
let deficit = bytes - self.tokens;
self.tokens = 0.0;
(deficit / self.rate_per_ms).ceil() as u64
}
}
#[derive(Debug, Clone, Copy)]
pub struct DutyCycle {
fraction: f64,
}
impl DutyCycle {
pub fn new(fraction: f64) -> Self {
Self { fraction: fraction.clamp(0.01, 1.0) }
}
pub fn idle_after(&self, spent_ms: u64) -> u64 {
((spent_ms as f64) * (1.0 - self.fraction) / self.fraction).round() as u64
}
}
pub trait PowerSource: Send + Sync {
fn on_battery(&self) -> bool;
fn memory_pressure(&self) -> bool;
}
pub struct RealPowerSource;
const MEMORY_PRESSURE_PERCENT: u32 = 90;
impl PowerSource for RealPowerSource {
#[cfg(windows)]
fn on_battery(&self) -> bool {
use windows_sys::Win32::System::Power::{GetSystemPowerStatus, SYSTEM_POWER_STATUS};
let mut status: SYSTEM_POWER_STATUS = unsafe { std::mem::zeroed() };
let ok = unsafe { GetSystemPowerStatus(&mut status) };
ok != 0 && status.ACLineStatus == 0
}
#[cfg(unix)]
fn on_battery(&self) -> bool {
let Ok(entries) = std::fs::read_dir("/sys/class/power_supply") else { return false };
for entry in entries.flatten() {
let path = entry.path();
let is_battery = path.file_name().and_then(|n| n.to_str()).is_some_and(|n| n.starts_with("BAT"));
if !is_battery {
continue;
}
if let Ok(status) = std::fs::read_to_string(path.join("status")) {
if status.trim().eq_ignore_ascii_case("discharging") {
return true;
}
}
}
false
}
#[cfg(not(any(windows, unix)))]
fn on_battery(&self) -> bool {
false
}
#[cfg(windows)]
fn memory_pressure(&self) -> bool {
use windows_sys::Win32::System::SystemInformation::{GlobalMemoryStatusEx, MEMORYSTATUSEX};
let mut status: MEMORYSTATUSEX = unsafe { std::mem::zeroed() };
status.dwLength = std::mem::size_of::<MEMORYSTATUSEX>() as u32;
let ok = unsafe { GlobalMemoryStatusEx(&mut status) };
ok != 0 && status.dwMemoryLoad >= MEMORY_PRESSURE_PERCENT
}
#[cfg(unix)]
fn memory_pressure(&self) -> bool {
let Ok(meminfo) = std::fs::read_to_string("/proc/meminfo") else { return false };
let mut total_kb: Option<u64> = None;
let mut available_kb: Option<u64> = None;
for line in meminfo.lines() {
let parse = |prefix: &str| -> Option<u64> { line.strip_prefix(prefix)?.split_whitespace().next()?.parse().ok() };
if let Some(v) = parse("MemTotal:") {
total_kb = Some(v);
} else if let Some(v) = parse("MemAvailable:") {
available_kb = Some(v);
}
}
match (total_kb, available_kb) {
(Some(total), Some(available)) if total > 0 => {
let used_percent = ((total - available.min(total)) * 100) / total;
used_percent as u32 >= MEMORY_PRESSURE_PERCENT
}
_ => false,
}
}
#[cfg(not(any(windows, unix)))]
fn memory_pressure(&self) -> bool {
false
}
}
pub const POWER_BACKOFF_MS: u64 = 30_000;
pub struct Governor {
bucket: Mutex<TokenBucket>,
duty: DutyCycle,
power: Box<dyn PowerSource>,
clock: Box<dyn Clock + Send + Sync>,
}
impl Governor {
pub fn new(bytes_per_sec: u64, cpu_fraction: f64) -> Self {
let clock = RealClock::new();
let bucket = TokenBucket::new(bytes_per_sec, clock.now_ms());
Self { bucket: Mutex::new(bucket), duty: DutyCycle::new(cpu_fraction), power: Box::new(RealPowerSource), clock: Box::new(clock) }
}
#[cfg(test)]
fn with_parts(bucket: TokenBucket, duty: DutyCycle, power: Box<dyn PowerSource>, clock: Box<dyn Clock + Send + Sync>) -> Self {
Self { bucket: Mutex::new(bucket), duty, power, clock }
}
pub fn throttle(&self, bytes: u64) -> u64 {
if self.power.on_battery() || self.power.memory_pressure() {
return POWER_BACKOFF_MS;
}
let now = self.clock.now_ms();
self.bucket.lock().unwrap().spend(now, bytes)
}
pub fn after_cpu_work(&self, spent_ms: u64) -> u64 {
self.duty.idle_after(spent_ms)
}
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn token_bucket_grants_up_to_capacity_immediately() {
let mut b = TokenBucket::new(1000, 0); assert_eq!(b.spend(0, 500), 0);
assert_eq!(b.spend(0, 500), 0); assert!(b.spend(0, 1) > 0); }
#[test]
fn token_bucket_refills_over_virtual_time() {
let mut b = TokenBucket::new(1000, 0);
b.spend(0, 1000); assert_eq!(b.spend(500, 500), 0, "half a second at 1000 B/s refills 500 B");
assert!(b.spend(500, 1) > 0, "and no more than that");
}
#[test]
fn token_bucket_reports_a_sensible_wait() {
let mut b = TokenBucket::new(1000, 0);
b.spend(0, 1000);
let wait = b.spend(0, 500); assert_eq!(wait, 500);
}
#[test]
fn token_bucket_never_exceeds_capacity() {
let mut b = TokenBucket::new(1000, 0);
assert_eq!(b.spend(1_000_000, 1000), 0); assert!(b.spend(1_000_000, 1) > 0);
}
#[test]
fn duty_cycle_half_means_equal_idle_and_work() {
let d = DutyCycle::new(0.5);
assert_eq!(d.idle_after(100), 100);
}
#[test]
fn duty_cycle_full_never_idles() {
let d = DutyCycle::new(1.0);
assert_eq!(d.idle_after(1000), 0);
}
#[test]
fn duty_cycle_small_fraction_idles_much_longer_than_it_works() {
let d = DutyCycle::new(0.1);
assert_eq!(d.idle_after(100), 900); }
#[test]
fn duty_cycle_clamps_to_a_sane_range() {
assert_eq!(DutyCycle::new(0.0).idle_after(100), DutyCycle::new(0.01).idle_after(100));
assert_eq!(DutyCycle::new(5.0).idle_after(100), 0);
}
struct FakePower {
battery: bool,
pressure: bool,
}
impl PowerSource for FakePower {
fn on_battery(&self) -> bool {
self.battery
}
fn memory_pressure(&self) -> bool {
self.pressure
}
}
#[test]
fn power_signal_overrides_the_byte_budget() {
use super::super::watcher::test_support::FakeClock;
let clock = FakeClock::new();
let g = Governor::with_parts(
TokenBucket::new(1_000_000_000, 0), DutyCycle::new(1.0),
Box::new(FakePower { battery: true, pressure: false }),
Box::new(clock),
);
assert_eq!(g.throttle(1), POWER_BACKOFF_MS);
let clock2 = super::super::watcher::test_support::FakeClock::new();
let g2 = Governor::with_parts(
TokenBucket::new(1_000_000_000, 0),
DutyCycle::new(1.0),
Box::new(FakePower { battery: false, pressure: true }),
Box::new(clock2),
);
assert_eq!(g2.throttle(1), POWER_BACKOFF_MS);
}
#[test]
fn no_power_signal_falls_through_to_the_byte_budget() {
let clock = super::super::watcher::test_support::FakeClock::new();
let g = Governor::with_parts(
TokenBucket::new(100, 0),
DutyCycle::new(1.0),
Box::new(FakePower { battery: false, pressure: false }),
Box::new(clock),
);
assert_eq!(g.throttle(100), 0); assert!(g.throttle(1) > 0); }
#[test]
fn real_power_source_never_panics() {
let p = RealPowerSource;
let _: bool = p.on_battery();
let _: bool = p.memory_pressure();
}
}