//! Session accounting shared by owners, with reservations refunded on failure/drop. //! These quotas account VM domains, not process RSS or allocator metadata. use std::sync::{Arc, Mutex, MutexGuard}; pub use prometeu_bytecode::{ResourceFailure, ResourceReason, RuntimeResource}; const COUNT: usize = 8; const MIB: u64 = 1_048_576; const CEILINGS: [u64; COUNT] = [256 * MIB, 1_048_576, 64 * MIB, 64 * MIB, 64 * MIB, 262_144, 4 * MIB, 1_024]; #[derive(Debug, Clone, PartialEq, Eq)] pub struct RuntimeLimits([u64; COUNT]); impl Default for RuntimeLimits { fn default() -> Self { Self(CEILINGS) } } impl RuntimeLimits { pub fn get(&self, resource: RuntimeResource) -> u64 { self.0[resource as usize] } /// Test/host configurations may lower ceilings; guest code cannot raise them. pub fn lowered( mut self, resource: RuntimeResource, limit: u64, ) -> Result { if limit > self.get(resource) { return Err(ResourceFailure { resource, reason: ResourceReason::Limit, requested: limit, limit: self.get(resource), }); } self.0[resource as usize] = limit; Ok(self) } } #[derive(Debug)] struct State { limits: RuntimeLimits, used: [u64; COUNT], #[cfg(feature = "resource-diagnostics")] peaks: [u64; COUNT], #[cfg(feature = "resource-diagnostics")] refusals: [u64; COUNT], } #[derive(Debug, Clone)] pub struct RuntimeBudget(Arc>); impl Default for RuntimeBudget { fn default() -> Self { Self::new(RuntimeLimits::default()) } } impl RuntimeBudget { pub fn new(limits: RuntimeLimits) -> Self { Self(Arc::new(Mutex::new(State { limits, used: [0; COUNT], #[cfg(feature = "resource-diagnostics")] peaks: [0; COUNT], #[cfg(feature = "resource-diagnostics")] refusals: [0; COUNT], }))) } fn state(&self) -> MutexGuard<'_, State> { self.0.lock().unwrap_or_else(std::sync::PoisonError::into_inner) } pub(crate) fn limits(&self) -> RuntimeLimits { self.state().limits.clone() } #[cfg(test)] pub(crate) fn test_lower_limit(&self, resource: RuntimeResource, limit: u64) { self.state().limits.0[resource as usize] = limit; } pub fn used(&self, resource: RuntimeResource) -> u64 { self.state().used[resource as usize] } pub fn limit(&self, resource: RuntimeResource) -> u64 { self.state().limits.get(resource) } pub fn check(&self, resource: RuntimeResource, requested: u64) -> Result<(), ResourceFailure> { let limit = self.limit(resource); if requested > limit { Err(self.failure(resource, ResourceReason::Limit, requested)) } else { #[cfg(feature = "resource-diagnostics")] { let mut state = self.state(); state.peaks[resource as usize] = state.peaks[resource as usize].max(requested); } Ok(()) } } pub fn failure( &self, resource: RuntimeResource, reason: ResourceReason, requested: u64, ) -> ResourceFailure { #[cfg(feature = "resource-diagnostics")] { let mut state = self.state(); state.refusals[resource as usize] += 1; } ResourceFailure { resource, reason, requested, limit: self.limit(resource) } } pub fn bytes( &self, count: usize, resource: RuntimeResource, ) -> Result { count .checked_mul(size_of::()) .and_then(|bytes| u64::try_from(bytes).ok()) .ok_or_else(|| self.failure(resource, ResourceReason::SizeOverflow, u64::MAX)) } pub fn reserve( &self, resource: RuntimeResource, amount: u64, ) -> Result { let mut state = self.state(); let current = state.used[resource as usize]; let limit = state.limits.get(resource); let Some(requested) = current.checked_add(amount) else { #[cfg(feature = "resource-diagnostics")] { state.refusals[resource as usize] += 1; } return Err(ResourceFailure { resource, reason: ResourceReason::SizeOverflow, requested: u64::MAX, limit, }); }; if requested > limit { #[cfg(feature = "resource-diagnostics")] { state.refusals[resource as usize] += 1; } return Err(ResourceFailure { resource, reason: ResourceReason::Limit, requested, limit, }); } state.used[resource as usize] = requested; #[cfg(feature = "resource-diagnostics")] { state.peaks[resource as usize] = state.peaks[resource as usize].max(requested); } Ok(Reservation { budget: self.clone(), resource, amount }) } pub(crate) fn empty_charge(&self, resource: RuntimeResource) -> Reservation { Reservation { budget: self.clone(), resource, amount: 0 } } /// Engineering-only counters. Holding the budget does not retain guest owners. #[cfg(feature = "resource-diagnostics")] pub fn diagnostic_snapshot(&self) -> crate::resource_diagnostics::BudgetSnapshot { let state = self.state(); crate::resource_diagnostics::BudgetSnapshot { used: state.used, peaks: state.peaks, refusals: state.refusals, limits: state.limits.0, } } } /// Unique accounting ownership; moving this token never charges a second time. #[derive(Debug)] pub struct Reservation { budget: RuntimeBudget, resource: RuntimeResource, amount: u64, } impl Reservation { pub fn amount(&self) -> u64 { self.amount } pub(crate) fn absorb(&mut self, mut other: Self) { assert!(Arc::ptr_eq(&self.budget.0, &other.budget.0)); assert_eq!(self.resource, other.resource); self.amount += other.amount; other.amount = 0; } fn resize(&mut self, amount: u64) -> Result<(), ResourceFailure> { if amount > self.amount { self.absorb(self.budget.reserve(self.resource, amount - self.amount)?); } else { self.budget.state().used[self.resource as usize] -= self.amount - amount; self.amount = amount; } Ok(()) } } impl Drop for Reservation { fn drop(&mut self) { self.budget.state().used[self.resource as usize] -= self.amount; } } #[cfg(test)] mod tests { use super::*; use RuntimeResource::*; #[test] fn accepted_limits_are_fixed_and_can_only_be_lowered() { let limits = RuntimeLimits::default(); for (resource, expected) in [ (GuestBytes, 268_435_456), (HandleSlots, 1_048_576), (AuxiliaryBytes, 67_108_864), (TemporaryBytes, 67_108_864), (StringBytes, 67_108_864), (StringAllocations, 262_144), (IndividualStringBytes, 4_194_304), (CallDepth, 1_024), ] { assert_eq!(limits.get(resource), expected); assert!(limits.clone().lowered(resource, expected + 1).is_err()); assert_eq!(limits.clone().lowered(resource, 0).unwrap().get(resource), 0); } } #[test] fn shared_reservations_refund_on_failure_and_follow_their_owner() { let budget = RuntimeBudget::new(RuntimeLimits::default().lowered(GuestBytes, 10).unwrap()); let charge = budget.reserve(GuestBytes, 7).unwrap(); let shared = budget.clone(); let failure = shared.reserve(GuestBytes, 4).unwrap_err(); assert_eq!((failure.resource, failure.requested, failure.limit), (GuestBytes, 11, 10)); assert_eq!(budget.used(GuestBytes), 7); let transferred = charge; assert_eq!(shared.used(GuestBytes), 7); let tail = shared.reserve(GuestBytes, 3).unwrap(); assert_eq!(shared.used(GuestBytes), 10); drop(transferred); assert_eq!(shared.used(GuestBytes), 3); drop(tail); assert_eq!(shared.used(GuestBytes), 0); } #[test] fn stack_capacity_is_retained_until_drop_and_transfer_does_not_charge_twice() { let budget = RuntimeBudget::new(RuntimeLimits::default().lowered(AuxiliaryBytes, 16).unwrap()); let mut queue = BudgetVec::::new(&budget, RuntimeResource::AuxiliaryBytes); queue.push(11).unwrap(); queue.push(22).unwrap(); assert_eq!(budget.used(AuxiliaryBytes), 16); assert!(queue.push(33).is_err()); assert_eq!(queue.pop(), Some(22)); assert_eq!(budget.used(AuxiliaryBytes), 16); queue.push(44).unwrap(); // reuse retained capacity let mut moved = queue; assert_eq!(budget.used(AuxiliaryBytes), 16); assert_eq!(moved.pop(), Some(44)); assert_eq!(moved.pop(), Some(11)); drop(moved); assert_eq!(budget.used(AuxiliaryBytes), 0); assert_eq!(budget.used(TemporaryBytes), 0); } #[test] fn temporary_growth_refusal_keeps_old_buffer_and_refunds_provisional_charge() { let limits = RuntimeLimits::default() .lowered(AuxiliaryBytes, 16) .unwrap() .lowered(TemporaryBytes, 0) .unwrap(); let budget = RuntimeBudget::new(limits); let mut queue = BudgetVec::::new(&budget, RuntimeResource::AuxiliaryBytes); queue.push(11).unwrap(); let error = queue.push(22).unwrap_err(); assert_eq!((error.resource, error.requested), (TemporaryBytes, 8)); assert_eq!(budget.used(AuxiliaryBytes), 8); assert_eq!(queue.pop(), Some(11)); assert_eq!(queue.pop(), None); assert_eq!(budget.used(TemporaryBytes), 0); } #[test] fn size_and_length_overflow_fail_before_growth() { let budget = RuntimeBudget::default(); assert_eq!( budget.bytes::(usize::MAX, AuxiliaryBytes).unwrap_err().reason, ResourceReason::SizeOverflow ); let mut queue = BudgetVec::::new(&budget, RuntimeResource::AuxiliaryBytes); queue.push(11).unwrap(); assert_eq!(queue.reserve(usize::MAX).unwrap_err().reason, ResourceReason::SizeOverflow); assert_eq!(budget.used(AuxiliaryBytes), 8); assert_eq!(queue.pop(), Some(11)); } #[test] fn incremental_growth_moves_a_linear_number_of_elements() { let budget = RuntimeBudget::default(); let mut values = BudgetVec::::new(&budget, AuxiliaryBytes); let mut moved = 0; let count = 16_000; for value in 0..count { let capacity = values.capacity(); values.push(value as u64).unwrap(); if values.capacity() != capacity { moved += value; } } assert!(moved < 2 * count, "moved {moved} elements for {count} pushes"); assert_eq!(values.as_slice(), (0..count as u64).collect::>()); assert_eq!(budget.used(AuxiliaryBytes), (values.capacity() * size_of::()) as u64); assert_eq!(budget.used(TemporaryBytes), 0); } #[test] fn growth_falls_back_to_exact_capacity_at_shared_and_coexistence_limits() { for resource in [AuxiliaryBytes, TemporaryBytes] { let limit = if resource == TemporaryBytes { 72 } else { 40 }; let budget = RuntimeBudget::new(RuntimeLimits::default().lowered(resource, limit).unwrap()); let mut values = BudgetVec::::new(&budget, resource); for value in 0..5 { values.push(value).unwrap(); } assert_eq!(values.as_slice(), &[0, 1, 2, 3, 4]); assert_eq!(values.capacity(), 5); assert_eq!(budget.used(resource), 40); assert!(values.push(5).is_err()); assert_eq!(values.as_slice(), &[0, 1, 2, 3, 4]); assert_eq!(budget.used(resource), 40); drop(values); assert_eq!(budget.used(resource), 0); assert_eq!(budget.used(TemporaryBytes), 0); } } } /// Contiguous execution storage. The capacity reservation travels with the buffer /// across ordinary calls; charges are refunded only when storage is dropped. #[derive(Debug)] pub struct BudgetVec { data: Vec, charge: Reservation, } impl BudgetVec { pub fn new(budget: &RuntimeBudget, resource: RuntimeResource) -> Self { Self { data: Vec::new(), charge: budget.empty_charge(resource) } } pub(crate) fn prepare_growth( &self, additional: usize, ) -> Result>, ResourceFailure> { let b = &self.charge.budget; let q = self.charge.resource; let required = self .data .len() .checked_add(additional) .ok_or_else(|| b.failure(q, ResourceReason::SizeOverflow, u64::MAX))?; if required <= self.data.capacity() { return Ok(None); } // Amortize incremental growth while keeping exact admission available // when spare capacity would exceed a shared or temporary quota. let preferred = required.max(self.data.capacity().saturating_mul(2)); if preferred > required && let Ok(growth) = self.prepare_capacity(preferred) { return Ok(Some(growth)); } self.prepare_capacity(required).map(Some) } fn prepare_capacity(&self, capacity: usize) -> Result, ResourceFailure> { let b = &self.charge.budget; let q = self.charge.resource; let bytes = b.bytes::(capacity, q)?; let mut extra = b.reserve(q, bytes - self.charge.amount)?; let temporary = b.reserve(RuntimeResource::TemporaryBytes, self.charge.amount)?; #[cfg(test)] if FAIL_NEXT_VEC_ALLOCATION.with(|fail| fail.replace(false)) { return Err(b.failure(q, ResourceReason::AllocationFailed, bytes)); } let mut candidate = Vec::new(); candidate .try_reserve_exact(capacity) .map_err(|_| b.failure(q, ResourceReason::AllocationFailed, bytes))?; extra.resize(b.bytes::(candidate.capacity(), q)? - self.charge.amount)?; Ok(VecGrowth { candidate, extra, _temporary: temporary, old_capacity: self.data.capacity(), }) } pub(crate) fn commit_growth(&mut self, growth: Option>) { if let Some(mut growth) = growth { assert_eq!(self.data.capacity(), growth.old_capacity); growth.candidate.append(&mut self.data); self.data = growth.candidate; self.charge.absorb(growth.extra); } } /// Rebuild a table with all fallible capacity/coexistence admission completed /// before moving any old entry. The relocation callback must not allocate. pub(crate) fn rebuild_with( &mut self, len: usize, vacant: impl FnMut() -> T, relocate: impl FnOnce(&mut [T], &mut [T]), ) -> Result<(), ResourceFailure> { let mut growth = self.prepare_capacity(len.max(self.data.capacity()))?; growth.candidate.resize_with(len, vacant); relocate(&mut self.data, &mut growth.candidate); self.data = growth.candidate; self.charge.absorb(growth.extra); Ok(()) } pub fn reserve(&mut self, additional: usize) -> Result<(), ResourceFailure> { let growth = self.prepare_growth(additional)?; self.commit_growth(growth); Ok(()) } pub(crate) fn accounted_bytes(&self) -> u64 { self.charge.amount } pub(crate) fn from_slice( budget: &RuntimeBudget, resource: RuntimeResource, values: &[T], ) -> Result where T: Clone, { let mut result = Self::new(budget, resource); result.reserve(values.len())?; result.data.extend_from_slice(values); Ok(result) } pub fn push(&mut self, value: T) -> Result<(), ResourceFailure> { self.reserve(1)?; self.data.push(value); Ok(()) } pub fn resize(&mut self, len: usize, value: T) -> Result<(), ResourceFailure> where T: Clone, { self.reserve(len.saturating_sub(self.data.len()))?; self.data.resize(len, value); Ok(()) } pub fn pop(&mut self) -> Option { self.data.pop() } pub fn clear(&mut self) { self.data.clear(); } pub(crate) fn extend_from_slice(&mut self, values: &[T]) -> Result<(), ResourceFailure> where T: Clone, { self.reserve(values.len())?; self.data.extend_from_slice(values); Ok(()) } pub fn truncate(&mut self, len: usize) { self.data.truncate(len); } pub fn capacity(&self) -> usize { self.data.capacity() } pub fn as_slice(&self) -> &[T] { &self.data } pub fn drain(&mut self, range: impl std::ops::RangeBounds) -> std::vec::Drain<'_, T> { self.data.drain(range) } pub fn take(&mut self) -> Self { let empty = Self::new(&self.charge.budget, self.charge.resource); std::mem::replace(self, empty) } /// Only used with the bounded native result writer after reserving its result slots. pub(crate) fn native_result_buffer(&mut self) -> &mut Vec { &mut self.data } } impl std::ops::Deref for BudgetVec { type Target = [T]; fn deref(&self) -> &[T] { &self.data } } impl std::ops::DerefMut for BudgetVec { fn deref_mut(&mut self) -> &mut [T] { &mut self.data } } impl<'a, T> IntoIterator for &'a BudgetVec { type Item = &'a T; type IntoIter = std::slice::Iter<'a, T>; fn into_iter(self) -> Self::IntoIter { self.data.iter() } } #[cfg(test)] impl PartialEq> for BudgetVec { fn eq(&self, other: &Vec) -> bool { &self.data == other } } /// Unpublished growth can be dropped to refund every provisional reservation. pub(crate) struct VecGrowth { candidate: Vec, extra: Reservation, _temporary: Reservation, old_capacity: usize, } #[cfg(test)] thread_local! { pub(crate) static FAIL_NEXT_VEC_ALLOCATION: std::cell::Cell = const { std::cell::Cell::new(false) }; }