use std::cell::{Cell, RefCell};
use std::sync::atomic::{AtomicBool, AtomicUsize, Ordering};
use purrdf_lex::allocation::{Admission, StorageError};
use purrdf_lex::walk::WorkList;
use crate::budget::Budget;
use crate::error::{LoadError, LoadErrorKind};
use crate::modtree::TargetId;
use crate::options::LoadOptions;
use crate::path::RelPath;
use crate::prescan::Scan;
#[derive(Debug, Clone, Copy, PartialEq, Eq, Default)]
#[non_exhaustive]
pub struct Usage {
pub total_bytes: usize,
pub item_bytes: usize,
pub fact_bytes: usize,
pub glob_bytes: usize,
pub max_file_tokens: usize,
pub max_recursion: usize,
pub max_directory_depth: usize,
pub work: usize,
}
pub(crate) struct Meter {
options: LoadOptions,
total_bytes: Cell<usize>,
item_bytes: Cell<usize>,
fact_bytes: Cell<usize>,
glob_bytes: Cell<usize>,
glob_peak: Cell<usize>,
max_file_tokens: Cell<usize>,
max_recursion: Cell<usize>,
max_directory_depth: Cell<usize>,
work: Cell<usize>,
work_limit: usize,
query_passed: Cell<Option<usize>>,
}
pub(crate) struct Transient<'m> {
meter: &'m Meter,
bytes: Cell<usize>,
}
pub(crate) struct QueryObservation<'m> {
memory: Transient<'m>,
targets: RefCell<Vec<TargetId>>,
}
impl<'m> QueryObservation<'m> {
pub(crate) const fn new(meter: &'m Meter) -> Self {
Self {
memory: Transient::new(meter),
targets: RefCell::new(Vec::new()),
}
}
pub(crate) fn record(
&self,
target: TargetId,
file: &RelPath,
line: Option<usize>,
) -> Result<(), LoadError> {
let mut targets = self.targets.borrow_mut();
self.memory
.work(targets.len().saturating_add(1), file, line)?;
if targets.contains(&target) {
return Ok(());
}
let bytes = targets.capacity() * size_of::<TargetId>();
let steps = Steps::QueryAt {
memory: &self.memory,
file,
line,
};
let mut admission = NativeAdmission::resume(steps, bytes);
purrdf_lex::allocation::Memory::resume(&mut admission, bytes)
.push(&mut targets, target)
.map_err(|error| admission.graph_error(error.into()))
}
pub(crate) fn finish(self) -> Vec<TargetId> {
self.targets.into_inner()
}
}
impl<'m> Transient<'m> {
pub(crate) const fn new(meter: &'m Meter) -> Self {
Self {
meter,
bytes: Cell::new(0),
}
}
pub(crate) const fn child(&self) -> Self {
Self::new(self.meter)
}
pub(crate) fn charge(
&self,
bytes: usize,
file: &RelPath,
line: Option<usize>,
) -> Result<(), LoadError> {
let limit = self.meter.options.max_glob_bytes;
let next = self
.bytes
.get()
.checked_add(bytes)
.filter(|_| {
self.meter
.glob_bytes
.get()
.checked_add(bytes)
.is_some_and(|held| held <= limit)
})
.ok_or_else(|| over_budget(Budget::GlobBytes, limit, file, line))?;
self.meter.globs(bytes, file, line)?;
self.bytes.set(next);
Ok(())
}
pub(crate) fn work(
&self,
units: usize,
file: &RelPath,
line: Option<usize>,
) -> Result<(), LoadError> {
self.meter.work(units, file, line)
}
pub(crate) fn transfer_to(
&self,
owner: &Self,
bytes: usize,
file: &RelPath,
line: Option<usize>,
) -> Result<(), LoadError> {
let retained = owner.bytes.get().checked_add(bytes);
if !std::ptr::eq(self.meter, owner.meter)
|| std::ptr::eq(self, owner)
|| bytes > self.bytes.get()
|| retained.is_none()
{
return Err(LoadError::new(
file,
line,
LoadErrorKind::Internal {
what: "retained import storage exceeds its original allocation grant"
.to_owned(),
},
));
}
owner
.bytes
.set(retained.expect("checked destination grant"));
self.bytes.set(self.bytes.get() - bytes);
Ok(())
}
}
impl Drop for Transient<'_> {
fn drop(&mut self) {
self.meter.release_globs(self.bytes.get());
}
}
pub(crate) struct NativeAdmission<'m> {
steps: Steps<'m>,
items: Option<(&'m Meter, &'m RelPath, Option<usize>)>,
live: usize,
failure: Option<LoadError>,
}
impl<'m> NativeAdmission<'m> {
pub(crate) const fn new(steps: Steps<'m>) -> Self {
Self {
steps,
items: None,
live: 0,
failure: None,
}
}
pub(crate) const fn resume(steps: Steps<'m>, live: usize) -> Self {
Self {
steps,
items: None,
live,
failure: None,
}
}
pub(crate) const fn items(
meter: &'m Meter,
file: &'m RelPath,
line: Option<usize>,
bytes: usize,
) -> Self {
Self {
steps: Steps::Load,
items: Some((meter, file, line)),
live: bytes,
failure: None,
}
}
pub(crate) fn graph_error(&mut self, error: purrdf_core::graph::GraphError) -> LoadError {
self.failure.take().unwrap_or_else(|| {
let (file, line) = if let Some((_, file, line)) = self.items {
(file.clone(), line)
} else {
match self.steps {
Steps::LoadAt { file, line, .. } => (file.clone(), Some(line)),
Steps::QueryAt { file, line, .. } | Steps::QueryItems { file, line, .. } => {
(file.clone(), line)
}
Steps::Load | Steps::Query(_) | Steps::Observed(_) => (RelPath::root(), None),
}
};
LoadError::new(&file, line, LoadErrorKind::Graph(error))
})
}
}
impl Admission for NativeAdmission<'_> {
fn resize(&mut self, live: usize) -> Result<(), StorageError> {
if live > self.live {
let result = if let Some((meter, file, line)) = self.items {
meter.items(live - self.live, file, line)
} else {
self.steps.reserve(live - self.live)
};
if let Err(error) = result {
if self.failure.is_none() {
self.failure = Some(error);
}
return Err(StorageError::AdmissionFailed);
}
} else if let Steps::LoadAt { memory, .. } | Steps::QueryAt { memory, .. } = self.steps {
let released = self.live - live;
memory.bytes.set(memory.bytes.get() - released);
memory.meter.release_globs(released);
}
self.live = live;
Ok(())
}
}
pub(crate) fn push_item_work<T, const N: usize>(
into: &mut WorkList<T, N>,
value: T,
meter: &Meter,
file: &RelPath,
line: Option<usize>,
) -> Result<(), LoadError> {
let bytes = into.heap_capacity() * size_of::<T>();
let mut admission = NativeAdmission::items(meter, file, line, bytes);
into.try_push_admitted(
value,
&mut purrdf_lex::allocation::Memory::resume(&mut admission, bytes),
)
.map_err(|error| admission.graph_error(error.into()))
}
#[derive(Debug, Default)]
pub(crate) struct LookupCount {
count: AtomicUsize,
built: AtomicBool,
}
impl LookupCount {
pub(crate) fn add(&self, steps: usize) {
debug_assert!(
!self.built.load(Ordering::Relaxed),
"a lookup after the load counted on the count of the load"
);
self.count
.store(self.get().saturating_add(steps), Ordering::Relaxed);
}
pub(crate) fn take(&self) -> usize {
self.count.swap(0, Ordering::Relaxed)
}
pub(crate) fn get(&self) -> usize {
self.count.load(Ordering::Relaxed)
}
pub(crate) fn built(&self, built: bool) {
self.built.store(built, Ordering::Relaxed);
}
}
impl Clone for LookupCount {
fn clone(&self) -> Self {
Self {
count: AtomicUsize::new(self.get()),
built: AtomicBool::new(self.built.load(Ordering::Relaxed)),
}
}
}
impl PartialEq for LookupCount {
fn eq(&self, other: &Self) -> bool {
self.get() == other.get()
}
}
impl Eq for LookupCount {}
#[derive(Clone, Copy)]
pub(crate) enum Steps<'m> {
Load,
LoadAt {
memory: &'m Transient<'m>,
file: &'m RelPath,
line: usize,
},
Query(&'m Meter),
Observed(&'m QueryObservation<'m>),
QueryItems {
meter: &'m Meter,
file: &'m RelPath,
line: Option<usize>,
},
QueryAt {
memory: &'m Transient<'m>,
file: &'m RelPath,
line: Option<usize>,
},
}
impl<'m> Steps<'m> {
pub(crate) fn reserve(self, bytes: usize) -> Result<(), LoadError> {
match self {
Self::LoadAt { memory, file, line } => memory.charge(bytes, file, Some(line)),
Self::QueryAt { memory, file, line } => memory.charge(bytes, file, line),
Self::QueryItems { meter, file, line } => meter.items(bytes, file, line),
Self::Load | Self::Query(_) | Self::Observed(_) => Ok(()),
}
}
pub(crate) fn storage_work(self, units: usize) -> Result<(), LoadError> {
match self {
Self::LoadAt { memory, file, line } => {
memory.work(units, file, Some(line))?;
crate::work::add(crate::work::Work::SettleSteps, units);
Ok(())
}
Self::QueryAt { memory, file, line } => {
memory.work(units, file, line)?;
crate::work::add(crate::work::Work::LookupCharges, units);
Ok(())
}
Self::QueryItems { meter, file, line } => {
meter.work(units, file, line)?;
crate::work::add(crate::work::Work::LookupCharges, units);
Ok(())
}
Self::Load | Self::Query(_) | Self::Observed(_) => Ok(()),
}
}
pub(crate) fn temporary(self) -> Option<Transient<'m>> {
match self {
Self::LoadAt { memory, .. } | Self::QueryAt { memory, .. } => Some(memory.child()),
Self::Load | Self::Query(_) | Self::Observed(_) | Self::QueryItems { .. } => None,
}
}
pub(crate) fn at(self, memory: &'m Transient<'m>) -> Self {
match self {
Self::LoadAt { file, line, .. } => Self::LoadAt { memory, file, line },
Self::QueryAt { file, line, .. } => Self::QueryAt { memory, file, line },
Self::Load | Self::Query(_) | Self::Observed(_) | Self::QueryItems { .. } => self,
}
}
pub(crate) fn query_meter(self) -> Option<&'m Meter> {
match self {
Self::Query(meter) | Self::QueryItems { meter, .. } => Some(meter),
Self::Observed(observation) => Some(observation.memory.meter),
Self::QueryAt { memory, .. } => Some(memory.meter),
Self::Load | Self::LoadAt { .. } => None,
}
}
pub(crate) fn with_query_storage(
self,
memory: Option<&'m Transient<'m>>,
site: (&'m RelPath, Option<usize>),
) -> Self {
if matches!(self, Self::QueryItems { .. }) {
return self;
}
memory.map_or(self, |memory| Self::QueryAt {
memory,
file: site.0,
line: site.1,
})
}
}
pub(crate) struct ItemAdmission<'m> {
meter: &'m Meter,
file: &'m RelPath,
live: usize,
failure: Option<LoadError>,
}
impl<'m> ItemAdmission<'m> {
pub(crate) const fn new(meter: &'m Meter, file: &'m RelPath) -> Self {
Self::resume(meter, file, 0)
}
pub(crate) const fn resume(meter: &'m Meter, file: &'m RelPath, live: usize) -> Self {
Self {
meter,
file,
live,
failure: None,
}
}
pub(crate) fn error(&mut self, error: StorageError) -> LoadError {
self.failure
.take()
.unwrap_or_else(|| LoadError::new(self.file, None, LoadErrorKind::Storage(error)))
}
pub(crate) fn recover(&mut self, error: LoadError) -> LoadError {
self.failure.take().unwrap_or(error)
}
}
impl Admission for ItemAdmission<'_> {
fn resize(&mut self, live: usize) -> Result<(), StorageError> {
if self.failure.is_some() {
return Err(StorageError::AdmissionFailed);
}
if live > self.live
&& let Err(error) = self.meter.items(live - self.live, self.file, None)
{
self.failure = Some(error);
return Err(StorageError::AdmissionFailed);
}
self.live = live;
Ok(())
}
}
pub(crate) fn over_budget(
budget: Budget,
limit: usize,
file: &RelPath,
line: Option<usize>,
) -> LoadError {
LoadError::new(file, line, LoadErrorKind::Budget { budget, limit })
}
fn add(total: &Cell<usize>, amount: usize, limit: usize) -> Result<(), ()> {
let sum = total.get().saturating_add(amount);
total.set(sum);
if sum > limit { Err(()) } else { Ok(()) }
}
impl Meter {
pub(crate) fn resume(options: &LoadOptions, usage: Usage) -> Self {
let meter = Self::new(options);
meter.total_bytes.set(usage.total_bytes);
meter.item_bytes.set(usage.item_bytes);
meter.fact_bytes.set(usage.fact_bytes);
meter.glob_peak.set(usage.glob_bytes);
meter.max_file_tokens.set(usage.max_file_tokens);
meter.max_recursion.set(usage.max_recursion);
meter.max_directory_depth.set(usage.max_directory_depth);
meter.work.set(usage.work);
meter
}
pub(crate) fn configuration_usage(&self) -> ConfigurationUsage {
ConfigurationUsage {
item_bytes: self.item_bytes.get(),
work: self.work.get(),
}
}
pub(crate) fn configuration_spent(
&self,
before: Usage,
after: ConfigurationUsage,
file: &RelPath,
) -> Result<(), LoadError> {
let backwards = || {
LoadError::new(
file,
None,
LoadErrorKind::Internal {
what: "configuration callback usage moved backwards".to_owned(),
},
)
};
self.items(
after
.item_bytes
.checked_sub(before.item_bytes)
.ok_or_else(backwards)?,
file,
None,
)?;
self.work(
after.work.checked_sub(before.work).ok_or_else(backwards)?,
file,
None,
)
}
pub(crate) fn new(options: &LoadOptions) -> Self {
Self {
options: options.clone(),
total_bytes: Cell::new(0),
item_bytes: Cell::new(0),
fact_bytes: Cell::new(0),
glob_bytes: Cell::new(0),
glob_peak: Cell::new(0),
max_file_tokens: Cell::new(0),
max_recursion: Cell::new(0),
max_directory_depth: Cell::new(0),
work: Cell::new(0),
work_limit: options.max_work,
query_passed: Cell::new(None),
}
}
pub(crate) fn query(options: &LoadOptions) -> Self {
Self {
work_limit: options.max_query_work,
..Self::new(options)
}
}
pub(crate) fn resume_query(options: &LoadOptions, usage: Usage) -> Self {
Self {
work_limit: options.max_query_work,
..Self::resume(options, usage)
}
}
pub(crate) fn count_query(&self, units: usize, module: usize) {
let sum = self.work.get().saturating_add(units);
self.work.set(sum);
if sum > self.work_limit && self.query_passed.get().is_none() {
self.query_passed.set(Some(module));
}
}
pub(crate) fn query_passed(&self) -> Option<usize> {
self.query_passed.get()
}
pub(crate) fn work_limit(&self) -> usize {
self.work_limit
}
pub(crate) fn options(&self) -> &LoadOptions {
&self.options
}
pub(crate) fn read(&self, file: &RelPath, text: &str) -> Result<(), LoadError> {
self.read_bytes(file, text.len())
}
pub(crate) fn read_bytes(&self, file: &RelPath, bytes: usize) -> Result<(), LoadError> {
let limit = self.options.max_total_bytes;
add(&self.total_bytes, bytes, limit)
.map_err(|()| over_budget(Budget::TotalBytes, limit, file, None))
}
pub(crate) fn items(
&self,
bytes: usize,
file: &RelPath,
line: Option<usize>,
) -> Result<(), LoadError> {
let limit = self.options.max_item_bytes;
add(&self.item_bytes, bytes, limit)
.map_err(|()| over_budget(Budget::ItemBytes, limit, file, line))
}
pub(crate) fn globs(
&self,
bytes: usize,
file: &RelPath,
line: Option<usize>,
) -> Result<(), LoadError> {
let limit = self.options.max_glob_bytes;
let held = add(&self.glob_bytes, bytes, limit);
self.glob_peak
.set(self.glob_peak.get().max(self.glob_bytes.get()));
held.map_err(|()| over_budget(Budget::GlobBytes, limit, file, line))
}
pub(crate) fn work(
&self,
units: usize,
file: &RelPath,
line: Option<usize>,
) -> Result<(), LoadError> {
let limit = self.work_limit;
#[cfg(test)]
charges::record(units);
add(&self.work, units, limit).map_err(|()| over_budget(Budget::Work, limit, file, line))
}
pub(crate) fn release_globs(&self, bytes: usize) {
let held = self
.glob_bytes
.get()
.checked_sub(bytes)
.expect("only what was charged is released");
self.glob_bytes.set(held);
}
pub(crate) fn fact_allowance(&self) -> FactAllowance {
FactAllowance {
spent: self.fact_bytes.get(),
limit: self.options.max_fact_bytes,
}
}
pub(crate) fn facts(&self, bytes: usize, file: &RelPath) -> Result<(), LoadError> {
let total = self
.fact_bytes
.get()
.checked_add(bytes)
.filter(|total| *total <= self.options.max_fact_bytes)
.ok_or_else(|| {
LoadError::new(
file,
None,
LoadErrorKind::Internal {
what: "parser fact accounting exceeded its original allowance".to_owned(),
},
)
})?;
self.fact_bytes.set(total);
Ok(())
}
pub(crate) fn scanned(&self, scan: Scan) {
self.max_file_tokens
.set(self.max_file_tokens.get().max(scan.tokens));
self.max_recursion
.set(self.max_recursion.get().max(scan.recursion));
}
pub(crate) fn directory(&self, depth: usize, dir: &RelPath) -> Result<(), LoadError> {
if depth > Budget::DirectoryDepth.limit() {
return Err(over_budget(
Budget::DirectoryDepth,
Budget::DirectoryDepth.limit(),
dir,
None,
));
}
self.max_directory_depth
.set(self.max_directory_depth.get().max(depth));
Ok(())
}
pub(crate) fn usage(&self) -> Usage {
Usage {
total_bytes: self.total_bytes.get(),
item_bytes: self.item_bytes.get(),
fact_bytes: self.fact_bytes.get(),
glob_bytes: self.glob_peak.get(),
max_file_tokens: self.max_file_tokens.get(),
max_recursion: self.max_recursion.get(),
max_directory_depth: self.max_directory_depth.get(),
work: self.work.get(),
}
}
}
#[cfg(test)]
pub(crate) mod charges {
use std::cell::RefCell;
thread_local! {
static CHARGES: RefCell<Vec<usize>> = const { RefCell::new(Vec::new()) };
}
pub(super) fn record(units: usize) {
CHARGES.with_borrow_mut(|charges| charges.push(units));
}
pub(crate) fn take() -> Vec<usize> {
CHARGES.take()
}
}
#[derive(Debug, Clone, Copy)]
pub(crate) struct FactAllowance {
pub(crate) spent: usize,
pub(crate) limit: usize,
}
#[derive(Clone, Copy)]
pub(crate) struct ConfigurationUsage {
item_bytes: usize,
work: usize,
}
#[cfg(test)]
mod tests {
use std::error::Error;
use purrdf_lex::allocation::{Admission, Memory, StorageError};
use super::{ItemAdmission, Meter, NativeAdmission, Steps, Transient, charges};
use crate::budget::Budget;
use crate::error::{LoadError, LoadErrorKind, Origin};
use crate::options::LoadOptions;
use crate::path::RelPath;
fn meter(max_work: usize) -> Meter {
Meter::new(&LoadOptions {
max_work,
..LoadOptions::default()
})
}
#[test]
fn native_recovery_preserves_nested_provenance_and_restores_its_own_refusal() {
let account = RelPath::new("account/Cargo.toml").unwrap();
let nested = RelPath::new("nested/src/lib.rs").unwrap();
let meter = Meter::new(&LoadOptions {
max_item_bytes: 0,
..LoadOptions::default()
});
let mut admission = ItemAdmission::new(&meter, &account);
let original = || {
LoadError::new(
&nested,
Some(17),
LoadErrorKind::Storage(StorageError::AdmissionFailed),
)
.reached_by(&Origin::Discovery)
};
let preserved = admission.recover(original());
assert_eq!(preserved.file, nested);
assert_eq!(preserved.line, Some(17));
assert!(matches!(
preserved.origin.as_deref(),
Some(Origin::Discovery)
));
assert!(matches!(
preserved.kind,
LoadErrorKind::Storage(StorageError::AdmissionFailed)
));
assert_eq!(admission.resize(1), Err(StorageError::AdmissionFailed));
let restored = admission.recover(original());
assert_eq!(restored.file, account);
assert_eq!(restored.line, None);
assert!(matches!(
restored.kind,
LoadErrorKind::Budget {
budget: Budget::ItemBytes,
limit: 0
}
));
}
#[test]
fn native_storage_preserves_the_item_limit_and_cumulative_charges() {
let file = RelPath::new("Cargo.toml").expect("path");
let meter = Meter::new(&LoadOptions {
max_item_bytes: 16,
..LoadOptions::default()
});
let mut admission = ItemAdmission::new(&meter, &file);
admission.resize(16).expect("exact limit");
admission.resize(8).expect("released storage");
assert_eq!(meter.usage().item_bytes, 16);
let native = admission.resize(9).expect_err("growth remains cumulative");
assert_eq!(native, StorageError::AdmissionFailed);
assert_eq!(admission.resize(8), Err(StorageError::AdmissionFailed));
let error = admission.error(native);
assert!(matches!(
error.kind,
LoadErrorKind::Budget {
budget: Budget::ItemBytes,
limit: 16,
}
));
assert_eq!(error.file, file);
assert_eq!(meter.usage().item_bytes, 17);
}
#[test]
fn native_storage_capacity_failure_has_its_original_error_source() {
let file = RelPath::new("Cargo.toml").expect("path");
let meter = Meter::new(&LoadOptions::default());
let mut admission = ItemAdmission::new(&meter, &file);
let mut values = Vec::<u64>::new();
let native = {
let mut memory = Memory::new(&mut admission);
memory
.reserve(&mut values, 1)
.expect("small native allocation");
let native = memory
.reserve(&mut values, usize::MAX)
.expect_err("impossible native capacity");
memory
.reserve(&mut values, 2)
.expect("capacity failure did not poison admission");
native
};
let error = admission.error(native);
assert!(matches!(error.kind, LoadErrorKind::Storage(found) if found == native));
assert_eq!(error.file, file);
assert_eq!(
error.source().expect("native source").to_string(),
native.to_string()
);
assert_eq!(values.len(), 0);
}
#[test]
fn work_up_to_the_limit_is_accepted_and_the_charge_that_passes_it_is_refused() {
let file = RelPath::new("src/lib.rs").expect("path");
let meter = meter(10);
meter.work(4, &file, Some(3)).expect("below the limit");
meter.work(6, &file, Some(3)).expect("at the limit");
assert_eq!(meter.usage().work, 10);
let error = meter.work(5, &file, Some(7)).expect_err("over the limit");
assert!(
matches!(
error.kind,
LoadErrorKind::Budget {
budget: Budget::Work,
limit: 10
}
),
"{error}"
);
assert_eq!((error.file.as_str(), error.line), ("src/lib.rs", Some(7)));
assert_eq!(meter.usage().work, 15);
assert_eq!(charges::take(), vec![4, 6, 5]);
}
#[test]
fn work_is_never_released_and_each_meter_counts_from_zero() {
let file = RelPath::new("src/lib.rs").expect("path");
let first = meter(100);
first.globs(64, &file, None).expect("glob bytes");
first.work(40, &file, None).expect("work");
first.release_globs(64);
first.work(40, &file, None).expect("work");
assert_eq!(first.usage().work, 80);
assert_eq!(first.usage().glob_bytes, 64);
let second = meter(100);
assert_eq!(second.usage().work, 0);
second.work(1, &file, None).expect("work");
assert_eq!(second.usage().work, 1);
assert_eq!(first.usage().work, 80);
}
#[test]
fn transient_reservations_refuse_atomically_and_release_on_every_exit() {
let file = RelPath::new("src/imports.rs").expect("path");
for limit in [63, 64] {
let meter = Meter::new(&LoadOptions {
max_glob_bytes: limit,
..LoadOptions::default()
});
meter.globs(16, &file, Some(2)).expect("retained tables");
{
let first = Transient::new(&meter);
first
.charge(24, &file, Some(3))
.expect("previous generation");
{
let next = first.child();
let result = next.charge(24, &file, Some(7));
if limit == 64 {
result.expect("exact simultaneous limit");
assert_eq!(meter.glob_bytes.get(), 64);
} else {
let error = result.expect_err("one below simultaneous limit");
assert_eq!(
(error.file.as_str(), error.line),
("src/imports.rs", Some(7))
);
assert!(matches!(
error.kind,
LoadErrorKind::Budget {
budget: Budget::GlobBytes,
limit: 63
}
));
assert_eq!(next.bytes.get(), 0);
assert_eq!(meter.glob_bytes.get(), 40);
}
assert!(next.charge(usize::MAX, &file, Some(9)).is_err());
assert_eq!(meter.glob_bytes.get(), if limit == 64 { 64 } else { 40 });
}
assert_eq!(meter.glob_bytes.get(), 40);
assert!(first.charge(limit, &file, Some(11)).is_err());
assert_eq!(first.bytes.get(), 24);
first
.work(1, &file, Some(3))
.expect("work is nonrefundable");
}
assert_eq!(meter.glob_bytes.get(), 16);
assert_eq!(meter.usage().work, 1);
let neighbor = Transient::new(&meter);
neighbor
.charge(limit - 16, &file, Some(12))
.expect("failed owners left no phantom reservation");
}
}
#[test]
fn retained_payload_moves_its_original_grant_without_readmission() {
let file = RelPath::new("src/imports.rs").expect("path");
let options = LoadOptions {
max_glob_bytes: 64,
..LoadOptions::default()
};
let meter = Meter::new(&options);
let owner = Transient::new(&meter);
owner.charge(16, &file, Some(1)).expect("batch storage");
{
let scratch = owner.child();
scratch.charge(48, &file, Some(2)).expect("exact peak");
scratch
.transfer_to(&owner, 24, &file, Some(2))
.expect("retained result");
assert_eq!(meter.glob_bytes.get(), 64);
assert_eq!(meter.usage().glob_bytes, 64);
assert!(scratch.transfer_to(&owner, 25, &file, Some(3)).is_err());
assert_eq!((scratch.bytes.get(), owner.bytes.get()), (24, 40));
let other_meter = Meter::new(&options);
let unrelated = Transient::new(&other_meter);
assert!(scratch.transfer_to(&unrelated, 1, &file, Some(4)).is_err());
assert_eq!(other_meter.glob_bytes.get(), 0);
}
assert_eq!(meter.glob_bytes.get(), 40);
owner
.charge(24, &file, Some(5))
.expect("released scratch is reusable");
assert!(owner.charge(1, &file, Some(6)).is_err());
drop(owner);
assert_eq!(meter.glob_bytes.get(), 0);
}
#[test]
fn native_emission_spill_preserves_cumulative_item_admission() {
let file = RelPath::new("src/lib.rs").expect("path");
let run = |count, limit| {
let meter = Meter::new(&LoadOptions {
max_item_bytes: limit,
max_glob_bytes: 0,
..LoadOptions::default()
});
let mut pending = purrdf_lex::walk::WorkList::<usize, 1>::new();
let mut result = Ok(());
for value in 0..count {
let live = pending.heap_capacity() * size_of::<usize>();
let mut admission = NativeAdmission::items(&meter, &file, Some(7), live);
result = pending
.try_push_admitted(value, &mut Memory::resume(&mut admission, live))
.map_err(|error| admission.graph_error(error.into()));
if result.is_err() {
break;
}
}
let spent = meter.usage().item_bytes;
drop(pending);
assert_eq!(meter.usage().item_bytes, spent, "items are cumulative");
assert_eq!(meter.usage().glob_bytes, 0);
(result, spent)
};
assert!(
run(1, 0).0.is_ok(),
"inline neighbor needs no item allocation"
);
let (result, spent) = run(33, usize::MAX);
result.expect("several native growths");
assert!(spent > 0);
assert!(run(33, spent).0.is_ok());
let (result, _) = run(33, spent - 1);
let error = result.expect_err("one item byte less");
assert_eq!((error.file.as_str(), error.line), ("src/lib.rs", Some(7)));
assert!(matches!(error.kind, LoadErrorKind::Budget {
budget: Budget::ItemBytes, limit,
} if limit == spent - 1));
}
#[test]
fn native_graph_storage_preserves_overlapping_grants_and_typed_refusals() {
let file = RelPath::new("src/imports.rs").expect("path");
let graph = [vec![1], vec![0, 2], vec![]];
let run = |limit| {
let meter = Meter::new(&LoadOptions {
max_glob_bytes: limit,
..LoadOptions::default()
});
let outer = Transient::new(&meter);
outer
.charge(17, &file, Some(2))
.expect("unrelated live payload");
{
let lease = outer.child();
let mut admission = NativeAdmission::new(Steps::LoadAt {
memory: &lease,
file: &file,
line: 7,
});
let result = purrdf_core::graph::tarjan_scc_with_memory(
&graph,
&mut Memory::new(&mut admission),
)
.map_err(|error| admission.graph_error(error));
match result {
Ok(components) => {
assert_eq!(components.len(), 2);
assert!(lease.bytes.get() > 0);
assert_eq!(meter.glob_bytes.get(), 17 + lease.bytes.get());
drop(components);
}
Err(error) => {
assert_eq!(
(error.file.as_str(), error.line),
("src/imports.rs", Some(7))
);
assert!(matches!(error.kind, LoadErrorKind::Budget {
budget: Budget::GlobBytes, limit: found,
} if found == limit));
assert_eq!(lease.bytes.get(), 0);
}
}
}
assert_eq!(meter.glob_bytes.get(), 17);
meter.usage().glob_bytes
};
let peak = run(usize::MAX);
assert!(peak > 17);
assert_eq!(run(peak), peak);
assert!(run(peak - 1) < peak);
}
}