use std::sync::Arc;
use std::sync::atomic::{AtomicU64, Ordering};
#[derive(Debug)]
pub(crate) struct Account {
limit: u64,
used: AtomicU64,
whole: Option<Arc<Account>>,
base: u64,
#[cfg_attr(
not(feature = "parallel"),
expect(dead_code, reason = "only a race's parts read it")
)]
input: u64,
}
impl Account {
#[cfg(any(test, feature = "interactive"))]
pub(crate) fn new(limit: Option<u64>) -> Self {
Self::holding(limit, 0)
}
pub(crate) fn holding(limit: Option<u64>, input: u64) -> Self {
Self {
limit: limit.unwrap_or(u64::MAX),
used: AtomicU64::new(input),
whole: None,
base: 0,
input,
}
}
#[cfg(feature = "parallel")]
pub(crate) fn part_of(whole: &Arc<Account>) -> Self {
Self {
limit: if whole.limit == u64::MAX {
u64::MAX
} else {
whole.limit.saturating_sub(whole.input)
},
used: AtomicU64::new(0),
whole: Some(whole.clone()),
base: 0,
input: 0,
}
}
pub(crate) fn share(&self, parts: u64) -> Self {
Self {
limit: if self.limit == u64::MAX {
u64::MAX
} else {
self.limit.saturating_sub(self.used()) / parts
},
used: AtomicU64::new(0),
whole: self.whole.clone(),
base: 0,
input: 0,
}
}
pub(crate) fn fork(&self) -> Self {
Self {
limit: self.limit,
used: AtomicU64::new(self.used()),
whole: self.whole.clone(),
base: self.used(),
input: 0,
}
}
pub(crate) fn limit(&self) -> u64 {
self.limit
}
pub(crate) fn charge(&self, bytes: usize) {
self.used.fetch_add(bytes as u64, Ordering::Relaxed);
if let Some(whole) = &self.whole {
whole.charge(bytes);
}
}
pub(crate) fn release(&self, bytes: usize) {
self.used.fetch_sub(bytes as u64, Ordering::Relaxed);
if let Some(whole) = &self.whole {
whole.release(bytes);
}
}
pub(crate) fn rewind(&self, held: u64) {
let since = self.used().saturating_sub(held);
self.used.fetch_sub(since, Ordering::Relaxed);
if let Some(whole) = &self.whole {
whole
.used
.fetch_sub(since.min(whole.used()), Ordering::Relaxed);
}
}
pub(crate) fn resize(&self, before: usize, after: usize) {
if after > before {
self.charge(after - before);
} else if before > after {
self.release(before - after);
}
}
pub(crate) fn used(&self) -> u64 {
self.used.load(Ordering::Relaxed)
}
pub(crate) fn left(&self) -> Option<u64> {
let own = (self.limit != u64::MAX).then(|| self.limit.saturating_sub(self.used()));
match (own, self.whole.as_ref().and_then(|whole| whole.left())) {
(Some(own), Some(whole)) => Some(own.min(whole)),
(own, whole) => own.or(whole),
}
}
pub(crate) fn fits(&self, bytes: usize) -> bool {
self.used().saturating_add(bytes as u64) <= self.limit
&& self.whole.as_ref().is_none_or(|whole| whole.fits(bytes))
}
pub(crate) fn spares(&self, bytes: usize) -> bool {
self.used()
.saturating_add(bytes as u64)
.saturating_add(self.limit / 8)
<= self.limit
&& self.whole.as_ref().is_none_or(|whole| whole.spares(bytes))
}
pub(crate) fn over(&self) -> bool {
self.used() > self.limit || self.whole.as_ref().is_some_and(|whole| whole.over())
}
}
impl Drop for Account {
fn drop(&mut self) {
if let Some(whole) = &self.whole {
let own = self.used().saturating_sub(self.base);
whole
.used
.fetch_sub(own.min(whole.used()), Ordering::Relaxed);
}
}
}
#[derive(Debug)]
pub(crate) struct Charged<'a> {
account: &'a Account,
bytes: usize,
}
impl<'a> Charged<'a> {
pub(crate) fn new(account: &'a Account) -> Self {
Self { account, bytes: 0 }
}
pub(crate) fn account(&self) -> &'a Account {
self.account
}
pub(crate) fn charge(&mut self, bytes: usize) {
self.bytes += bytes;
self.account.charge(bytes);
}
pub(crate) fn resize(&mut self, before: usize, after: usize) {
self.bytes = self.bytes + after - before;
self.account.resize(before, after);
}
}
impl Drop for Charged<'_> {
fn drop(&mut self) {
self.account.release(self.bytes);
}
}
pub(crate) fn bytes_of<T>(vector: &Vec<T>) -> usize {
vector.capacity() * size_of::<T>()
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn accounting() {
let account = Account::new(Some(100));
account.charge(60);
assert!(account.fits(40) && !account.fits(41) && !account.over());
assert!(account.spares(28) && !account.spares(29));
account.resize(60, 110);
assert!(account.over());
account.release(20);
assert_eq!(account.used(), 90);
assert_eq!(account.left(), Some(10));
let half = account.share(2);
assert!(half.fits(5) && !half.fits(6), "half of what is left");
assert_eq!(Account::new(None).left(), None);
assert!(Account::new(None).share(2).fits(usize::MAX));
#[cfg(feature = "parallel")]
{
let whole = Arc::new(Account::holding(Some(100), 40));
let half = Account::part_of(&whole).share(2);
assert!(half.fits(30) && !half.fits(31));
}
let before = account.used();
let mut own = Charged::new(&account);
own.charge(7);
own.resize(7, 3);
assert_eq!(account.used(), before + 3);
drop(own);
assert_eq!(account.used(), before);
}
}