use crate::{Error, Result};
use std::sync::atomic::{AtomicBool, Ordering};
#[derive(Clone, Copy, Debug, Default)]
pub struct Execution<'a> {
max_work: Option<u64>,
cancellation: Option<&'a AtomicBool>,
}
impl<'a> Execution<'a> {
pub fn new(max_work: Option<u64>, cancellation: Option<&'a AtomicBool>) -> Self {
Self {
max_work,
cancellation,
}
}
pub fn max_work(mut self, limit: u64) -> Self {
self.max_work = Some(limit);
self
}
pub fn cancellation(mut self, flag: &'a AtomicBool) -> Self {
self.cancellation = Some(flag);
self
}
pub(crate) fn is_unlimited(&self) -> bool {
self.max_work.is_none() && self.cancellation.is_none()
}
}
pub(crate) struct WorkBudget<'a, const CONTROLLED: bool = true> {
limits: Execution<'a>,
used: u64,
#[cfg(test)]
cancel_at: Option<u64>,
}
impl<'a> WorkBudget<'a> {
pub(crate) fn new(limits: &Execution<'a>) -> Result<Self> {
let result = Self {
limits: *limits,
used: 0,
#[cfg(test)]
cancel_at: None,
};
result.check()?;
Ok(result)
}
}
impl WorkBudget<'static, false> {
pub(crate) fn unlimited() -> Self {
Self {
limits: Execution::default(),
used: 0,
#[cfg(test)]
cancel_at: None,
}
}
}
impl<const CONTROLLED: bool> WorkBudget<'_, CONTROLLED> {
#[inline(always)]
pub(crate) fn check(&self) -> Result<()> {
if !CONTROLLED {
return Ok(());
}
#[cfg(test)]
if self.cancel_at.is_some_and(|at| self.used >= at)
&& let Some(flag) = self.limits.cancellation
{
flag.store(true, Ordering::Relaxed);
}
if self
.limits
.cancellation
.is_some_and(|flag| flag.load(Ordering::Relaxed))
{
return Err(Error::Cancelled);
}
Ok(())
}
#[inline(always)]
pub(crate) fn step(&mut self) -> Result<()> {
self.step_by(1)
}
#[inline(always)]
pub(crate) fn step_by(&mut self, count: usize) -> Result<()> {
if !CONTROLLED {
return Ok(());
}
self.check()?;
if let Some(limit) = self.limits.max_work {
let count = u64::try_from(count).map_err(|_| Error::WorkLimitExceeded { limit })?;
if count > limit - self.used {
return Err(Error::WorkLimitExceeded { limit });
}
self.used += count;
}
Ok(())
}
#[cfg(test)]
pub(crate) fn used(&self) -> u64 {
self.used
}
#[cfg(test)]
pub(crate) fn cancel_at_work(&mut self, work: u64) {
self.cancel_at = Some(work);
}
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn batch_charging_is_atomic_and_does_not_wrap() {
let mut budget = WorkBudget::new(&Execution::default().max_work(3)).unwrap();
budget.step_by(2).unwrap();
assert_eq!(
budget.step_by(2),
Err(Error::WorkLimitExceeded { limit: 3 })
);
assert_eq!(budget.used, 2);
budget.step().unwrap();
budget.step_by(0).unwrap();
assert_eq!(budget.step(), Err(Error::WorkLimitExceeded { limit: 3 }));
let mut budget = WorkBudget::new(&Execution::default().max_work(u64::MAX)).unwrap();
budget.used = u64::MAX - 1;
budget.step().unwrap();
assert_eq!(
budget.step(),
Err(Error::WorkLimitExceeded { limit: u64::MAX })
);
}
}