Files
prometeu-runtime/crates/console/prometeu-vm/src/resource_budget.rs
T

533 lines
18 KiB
Rust

//! 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<Self, ResourceFailure> {
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<Mutex<State>>);
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<T>(
&self,
count: usize,
resource: RuntimeResource,
) -> Result<u64, ResourceFailure> {
count
.checked_mul(size_of::<T>())
.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<Reservation, ResourceFailure> {
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::<u64>::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::<u64>::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::<u64>(usize::MAX, AuxiliaryBytes).unwrap_err().reason,
ResourceReason::SizeOverflow
);
let mut queue = BudgetVec::<u64>::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::<u64>::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::<Vec<_>>());
assert_eq!(budget.used(AuxiliaryBytes), (values.capacity() * size_of::<u64>()) 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::<u64>::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<T> {
data: Vec<T>,
charge: Reservation,
}
impl<T> BudgetVec<T> {
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<Option<VecGrowth<T>>, 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<VecGrowth<T>, ResourceFailure> {
let b = &self.charge.budget;
let q = self.charge.resource;
let bytes = b.bytes::<T>(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::<T>(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<VecGrowth<T>>) {
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<Self, ResourceFailure>
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<T> {
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<usize>) -> 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<T> {
&mut self.data
}
}
impl<T> std::ops::Deref for BudgetVec<T> {
type Target = [T];
fn deref(&self) -> &[T] {
&self.data
}
}
impl<T> std::ops::DerefMut for BudgetVec<T> {
fn deref_mut(&mut self) -> &mut [T] {
&mut self.data
}
}
impl<'a, T> IntoIterator for &'a BudgetVec<T> {
type Item = &'a T;
type IntoIter = std::slice::Iter<'a, T>;
fn into_iter(self) -> Self::IntoIter {
self.data.iter()
}
}
#[cfg(test)]
impl<T: PartialEq> PartialEq<Vec<T>> for BudgetVec<T> {
fn eq(&self, other: &Vec<T>) -> bool {
&self.data == other
}
}
/// Unpublished growth can be dropped to refund every provisional reservation.
pub(crate) struct VecGrowth<T> {
candidate: Vec<T>,
extra: Reservation,
_temporary: Reservation,
old_capacity: usize,
}
#[cfg(test)]
thread_local! {
pub(crate) static FAIL_NEXT_VEC_ALLOCATION: std::cell::Cell<bool> = const { std::cell::Cell::new(false) };
}