use std::sync::atomic::{AtomicUsize, Ordering};
use std::sync::Arc;
use tokio::sync::{OwnedSemaphorePermit, Semaphore};
fn log_aimd_transition(key: &str, from: usize, to: usize) {
log::debug!(
"{}",
crate::i18n::tr_log_args(
key,
&[
("from", (from as i64).to_string()),
("to", (to as i64).to_string()),
],
)
);
}
pub const DEFAULT_MIN_LIMIT: usize = 1;
pub const DEFAULT_MAX_LIMIT: usize = 100;
pub const DEFAULT_INCREASE_THRESHOLD: usize = 10;
#[derive(Debug)]
pub struct AIMDController {
current_limit: AtomicUsize,
consecutive_successes: AtomicUsize,
min_limit: usize,
max_limit: usize,
increase_threshold: usize,
}
impl AIMDController {
pub fn new(initial: usize) -> Self {
Self::with_bounds(initial, DEFAULT_MIN_LIMIT, DEFAULT_MAX_LIMIT)
}
pub fn with_bounds(initial: usize, min_limit: usize, max_limit: usize) -> Self {
assert!(min_limit >= 1, "min_limit must be >= 1, got {min_limit}");
assert!(
max_limit >= min_limit,
"max_limit ({max_limit}) must be >= min_limit ({min_limit})"
);
let clamped = initial.clamp(min_limit, max_limit);
Self {
current_limit: AtomicUsize::new(clamped),
consecutive_successes: AtomicUsize::new(0),
min_limit,
max_limit,
increase_threshold: DEFAULT_INCREASE_THRESHOLD,
}
}
pub fn with_params(
initial: usize,
min_limit: usize,
max_limit: usize,
increase_threshold: usize,
) -> Self {
assert!(min_limit >= 1, "min_limit must be >= 1, got {min_limit}");
assert!(
max_limit >= min_limit,
"max_limit ({max_limit}) must be >= min_limit ({min_limit})"
);
assert!(
increase_threshold >= 1,
"increase_threshold must be >= 1, got {increase_threshold}"
);
let clamped = initial.clamp(min_limit, max_limit);
Self {
current_limit: AtomicUsize::new(clamped),
consecutive_successes: AtomicUsize::new(0),
min_limit,
max_limit,
increase_threshold,
}
}
pub fn record_success(&self) -> usize {
let successes = self.consecutive_successes.fetch_add(1, Ordering::Relaxed) + 1;
if successes >= self.increase_threshold {
self.consecutive_successes.store(0, Ordering::Relaxed);
loop {
let current = self.current_limit.load(Ordering::Relaxed);
if current >= self.max_limit {
return current;
}
let new = current + 1;
match self.current_limit.compare_exchange(
current,
new,
Ordering::Relaxed,
Ordering::Relaxed,
) {
Ok(_) => {
log_aimd_transition("aimd-limit-increased", current, new);
return new;
}
Err(_) => continue, }
}
}
self.current_limit.load(Ordering::Relaxed)
}
pub fn record_failure(&self) -> usize {
self.consecutive_successes.store(0, Ordering::Relaxed);
self.halve_limit()
}
pub fn on_memory_pressure(&self, critical: bool) -> usize {
self.consecutive_successes.store(0, Ordering::Relaxed);
if critical {
self.halve_limit()
} else {
self.current_limit.load(Ordering::Relaxed)
}
}
fn halve_limit(&self) -> usize {
loop {
let current = self.current_limit.load(Ordering::Relaxed);
let new = (current / 2).max(self.min_limit);
if new == current {
return current;
}
if self
.current_limit
.compare_exchange(current, new, Ordering::Relaxed, Ordering::Relaxed)
.is_ok()
{
log_aimd_transition("aimd-limit-halved", current, new);
return new;
}
}
}
pub fn current_limit(&self) -> usize {
self.current_limit.load(Ordering::Relaxed)
}
pub fn reset(&self, initial: usize) {
let clamped = initial.clamp(self.min_limit, self.max_limit);
self.current_limit.store(clamped, Ordering::Relaxed);
self.consecutive_successes.store(0, Ordering::Relaxed);
}
pub fn min_limit(&self) -> usize {
self.min_limit
}
pub fn max_limit(&self) -> usize {
self.max_limit
}
}
impl Default for AIMDController {
fn default() -> Self {
Self::new(10)
}
}
#[derive(Debug)]
pub struct AdaptiveSemaphore {
semaphore: Arc<Semaphore>,
target: AtomicUsize,
}
impl AdaptiveSemaphore {
pub fn new(initial_permits: usize) -> Self {
Self {
semaphore: Arc::new(Semaphore::new(initial_permits)),
target: AtomicUsize::new(initial_permits),
}
}
pub async fn acquire(&self) -> OwnedSemaphorePermit {
self.semaphore
.clone()
.acquire_owned()
.await
.expect("semaphore closed unexpectedly")
}
pub fn try_acquire(&self) -> Option<OwnedSemaphorePermit> {
self.semaphore.clone().try_acquire_owned().ok()
}
pub fn available_permits(&self) -> usize {
self.semaphore.available_permits()
}
pub fn set_target(&self, new_target: usize) -> usize {
let current = self.target.load(Ordering::Relaxed);
if new_target == current {
return current;
}
self.target.store(new_target, Ordering::Relaxed);
log_aimd_transition("aimd-target-changed", current, new_target);
if new_target > current {
self.semaphore.add_permits(new_target - current);
} else {
let to_remove = current - new_target;
let mut removed = 0;
while removed < to_remove {
match self.semaphore.clone().try_acquire_owned() {
Ok(permit) => {
permit.forget();
removed += 1;
}
Err(_) => {
break;
}
}
}
}
new_target
}
pub fn current_target(&self) -> usize {
self.target.load(Ordering::Relaxed)
}
pub fn semaphore(&self) -> Arc<Semaphore> {
self.semaphore.clone()
}
}
impl Default for AdaptiveSemaphore {
fn default() -> Self {
Self::new(10)
}
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn controller_new_default_params() {
let c = AIMDController::new(10);
assert_eq!(c.current_limit(), 10);
assert_eq!(c.min_limit(), DEFAULT_MIN_LIMIT);
assert_eq!(c.max_limit(), DEFAULT_MAX_LIMIT);
}
#[test]
fn controller_with_bounds_clamps_initial() {
let c = AIMDController::with_bounds(200, 1, 100);
assert_eq!(c.current_limit(), 100);
let c = AIMDController::with_bounds(0, 1, 100);
assert_eq!(c.current_limit(), 1);
}
#[test]
fn record_success_below_threshold_no_increase() {
let c = AIMDController::with_params(10, 1, 100, 5);
for _ in 0..4 {
assert_eq!(c.record_success(), 10);
}
assert_eq!(c.current_limit(), 10);
}
#[test]
fn record_success_at_threshold_increases() {
let c = AIMDController::with_params(10, 1, 100, 5);
for _ in 0..4 {
c.record_success();
}
let target = c.record_success();
assert_eq!(target, 11);
assert_eq!(c.current_limit(), 11);
}
#[test]
fn record_success_multiple_thresholds() {
let c = AIMDController::with_params(10, 1, 100, 3);
for _ in 0..3 {
c.record_success();
}
assert_eq!(c.current_limit(), 11);
for _ in 0..3 {
c.record_success();
}
assert_eq!(c.current_limit(), 12);
}
#[test]
fn record_success_at_max_no_increase() {
let c = AIMDController::with_params(99, 1, 100, 1);
let target = c.record_success();
assert_eq!(target, 100);
let target = c.record_success();
assert_eq!(target, 100);
assert_eq!(c.current_limit(), 100);
}
#[test]
fn record_failure_halves_limit() {
let c = AIMDController::new(10);
let target = c.record_failure();
assert_eq!(target, 5);
assert_eq!(c.current_limit(), 5);
}
#[test]
fn record_failure_multiple_halves() {
let c = AIMDController::new(16);
c.record_failure();
assert_eq!(c.current_limit(), 8);
c.record_failure();
assert_eq!(c.current_limit(), 4);
c.record_failure();
assert_eq!(c.current_limit(), 2);
c.record_failure();
assert_eq!(c.current_limit(), 1);
}
#[test]
fn record_failure_at_min_no_decrease() {
let c = AIMDController::with_bounds(2, 1, 100);
c.record_failure();
assert_eq!(c.current_limit(), 1);
let target = c.record_failure();
assert_eq!(target, 1);
}
#[test]
fn record_failure_resets_success_counter() {
let c = AIMDController::with_params(10, 1, 100, 5);
for _ in 0..3 {
c.record_success();
}
c.record_failure();
for _ in 0..3 {
c.record_success();
}
assert_eq!(c.current_limit(), 5); c.record_success();
assert_eq!(c.current_limit(), 5);
c.record_success();
assert_eq!(c.current_limit(), 6);
}
#[test]
fn alternating_success_failure() {
let c = AIMDController::with_params(10, 1, 100, 1);
c.record_success();
assert_eq!(c.current_limit(), 11);
c.record_failure();
assert_eq!(c.current_limit(), 5);
c.record_success();
assert_eq!(c.current_limit(), 6);
c.record_failure();
assert_eq!(c.current_limit(), 3);
}
#[test]
fn reset_sets_new_value() {
let c = AIMDController::new(10);
c.record_failure();
c.reset(20);
assert_eq!(c.current_limit(), 20);
for _ in 0..9 {
c.record_success();
}
assert_eq!(c.current_limit(), 20);
}
#[test]
fn reset_clamps_to_bounds() {
let c = AIMDController::with_bounds(10, 1, 100);
c.reset(500);
assert_eq!(c.current_limit(), 100);
c.reset(0);
assert_eq!(c.current_limit(), 1);
}
#[test]
fn default_equals_new_10() {
let c = AIMDController::default();
assert_eq!(c.current_limit(), 10);
}
#[test]
fn concurrent_record_success_is_safe() {
use std::sync::Arc;
use std::thread;
let c = Arc::new(AIMDController::with_params(10, 1, 1000, 1));
let handles: Vec<_> = (0..8)
.map(|_| {
let c = c.clone();
thread::spawn(move || {
for _ in 0..100 {
c.record_success();
}
})
})
.collect();
for h in handles {
h.join().expect("thread panicked");
}
assert!(c.current_limit() <= 1000);
}
#[test]
fn concurrent_record_failure_is_safe() {
use std::sync::Arc;
use std::thread;
let c = Arc::new(AIMDController::new(100));
let handles: Vec<_> = (0..8)
.map(|_| {
let c = c.clone();
thread::spawn(move || {
for _ in 0..10 {
c.record_failure();
}
})
})
.collect();
for h in handles {
h.join().expect("thread panicked");
}
assert!(c.current_limit() >= 1);
}
#[test]
fn memory_pressure_freezes_additive_increase() {
let c = AIMDController::with_params(10, 1, 100, 3);
for _ in 0..10 {
c.on_memory_pressure(false);
c.record_success();
c.record_success();
}
assert_eq!(
c.current_limit(),
10,
"renewed pressure signals must freeze additive increase"
);
assert_eq!(
c.on_memory_pressure(false),
10,
"pressure keeps current limit"
);
}
#[test]
fn memory_pressure_recovers_after_signal_stops() {
let c = AIMDController::with_params(10, 1, 100, 3);
c.on_memory_pressure(false);
c.record_success();
c.record_success();
assert_eq!(c.current_limit(), 10, "frozen below threshold");
c.record_success();
assert_eq!(
c.current_limit(),
11,
"increase must resume (no stickiness)"
);
}
#[test]
fn memory_critical_halves_limit_clamped_to_min() {
let c = AIMDController::new(16);
assert_eq!(c.on_memory_pressure(true), 8);
assert_eq!(c.on_memory_pressure(true), 4);
assert_eq!(c.on_memory_pressure(true), 2);
assert_eq!(c.on_memory_pressure(true), 1);
assert_eq!(c.on_memory_pressure(true), 1);
assert_eq!(c.current_limit(), 1);
}
#[test]
fn memory_critical_resets_success_counter() {
let c = AIMDController::with_params(10, 1, 100, 2);
c.record_success();
c.on_memory_pressure(true);
c.record_success();
assert_eq!(c.current_limit(), 5, "10/2=5, counter reset blocks +1");
}
#[test]
fn memory_pressure_keeps_current_limit() {
let c = AIMDController::new(10);
assert_eq!(c.on_memory_pressure(false), 10);
assert_eq!(c.current_limit(), 10);
}
#[test]
fn concurrent_memory_pressure_with_record_is_safe() {
use std::sync::Arc;
use std::thread;
let c = Arc::new(AIMDController::with_params(50, 1, 100, 1));
let handles: Vec<_> = (0..8)
.map(|i| {
let c = c.clone();
thread::spawn(move || {
for _ in 0..100 {
if i % 2 == 0 {
c.record_success();
} else {
c.record_failure();
}
c.on_memory_pressure(i % 4 == 3);
}
})
})
.collect();
for h in handles {
h.join().expect("thread panicked");
}
let limit = c.current_limit();
assert!(
(1..=100).contains(&limit),
"limit must stay in bounds: {limit}"
);
}
#[test]
fn semaphore_new_has_initial_permits() {
let s = AdaptiveSemaphore::new(5);
assert_eq!(s.current_target(), 5);
let _permits: Vec<OwnedSemaphorePermit> = (0..5)
.map(|_| s.try_acquire().expect("should acquire"))
.collect();
assert!(s.try_acquire().is_none());
}
#[test]
fn set_target_increase_adds_permits() {
let s = AdaptiveSemaphore::new(2);
let _p1 = s.try_acquire().expect("permit 1");
let _p2 = s.try_acquire().expect("permit 2");
assert!(s.try_acquire().is_none());
s.set_target(4);
assert_eq!(s.current_target(), 4);
let _p3 = s.try_acquire().expect("permit 3");
let _p4 = s.try_acquire().expect("permit 4");
assert!(s.try_acquire().is_none());
}
#[test]
fn set_target_decrease_removes_available_permits() {
let s = AdaptiveSemaphore::new(5);
s.set_target(2);
assert_eq!(s.current_target(), 2);
let _p1 = s.try_acquire().expect("permit 1");
let _p2 = s.try_acquire().expect("permit 2");
assert!(s.try_acquire().is_none());
}
#[test]
fn set_target_decrease_with_in_use_permits() {
let s = AdaptiveSemaphore::new(5);
let _p1 = s.try_acquire().expect("p1");
let _p2 = s.try_acquire().expect("p2");
let _p3 = s.try_acquire().expect("p3");
s.set_target(1);
assert_eq!(s.current_target(), 1);
drop(_p1);
drop(_p2);
drop(_p3);
assert_eq!(s.current_target(), 1);
}
#[test]
fn set_target_same_value_noop() {
let s = AdaptiveSemaphore::new(5);
let result = s.set_target(5);
assert_eq!(result, 5);
assert_eq!(s.current_target(), 5);
for _ in 0..5 {
assert!(s.try_acquire().is_some());
}
}
#[tokio::test]
async fn acquire_returns_permit() {
let s = AdaptiveSemaphore::new(1);
let permit = s.acquire().await;
drop(permit);
let _permit2 = s.acquire().await;
}
#[test]
fn semaphore_default_equals_new_10() {
let s = AdaptiveSemaphore::default();
assert_eq!(s.current_target(), 10);
}
#[test]
fn semaphore_returns_underlying_arc() {
let s = AdaptiveSemaphore::new(3);
let sem = s.semaphore();
let _ = sem.try_acquire();
}
}