use std::cell::Cell;
use std::sync::Arc;
use std::sync::atomic::{AtomicUsize, Ordering};
use unityrs_testkit::counted::{Allocator, Tally, count_this_thread, others_are_not_counted};
use crate::budget::{BudgetExceeded, MemoryBudget, Permit, PermitHome, Reservation};
use crate::limits::Meter;
#[cfg(test)]
std::thread_local! {
static LIVE: Cell<usize> = const { Cell::new(0) };
}
struct Heap;
impl Tally for Heap {
fn grew(&self, size: usize, _zeroed: bool) {
let _ = LIVE.try_with(|l| l.set(l.get().wrapping_add(size)));
}
fn shrank(&self, size: usize) {
let _ = LIVE.try_with(|l| l.set(l.get().wrapping_sub(size)));
}
}
#[global_allocator]
static ALLOC: Allocator<Heap> = Allocator(Heap);
pub(crate) fn count() {
count_this_thread();
others_are_not_counted(live);
}
pub(crate) fn live() -> usize {
LIVE.try_with(Cell::get).unwrap_or(0)
}
#[derive(Debug, Default)]
pub(crate) struct Noted {
last: AtomicUsize,
releases: AtomicUsize,
}
impl Noted {
pub(crate) fn meter() -> (Arc<Meter>, Arc<Noted>) {
let noted = Arc::new(Noted::default());
let budget = Arc::new(Budget(noted.clone()));
(Meter::new(u64::MAX, budget, Reservation::Input), noted)
}
pub(crate) fn releases(&self) -> usize {
self.releases.load(Ordering::Relaxed)
}
}
impl PermitHome for Noted {
fn release(&self, _bytes: u64) {
self.last.store(live(), Ordering::Relaxed);
self.releases.fetch_add(1, Ordering::Relaxed);
}
}
#[derive(Debug)]
struct Budget(Arc<Noted>);
impl MemoryBudget for Budget {
fn try_reserve(&self, bytes: u64, _what: Reservation) -> Result<Permit, BudgetExceeded> {
Ok(Permit::new(bytes, self.0.clone()))
}
}
pub(crate) fn released_last(noted: &Noted, from: usize, after: usize, what: &str) {
assert!(noted.releases() > from, "{what}: no release");
let at = noted.last.load(Ordering::Relaxed);
assert_eq!(
at,
after,
"{what}: {} bytes were freed after its release",
at.wrapping_sub(after).cast_signed()
);
}