feat(vm)!: implement typed callables and single-context execution
Intrepid/Prometeu/Runtime/pipeline/pr-master This commit looks good
Intrepid/Prometeu/Runtime/pipeline/pr-master This commit looks good
Add structural Fn signatures, typed capture environments, indirect calls and Trait dispatch while preserving logical parameter and result groups, ownership and budgets. Remove guest coroutine execution and legacy loading. Activate bounded sealed PBX v1 with mandatory capture metadata, preserve frame continuations and root return results, and migrate producers and shipped cartridges. Publish coordinated specs, handoffs and the completed runtime lesson. Validation: 880 workspace tests passed, 9 existing tests ignored; both cartridges completed six production-host frames.
This commit is contained in:
@@ -1,6 +1,5 @@
|
||||
//! Session accounting shared by owners, with reservations refunded on failure/drop.
|
||||
//! These quotas account VM domains, not process RSS or allocator metadata.
|
||||
use std::collections::VecDeque;
|
||||
use std::sync::{Arc, Mutex, MutexGuard};
|
||||
|
||||
pub use prometeu_bytecode::{ResourceFailure, ResourceReason, RuntimeResource};
|
||||
@@ -58,6 +57,9 @@ impl RuntimeBudget {
|
||||
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;
|
||||
@@ -157,74 +159,6 @@ impl Drop for Reservation {
|
||||
}
|
||||
}
|
||||
|
||||
/// Scheduler storage owns its capacity charge, including unused capacity.
|
||||
/// During growth, the old allocation is also covered by a temporary reservation.
|
||||
#[derive(Debug)]
|
||||
pub(crate) struct BudgetQueue<T> {
|
||||
data: VecDeque<T>,
|
||||
charge: Reservation,
|
||||
}
|
||||
impl<T> BudgetQueue<T> {
|
||||
#[cfg(test)]
|
||||
pub(crate) fn capacity_bytes(&self) -> u64 {
|
||||
self.charge.amount
|
||||
}
|
||||
|
||||
pub fn new(budget: &RuntimeBudget) -> Self {
|
||||
Self { data: VecDeque::new(), charge: budget.empty_charge(RuntimeResource::AuxiliaryBytes) }
|
||||
}
|
||||
#[cfg(test)]
|
||||
pub fn len(&self) -> usize {
|
||||
self.data.len()
|
||||
}
|
||||
pub fn is_empty(&self) -> bool {
|
||||
self.data.is_empty()
|
||||
}
|
||||
pub fn pop_front(&mut self) -> Option<T> {
|
||||
self.data.pop_front()
|
||||
}
|
||||
pub fn reserve(&mut self, additional: usize) -> Result<(), ResourceFailure> {
|
||||
let b = &self.charge.budget;
|
||||
let q = RuntimeResource::AuxiliaryBytes;
|
||||
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(());
|
||||
}
|
||||
// Exact growth prevents a geometric allocation from exceeding the available quota.
|
||||
let bytes = b.bytes::<T>(required, q)?;
|
||||
let mut extra = b.reserve(q, bytes - self.charge.amount)?;
|
||||
let _temporary = b.reserve(RuntimeResource::TemporaryBytes, self.charge.amount)?;
|
||||
let mut candidate = VecDeque::new();
|
||||
candidate
|
||||
.try_reserve_exact(required)
|
||||
.map_err(|_| b.failure(q, ResourceReason::AllocationFailed, bytes))?;
|
||||
let actual = b.bytes::<T>(candidate.capacity(), q)?;
|
||||
// If the allocator reports excess capacity, reject before publishing the new buffer.
|
||||
extra.resize(actual - self.charge.amount)?;
|
||||
candidate.append(&mut self.data);
|
||||
self.data = candidate;
|
||||
self.charge.absorb(extra);
|
||||
Ok(())
|
||||
}
|
||||
pub fn push_back(&mut self, value: T) -> Result<(), ResourceFailure> {
|
||||
self.reserve(1)?;
|
||||
self.data.push_back(value);
|
||||
Ok(())
|
||||
}
|
||||
pub fn insert(&mut self, index: usize, value: T) -> Result<(), ResourceFailure> {
|
||||
self.reserve(1)?;
|
||||
self.data.insert(index, value);
|
||||
Ok(())
|
||||
}
|
||||
pub fn partition_point(&self, predicate: impl FnMut(&T) -> bool) -> usize {
|
||||
self.data.partition_point(predicate)
|
||||
}
|
||||
}
|
||||
|
||||
#[cfg(test)]
|
||||
mod tests {
|
||||
use super::*;
|
||||
@@ -268,21 +202,21 @@ mod tests {
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn queue_capacity_is_retained_until_drop_and_transfer_does_not_charge_twice() {
|
||||
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 = BudgetQueue::<u64>::new(&budget);
|
||||
queue.push_back(11).unwrap();
|
||||
queue.push_back(22).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_back(33).is_err());
|
||||
assert_eq!(queue.pop_front(), Some(11));
|
||||
assert!(queue.push(33).is_err());
|
||||
assert_eq!(queue.pop(), Some(22));
|
||||
assert_eq!(budget.used(AuxiliaryBytes), 16);
|
||||
queue.push_back(44).unwrap(); // reuse retained capacity
|
||||
queue.push(44).unwrap(); // reuse retained capacity
|
||||
let mut moved = queue;
|
||||
assert_eq!(budget.used(AuxiliaryBytes), 16);
|
||||
assert_eq!(moved.pop_front(), Some(22));
|
||||
assert_eq!(moved.pop_front(), Some(44));
|
||||
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);
|
||||
@@ -296,13 +230,13 @@ mod tests {
|
||||
.lowered(TemporaryBytes, 0)
|
||||
.unwrap();
|
||||
let budget = RuntimeBudget::new(limits);
|
||||
let mut queue = BudgetQueue::<u64>::new(&budget);
|
||||
queue.push_back(11).unwrap();
|
||||
let error = queue.push_back(22).unwrap_err();
|
||||
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_front(), Some(11));
|
||||
assert_eq!(queue.pop_front(), None);
|
||||
assert_eq!(queue.pop(), Some(11));
|
||||
assert_eq!(queue.pop(), None);
|
||||
assert_eq!(budget.used(TemporaryBytes), 0);
|
||||
}
|
||||
|
||||
@@ -313,16 +247,16 @@ mod tests {
|
||||
budget.bytes::<u64>(usize::MAX, AuxiliaryBytes).unwrap_err().reason,
|
||||
ResourceReason::SizeOverflow
|
||||
);
|
||||
let mut queue = BudgetQueue::<u64>::new(&budget);
|
||||
queue.push_back(11).unwrap();
|
||||
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_front(), Some(11));
|
||||
assert_eq!(queue.pop(), Some(11));
|
||||
}
|
||||
}
|
||||
|
||||
/// Contiguous execution storage. The capacity reservation travels with the buffer
|
||||
/// when a coroutine suspends/resumes, and is refunded only when storage is dropped.
|
||||
/// across ordinary calls; charges are refunded only when storage is dropped.
|
||||
#[derive(Debug)]
|
||||
pub struct BudgetVec<T> {
|
||||
data: Vec<T>,
|
||||
@@ -440,13 +374,6 @@ impl<T> BudgetVec<T> {
|
||||
pub(crate) fn native_result_buffer(&mut self) -> &mut Vec<T> {
|
||||
&mut self.data
|
||||
}
|
||||
#[cfg(test)]
|
||||
pub(crate) fn fixture(data: Vec<T>) -> Self {
|
||||
let budget = RuntimeBudget::default();
|
||||
let bytes = budget.bytes::<T>(data.capacity(), RuntimeResource::AuxiliaryBytes).unwrap();
|
||||
let charge = budget.reserve(RuntimeResource::AuxiliaryBytes, bytes).unwrap();
|
||||
Self { data, charge }
|
||||
}
|
||||
}
|
||||
impl<T> std::ops::Deref for BudgetVec<T> {
|
||||
type Target = [T];
|
||||
|
||||
Reference in New Issue
Block a user