use std::sync::atomic::{AtomicBool, AtomicUsize, Ordering};
use std::sync::Arc;
use thiserror::Error;
#[derive(Debug, Error)]
pub enum BufferBudgetError {
#[error("max_buffered_bytes={requested} exceeds per-tool limit {tool_limit}")]
OverToolLimit { requested: usize, tool_limit: usize },
#[error("max_buffered_bytes must be > 0")]
ZeroRequest,
#[error("insufficient program buffer budget: requested {requested}, available {available}")]
InsufficientProgramBudget { requested: usize, available: usize },
}
pub trait BufferBudget: Send + Sync {
fn try_reserve(&self, bytes: usize) -> Result<Box<dyn BufferReservation>, BufferBudgetError>;
fn tool_limit(&self) -> usize;
fn program_limit(&self) -> usize;
fn available(&self) -> usize;
}
pub trait BufferReservation: Send + std::fmt::Debug {
fn bytes(&self) -> usize;
}
pub struct AtomicBudget {
program_limit: usize,
tool_limit: usize,
available: Arc<AtomicUsize>,
}
impl AtomicBudget {
pub fn new(program_limit: usize, tool_limit: usize) -> Self {
assert!(program_limit > 0, "program_limit must be > 0");
assert!(tool_limit > 0, "tool_limit must be > 0");
assert!(
tool_limit <= program_limit,
"tool_limit must be <= program_limit"
);
Self {
program_limit,
tool_limit,
available: Arc::new(AtomicUsize::new(program_limit)),
}
}
}
impl BufferBudget for AtomicBudget {
fn try_reserve(&self, bytes: usize) -> Result<Box<dyn BufferReservation>, BufferBudgetError> {
if bytes == 0 {
return Err(BufferBudgetError::ZeroRequest);
}
if bytes > self.tool_limit {
return Err(BufferBudgetError::OverToolLimit {
requested: bytes,
tool_limit: self.tool_limit,
});
}
loop {
let current = self.available.load(Ordering::Acquire);
if current < bytes {
return Err(BufferBudgetError::InsufficientProgramBudget {
requested: bytes,
available: current,
});
}
let new = current - bytes;
if self
.available
.compare_exchange(current, new, Ordering::AcqRel, Ordering::Acquire)
.is_ok()
{
break;
}
}
Ok(Box::new(AtomicReservation {
bytes,
available: Arc::clone(&self.available),
released: AtomicBool::new(false),
}))
}
fn tool_limit(&self) -> usize {
self.tool_limit
}
fn program_limit(&self) -> usize {
self.program_limit
}
fn available(&self) -> usize {
self.available.load(Ordering::Acquire)
}
}
#[derive(Debug)]
struct AtomicReservation {
bytes: usize,
available: Arc<AtomicUsize>,
released: AtomicBool,
}
impl BufferReservation for AtomicReservation {
fn bytes(&self) -> usize {
self.bytes
}
}
impl Drop for AtomicReservation {
fn drop(&mut self) {
if !self.released.swap(true, Ordering::AcqRel) {
self.available.fetch_add(self.bytes, Ordering::AcqRel);
}
}
}
pub struct FakeBudget {
tool_limit: usize,
program_limit: usize,
remaining: Arc<std::sync::Mutex<usize>>,
}
impl FakeBudget {
pub fn new(program_limit: usize, tool_limit: usize) -> Self {
assert!(program_limit > 0);
assert!(tool_limit > 0);
assert!(tool_limit <= program_limit);
Self {
tool_limit,
program_limit,
remaining: Arc::new(std::sync::Mutex::new(program_limit)),
}
}
pub fn reset(&self) {
*self.remaining.lock().expect("remaining") = self.program_limit;
}
}
impl BufferBudget for FakeBudget {
fn try_reserve(&self, bytes: usize) -> Result<Box<dyn BufferReservation>, BufferBudgetError> {
if bytes == 0 {
return Err(BufferBudgetError::ZeroRequest);
}
if bytes > self.tool_limit {
return Err(BufferBudgetError::OverToolLimit {
requested: bytes,
tool_limit: self.tool_limit,
});
}
let mut remaining = self.remaining.lock().expect("remaining");
if *remaining < bytes {
return Err(BufferBudgetError::InsufficientProgramBudget {
requested: bytes,
available: *remaining,
});
}
*remaining -= bytes;
Ok(Box::new(FakeReservation {
bytes,
remaining: Arc::clone(&self.remaining),
released: AtomicBool::new(false),
}))
}
fn tool_limit(&self) -> usize {
self.tool_limit
}
fn program_limit(&self) -> usize {
self.program_limit
}
fn available(&self) -> usize {
*self.remaining.lock().expect("remaining")
}
}
#[derive(Debug)]
struct FakeReservation {
bytes: usize,
remaining: Arc<std::sync::Mutex<usize>>,
released: AtomicBool,
}
impl BufferReservation for FakeReservation {
fn bytes(&self) -> usize {
self.bytes
}
}
impl Drop for FakeReservation {
fn drop(&mut self) {
if !self.released.swap(true, Ordering::AcqRel) {
*self.remaining.lock().expect("remaining") += self.bytes;
}
}
}
pub struct UnlimitedBudget {
tool_limit: usize,
}
impl UnlimitedBudget {
pub fn new(tool_limit: usize) -> Self {
Self { tool_limit }
}
}
impl BufferBudget for UnlimitedBudget {
fn try_reserve(&self, bytes: usize) -> Result<Box<dyn BufferReservation>, BufferBudgetError> {
if bytes == 0 {
return Err(BufferBudgetError::ZeroRequest);
}
if bytes > self.tool_limit {
return Err(BufferBudgetError::OverToolLimit {
requested: bytes,
tool_limit: self.tool_limit,
});
}
Ok(Box::new(NopReservation { bytes }))
}
fn tool_limit(&self) -> usize {
self.tool_limit
}
fn program_limit(&self) -> usize {
usize::MAX
}
fn available(&self) -> usize {
usize::MAX
}
}
#[derive(Debug)]
struct NopReservation {
bytes: usize,
}
impl BufferReservation for NopReservation {
fn bytes(&self) -> usize {
self.bytes
}
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn atomic_budget_reserve_and_release() {
let budget = AtomicBudget::new(1024, 512);
assert_eq!(budget.available(), 1024);
let r = budget.try_reserve(256).unwrap();
assert_eq!(r.bytes(), 256);
assert_eq!(budget.available(), 768);
drop(r);
assert_eq!(budget.available(), 1024);
}
#[test]
fn atomic_budget_over_tool_limit() {
let budget = AtomicBudget::new(1024, 512);
let err = budget.try_reserve(600).unwrap_err();
assert!(matches!(
err,
BufferBudgetError::OverToolLimit {
requested: 600,
tool_limit: 512
}
));
}
#[test]
fn atomic_budget_zero_request() {
let budget = AtomicBudget::new(1024, 512);
let err = budget.try_reserve(0).unwrap_err();
assert!(matches!(err, BufferBudgetError::ZeroRequest));
}
#[test]
fn atomic_budget_insufficient_program() {
let budget = AtomicBudget::new(1024, 1024);
let _r1 = budget.try_reserve(800).unwrap();
let err = budget.try_reserve(300).unwrap_err();
assert!(matches!(
err,
BufferBudgetError::InsufficientProgramBudget {
requested: 300,
available: 224
}
));
}
#[test]
fn atomic_budget_concurrent_reserve() {
let budget = Arc::new(AtomicBudget::new(4096, 4096));
let mut handles = Vec::new();
for _ in 0..4 {
let b = Arc::clone(&budget);
handles.push(std::thread::spawn(move || {
let r = b.try_reserve(1024).unwrap();
assert_eq!(r.bytes(), 1024);
r
}));
}
let reservations: Vec<_> = handles.into_iter().map(|h| h.join().unwrap()).collect();
assert_eq!(budget.available(), 0);
let err = budget.try_reserve(1).unwrap_err();
assert!(matches!(
err,
BufferBudgetError::InsufficientProgramBudget { .. }
));
drop(reservations);
assert_eq!(budget.available(), 4096);
}
#[test]
fn atomic_budget_rejects_zero_limits() {
let _ = std::panic::catch_unwind(|| AtomicBudget::new(0, 1));
let _ = std::panic::catch_unwind(|| AtomicBudget::new(1, 0));
let _ = std::panic::catch_unwind(|| AtomicBudget::new(1, 2));
}
#[test]
fn atomic_budget_reserve_at_exact_tool_limit() {
let budget = AtomicBudget::new(1024, 512);
let r = budget.try_reserve(512).unwrap();
assert_eq!(r.bytes(), 512);
assert_eq!(budget.available(), 512);
}
#[test]
fn atomic_budget_reports_configured_limits() {
let budget = AtomicBudget::new(1024, 512);
assert_eq!(budget.tool_limit(), 512);
assert_eq!(budget.program_limit(), 1024);
}
#[test]
fn fake_budget_basic() {
let budget = FakeBudget::new(1024, 512);
let r = budget.try_reserve(256).unwrap();
assert_eq!(budget.available(), 768);
drop(r);
assert_eq!(budget.available(), 1024);
}
#[test]
fn fake_budget_exhaustion() {
let budget = FakeBudget::new(512, 512);
let _r1 = budget.try_reserve(512).unwrap();
let err = budget.try_reserve(1).unwrap_err();
assert!(matches!(
err,
BufferBudgetError::InsufficientProgramBudget {
requested: 1,
available: 0
}
));
}
#[test]
fn fake_budget_reports_configured_limits() {
let budget = FakeBudget::new(1024, 512);
assert_eq!(budget.tool_limit(), 512);
assert_eq!(budget.program_limit(), 1024);
}
#[test]
fn fake_budget_reservation_bytes_matches_request() {
let budget = FakeBudget::new(1024, 512);
let r = budget.try_reserve(256).unwrap();
assert_eq!(r.bytes(), 256);
}
#[test]
fn fake_budget_reset_restores_available() {
let budget = FakeBudget::new(512, 512);
let _r = budget.try_reserve(512).unwrap();
assert_eq!(budget.available(), 0);
assert!(budget.try_reserve(1).is_err());
budget.reset();
assert_eq!(budget.available(), 512);
let r2 = budget.try_reserve(256).unwrap();
assert_eq!(r2.bytes(), 256);
}
#[test]
fn unlimited_budget_always_succeeds() {
let budget = UnlimitedBudget::new(1024);
let r = budget.try_reserve(1024).unwrap();
assert_eq!(r.bytes(), 1024);
assert_eq!(budget.available(), usize::MAX);
}
#[test]
fn unlimited_budget_still_rejects_over_tool_limit() {
let budget = UnlimitedBudget::new(1024);
let err = budget.try_reserve(1025).unwrap_err();
assert!(matches!(err, BufferBudgetError::OverToolLimit { .. }));
}
#[test]
fn unlimited_budget_rejects_zero() {
let budget = UnlimitedBudget::new(1024);
let err = budget.try_reserve(0).unwrap_err();
assert!(matches!(err, BufferBudgetError::ZeroRequest));
}
#[test]
fn unlimited_budget_reports_configured_limits() {
let budget = UnlimitedBudget::new(1024);
assert_eq!(budget.tool_limit(), 1024);
assert_eq!(budget.program_limit(), usize::MAX);
}
}