feat(vm)!: implement typed callables and single-context execution
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:
2026-10-09 05:47:24 +01:00
parent 86bade3e1f
commit ec84a6bba5
96 changed files with 3656 additions and 6075 deletions
@@ -3,4 +3,6 @@ pub struct CallFrame {
pub return_pc: u32,
pub stack_base: usize,
pub func_idx: usize,
/// Active Fn owner; keeps the immutable environment alive until return.
pub closure: Option<prometeu_bytecode::HeapRef>,
}
+30 -204
View File
@@ -1,5 +1,4 @@
mod dynamic_box;
use crate::call_frame::CallFrame;
use crate::object::{ObjectHeader, ObjectKind};
use crate::resource_budget::{
BudgetVec, Reservation, ResourceFailure, ResourceReason, RuntimeBudget, RuntimeResource as Q,
@@ -30,8 +29,6 @@ pub struct StoredObject {
/// they stay directly GC-visible. The GC must traverse exactly `env_len`
/// entries from this slice, in order.
pub closure_env: Option<BudgetVec<Value>>,
/// Optional coroutine data for `ObjectKind::Coroutine`.
pub coroutine: Option<CoroutineData>,
/// Registry-backed compact Struct/Array fields, never raw Value elements.
typed: Option<TypedStorage>,
/// Immutable native Value slots; not accessible through collection helpers.
@@ -76,26 +73,6 @@ struct PreparedSlot {
free: Option<VecGrowth<usize>>,
}
/// Execution state of a coroutine.
#[derive(Debug, Copy, Clone, Eq, PartialEq)]
pub enum CoroutineState {
Ready,
Running,
Sleeping,
Finished,
// Faulted,
}
/// Stored payload for coroutine objects.
#[derive(Debug)]
pub struct CoroutineData {
pub pc: usize,
pub state: CoroutineState,
pub wake_tick: u64,
pub stack: BudgetVec<Value>,
pub frames: BudgetVec<CallFrame>,
}
/// Non-moving, generation-checked heap with safepoint mark/sweep.
#[derive(Debug)]
pub struct Heap {
@@ -127,25 +104,6 @@ impl Heap {
self.used_bytes.fetch_sub(old, Ordering::Relaxed);
self.used_bytes.fetch_add(new, Ordering::Relaxed);
}
#[cfg(test)]
pub(crate) fn table_capacity_bytes(&self) -> u64 {
self.objects.accounted_bytes()
+ self.generations.accounted_bytes()
+ self.free_list.accounted_bytes()
}
#[cfg(test)]
pub(crate) fn execution_capacity_bytes(&self) -> u64 {
self.objects
.iter()
.flatten()
.filter_map(|object| object.coroutine.as_ref())
.map(|co| {
(co.stack.capacity() * size_of::<Value>()
+ co.frames.capacity() * size_of::<CallFrame>()) as u64
})
.sum()
}
#[cfg(test)]
pub fn new() -> Self {
@@ -233,7 +191,6 @@ impl Heap {
payload,
array_elems: None,
closure_env: None,
coroutine: None,
typed: None,
dynamic_box: None,
})
@@ -249,7 +206,6 @@ impl Heap {
payload: BudgetVec::new(&self.budget, Q::GuestBytes),
array_elems: Some(elems),
closure_env: None,
coroutine: None,
typed: None,
dynamic_box: None,
})
@@ -261,44 +217,25 @@ impl Heap {
})
}
pub fn alloc_closure(
pub(crate) fn alloc_typed_closure(
&mut self,
fn_id: u32,
fn_type: TypeId,
env_values: &[Value],
) -> Result<HeapRef, ResourceFailure> {
self.check_slot()?;
let env_len = self.payload_len(env_values.len())?;
let mut bytes = [0; 8];
let mut bytes = [0; 12];
bytes[..4].copy_from_slice(&fn_id.to_le_bytes());
bytes[4..].copy_from_slice(&env_len.to_le_bytes());
bytes[4..8].copy_from_slice(&env_len.to_le_bytes());
bytes[8..12].copy_from_slice(&fn_type.0.to_le_bytes());
let payload = BudgetVec::from_slice(&self.budget, Q::GuestBytes, &bytes)?;
let env = BudgetVec::from_slice(&self.budget, Q::GuestBytes, env_values)?;
self.insert_object(StoredObject {
header: ObjectHeader::new(ObjectKind::Closure, 8),
header: ObjectHeader::new(ObjectKind::Closure, 12),
payload,
array_elems: None,
closure_env: Some(env),
coroutine: None,
typed: None,
dynamic_box: None,
})
}
pub fn allocate_coroutine(
&mut self,
pc: usize,
state: CoroutineState,
wake_tick: u64,
stack: BudgetVec<Value>,
frames: BudgetVec<CallFrame>,
) -> Result<HeapRef, ResourceFailure> {
self.check_slot()?;
self.insert_object(StoredObject {
header: ObjectHeader::new(ObjectKind::Coroutine, 0),
payload: BudgetVec::new(&self.budget, Q::GuestBytes),
array_elems: None,
closure_env: None,
coroutine: Some(CoroutineData { pc, state, wake_tick, stack, frames }),
typed: None,
dynamic_box: None,
})
@@ -313,28 +250,6 @@ impl Heap {
r.generation != 0 && self.generations[idx] == r.generation && self.objects[idx].is_some()
}
/// Returns a shared reference to the coroutine data for the given handle, if it is a Coroutine.
#[cfg(test)]
pub fn coroutine_data(&self, r: HeapRef) -> Option<&CoroutineData> {
if !self.is_valid(r) {
return None;
}
let idx = r.index as usize;
self.objects.get(idx).and_then(|slot| slot.as_ref()).and_then(|obj| obj.coroutine.as_ref())
}
/// Returns a mutable reference to the coroutine data for the given handle, if it is a Coroutine.
pub fn coroutine_data_mut(&mut self, r: HeapRef) -> Option<&mut CoroutineData> {
if !self.is_valid(r) {
return None;
}
let idx = r.index as usize;
self.objects
.get_mut(idx)
.and_then(|slot| slot.as_mut())
.and_then(|obj| obj.coroutine.as_mut())
}
/// Get immutable access to an object's header by handle.
pub fn header(&self, r: HeapRef) -> Option<&ObjectHeader> {
if !self.is_valid(r) {
@@ -351,6 +266,22 @@ impl Heap {
self.objects.get_mut(r.index as usize).and_then(|slot| slot.as_mut()).map(|o| &mut o.header)
}
pub(crate) fn closure_type(&self, r: HeapRef) -> Result<TypeId, ValueError> {
if !self.is_valid(r) {
return Err(ValueError::InvalidHandle);
}
let object = self.objects[r.index as usize].as_ref().unwrap();
if object.header.kind != ObjectKind::Closure || object.payload.len() != 12 {
return Err(ValueError::Type);
}
Ok(TypeId(u32::from_le_bytes(object.payload[8..12].try_into().unwrap())))
}
#[cfg(test)]
pub fn alloc_closure(&mut self, fn_id: u32, env: &[Value]) -> Result<HeapRef, ResourceFailure> {
self.alloc_typed_closure(fn_id, TypeId(0), env)
}
/// Read the `fn_id` stored in a closure object. Returns None if kind mismatch or invalid ref.
pub fn closure_fn_id(&self, r: HeapRef) -> Option<u32> {
if !self.is_valid(r) {
@@ -364,15 +295,14 @@ impl Heap {
if slot.payload.len() < 8 {
return None;
}
debug_assert_eq!(slot.header.payload_len, 8);
debug_assert_eq!(slot.header.payload_len, 12);
let mut bytes = [0u8; 4];
bytes.copy_from_slice(&slot.payload[0..4]);
Some(u32::from_le_bytes(bytes))
}
/// Get the captured environment slice of a closure. Returns None if kind mismatch or invalid ref.
#[cfg(test)]
pub fn closure_env_slice(&self, r: HeapRef) -> Option<&[Value]> {
pub(crate) fn closure_env_slice(&self, r: HeapRef) -> Option<&[Value]> {
if !self.is_valid(r) {
return None;
}
@@ -399,14 +329,14 @@ impl Heap {
&mut self,
roots: I,
) -> Result<(), ResourceFailure> {
self.mark(roots, false)
self.mark(roots)
}
pub fn mark_session_roots<I: IntoIterator<Item = HeapRef>>(
&mut self,
roots: I,
) -> Result<(), ResourceFailure> {
self.mark(roots, true)
self.mark(roots)
}
fn enqueue_mark(&mut self, r: HeapRef, stack: &mut BudgetVec<HeapRef>) {
@@ -425,35 +355,16 @@ impl Heap {
ObjectKind::Array => obj.array_elems.as_deref().unwrap_or(&[]),
ObjectKind::Closure => obj.closure_env.as_deref().unwrap_or(&[]),
ObjectKind::DynamicBox => obj.dynamic_box.as_ref().map_or(&[], DynamicBox::values),
ObjectKind::Coroutine => obj.coroutine.as_ref().map_or(&[], |co| co.stack.as_slice()),
_ => &[],
}
}
fn mark<I: IntoIterator<Item = HeapRef>>(
&mut self,
roots: I,
suspended: bool,
) -> Result<(), ResourceFailure> {
fn mark<I: IntoIterator<Item = HeapRef>>(&mut self, roots: I) -> Result<(), ResourceFailure> {
let mut stack = BudgetVec::new(&self.budget, Q::TemporaryBytes);
stack.reserve(self.len())?; // Fail before changing any mark bit.
for root in roots {
self.enqueue_mark(root, &mut stack);
}
if suspended {
for idx in 0..self.objects.len() {
let root =
self.objects[idx].as_ref().and_then(|o| o.coroutine.as_ref()).is_some_and(
|co| matches!(co.state, CoroutineState::Ready | CoroutineState::Sleeping),
);
if root {
self.enqueue_mark(
HeapRef { index: idx as u32, generation: self.generations[idx] },
&mut stack,
);
}
}
}
while let Some(r) = stack.pop() {
let typed_count = self.objects[r.index as usize]
.as_ref()
@@ -515,18 +426,6 @@ impl Heap {
pub fn allocation_count(&self) -> u64 {
self.allocation_count.load(Ordering::Relaxed)
}
/// Enumerate handles of coroutines that are currently suspended (i.e., not running):
/// Ready or Sleeping. These must be treated as GC roots by the runtime so their
/// stacks/frames are scanned during mark.
#[cfg(test)]
pub fn suspended_coroutine_handles(&self) -> impl Iterator<Item = HeapRef> + '_ {
self.objects.iter().enumerate().filter_map(|(idx, slot)| {
let co = slot.as_ref()?.coroutine.as_ref()?;
matches!(co.state, CoroutineState::Ready | CoroutineState::Sleeping)
.then_some(HeapRef { index: idx as u32, generation: self.generations[idx] })
})
}
}
// Internal consumer seam for PLN-0176 step 18 / AGD-0054. Executable image
@@ -598,7 +497,6 @@ impl Heap {
payload: BudgetVec::new(&self.budget, Q::GuestBytes),
array_elems: None,
closure_env: None,
coroutine: None,
typed: Some(storage),
dynamic_box: None,
},
@@ -656,7 +554,6 @@ impl Heap {
payload: BudgetVec::new(&self.budget, Q::GuestBytes),
array_elems: None,
closure_env: None,
coroutine: None,
typed: None,
dynamic_box: Some(dynamic_box),
})?)
@@ -750,38 +647,6 @@ mod tests {
assert_eq!(heap.generations[last.index as usize], u32::MAX);
}
#[test]
fn null_zero_generation_and_dead_coroutine_handles_are_rejected() {
let mut heap = Heap::new();
let old = heap
.allocate_coroutine(
0,
CoroutineState::Ready,
0,
BudgetVec::fixture(vec![]),
BudgetVec::fixture(vec![]),
)
.unwrap();
assert!(!heap.is_valid(HeapRef::NULL));
assert!(!heap.is_valid(HeapRef { index: 1, generation: 0 }));
assert!(!heap.is_valid(HeapRef { index: u32::MAX, generation: 1 }));
heap.sweep();
let next = heap
.allocate_coroutine(
2,
CoroutineState::Ready,
0,
BudgetVec::fixture(vec![]),
BudgetVec::fixture(vec![]),
)
.unwrap();
assert!(heap.coroutine_data(old).is_none());
assert!(heap.coroutine_data_mut(old).is_none());
assert_eq!(heap.suspended_coroutine_handles().collect::<Vec<_>>(), vec![next]);
assert_eq!(size_of::<HeapRef>(), 8);
assert_eq!(align_of::<HeapRef>(), 8);
}
#[test]
fn basic_allocation_returns_valid_refs() {
let mut heap = Heap::new();
@@ -808,45 +673,6 @@ mod tests {
assert_eq!(h3.payload_len, 0);
}
#[test]
fn allocate_and_transition_coroutine() {
let mut heap = Heap::new();
// Create a coroutine with a small stack containing a HeapRef to verify GC traversal later.
let obj_ref = heap.allocate_object(ObjectKind::Bytes, &[4, 5, 6]).unwrap();
let coro = heap
.allocate_coroutine(
0,
CoroutineState::Ready,
0,
BudgetVec::fixture(vec![Value::Int32(1), Value::HeapRef(obj_ref)]),
BudgetVec::fixture(vec![CallFrame { return_pc: 0, stack_base: 0, func_idx: 0 }]),
)
.unwrap();
let hdr = heap.header(coro).unwrap();
assert_eq!(hdr.kind, ObjectKind::Coroutine);
assert_eq!(hdr.payload_len, 0);
// Manually mutate state transitions via access to inner data.
{
let slot = heap.objects.get_mut(coro.index as usize).and_then(|s| s.as_mut()).unwrap();
let co = slot.coroutine.as_mut().unwrap();
assert_eq!(co.state, CoroutineState::Ready);
co.state = CoroutineState::Running;
assert_eq!(co.state, CoroutineState::Running);
co.state = CoroutineState::Sleeping;
co.wake_tick = 42;
assert_eq!(co.wake_tick, 42);
co.state = CoroutineState::Finished;
assert_eq!(co.state, CoroutineState::Finished);
}
// GC should mark the object referenced from the coroutine stack when the coroutine is a root.
heap.mark_from_roots([coro]).unwrap();
assert!(heap.header(obj_ref).unwrap().is_marked());
}
#[test]
fn mark_reachable_through_array() {
let mut heap = Heap::new();
@@ -910,7 +736,7 @@ mod tests {
let h = heap.header(c).unwrap();
assert_eq!(h.kind, ObjectKind::Closure);
// payload has only metadata (8 bytes)
assert_eq!(h.payload_len, 8);
assert_eq!(h.payload_len, 12);
assert_eq!(heap.closure_fn_id(c), Some(42));
let env = heap.closure_env_slice(c).unwrap();
assert_eq!(env.len(), 0);
@@ -925,7 +751,7 @@ mod tests {
let h = heap.header(c).unwrap();
assert_eq!(h.kind, ObjectKind::Closure);
assert_eq!(h.payload_len, 8);
assert_eq!(h.payload_len, 12);
assert_eq!(heap.closure_fn_id(c), Some(7));
let env = heap.closure_env_slice(c).unwrap();
assert_eq!(env, &env_vals[..]);
@@ -1146,7 +972,7 @@ mod tests {
#[test]
fn guest_header_and_payload_limits_refund_failed_construction() {
let required = (size_of::<StoredObject>() + 8 + size_of::<Value>()) as u64;
let required = (size_of::<StoredObject>() + 12 + size_of::<Value>()) as u64;
let (mut heap, budget) = tiny_heap(Q::GuestBytes, required - 1);
assert_eq!(heap.alloc_closure(0, &[Value::Int64(9)]).unwrap_err().resource, Q::GuestBytes);
for q in [Q::GuestBytes, Q::HandleSlots, Q::AuxiliaryBytes, Q::TemporaryBytes] {
@@ -33,7 +33,6 @@ fn forge_box(heap: &mut Heap, registry: Arc<Registry>, ty: TypeId, values: &[Val
payload: BudgetVec::new(&heap.budget, Q::GuestBytes),
array_elems: None,
closure_env: None,
coroutine: None,
typed: None,
dynamic_box: Some(dynamic_box),
})
-1
View File
@@ -14,7 +14,6 @@ mod roots;
mod program_image;
#[allow(dead_code)]
mod registry_verifier;
mod scheduler;
pub use program_image::{ImageStringLease, ValidatedProgramImage};
// Image/session creation and native provenance consume this in step 19.
#[allow(dead_code)]
@@ -1,5 +1,5 @@
use crate::call_frame::CallFrame;
use prometeu_bytecode::FunctionMeta;
use prometeu_bytecode::ExecutionFunction;
use prometeu_bytecode::{TRAP_INVALID_LOCAL, TrapInfo};
// /// Computes the absolute stack index for the start of the current frame's locals (including args).
@@ -15,7 +15,7 @@ pub fn local_index(frame: &CallFrame, slot: u32) -> usize {
/// Validates that a local slot index is within the valid range for the function.
/// Range: 0 <= slot < (param_slots + local_slots)
pub fn check_local_slot(
meta: &FunctionMeta,
meta: &ExecutionFunction,
slot: u32,
opcode: u16,
pc: u32,
+6 -14
View File
@@ -26,15 +26,15 @@
//! defined by each object kind; the GC treats it as an opaque metadata field.
//!
//! Closure-specific note: for `ObjectKind::Closure`, `payload_len` is the
//! fixed size `8` and the payload layout is exactly two little-endian `u32`s:
//! `[fn_id][env_len]`. The captured environment values themselves are NOT in
//! fixed size `12` and the payload layout is exactly three little-endian `u32`s:
//! `[fn_id][env_len][FnTypeId]`. The captured environment values themselves are NOT in
//! the raw payload; they live in a separate GC-visible area managed by the
//! heap (see `Heap`), and the GC must traverse exactly `env_len` values from
//! that environment slice.
//!
//! Notes:
//! - The GC only relies on `flags` (mark bit) and `kind` to traverse/trace.
//! Actual traversal logic will be implemented elsewhere in future PRs.
//! The heap traverses resolved typed reference maps and closure environments.
//! - The header is intentionally compact (8 bytes on most targets) to minimize
//! per-object overhead.
//!
@@ -66,8 +66,8 @@ pub enum ObjectKind {
/// Compiled closure/function value.
///
/// Invariants for `payload_len` and payload layout:
/// - `payload_len == 8` (fixed).
/// - payload bytes are `[fn_id: u32][env_len: u32]` (little-endian).
/// - `payload_len == 12` (fixed).
/// - payload bytes are `[fn_id: u32][env_len: u32][FnTypeId: u32]` (little-endian).
/// - The `env_len` captured values are stored out-of-line in the heap so
/// they remain directly visible to the GC during traversal.
Closure = 3,
@@ -80,15 +80,7 @@ pub enum ObjectKind {
#[allow(dead_code)] // Reserved for host/native integrations
UserData = 5,
/// Coroutine object: suspended execution context with its own stack/frames.
///
/// Notes:
/// - Stack/frames are stored in typed fields inside the heap storage
/// (not inside raw `payload` bytes) so the GC can traverse their
/// contained `HeapRef`s directly.
/// - `payload_len` is 0 for this fixed-layout object.
Coroutine = 6,
// Tag 6 is reserved for the retired Coroutine kind.
/// Registry-defined Struct with a compact typed instance payload.
Struct = 7,
@@ -8,7 +8,7 @@ use prometeu_bytecode::load_limits::{
use prometeu_bytecode::model::{ConstantPoolEntry as K, DebugInfo, Export};
use prometeu_bytecode::registry::{FunctionId, Registry};
use prometeu_bytecode::registry_codec::OwnedPbx;
use prometeu_bytecode::{FunctionMeta, ProgramImage, Value};
use prometeu_bytecode::{ExecutionFunction, ProgramImage, Value};
use prometeu_hal::syscalls::{CapFlags, DeclaredLoadError, SyscallResolved};
use std::collections::HashMap;
use std::sync::{Arc, Mutex, Weak};
@@ -144,6 +144,11 @@ impl ValidatedProgramImage {
if module.registry.declarations().functions.is_empty() {
return Err(E::new(C::InvalidEntrypoint, R::FunctionId).in_function(0, None).into());
}
if !module.registry.declarations().functions[0].captures.is_empty() {
return Err(E::new(C::InvalidEntrypoint, R::CapturedDirectCall)
.in_function(0, None)
.into());
}
bind(&mut module, b, capabilities)?;
crate::registry_verifier::validate_registry_types(
&module.code,
@@ -153,7 +158,7 @@ impl ValidatedProgramImage {
)?;
let mut functions =
scratch::<FunctionMeta>(module.registry.declarations().functions.len(), b)?;
scratch::<ExecutionFunction>(module.registry.declarations().functions.len(), b)?;
for (index, f) in module.registry.declarations().functions.iter().enumerate() {
b.work(1)?;
let slots = module.registry.function_layout(FunctionId(index as u32)).unwrap();
@@ -165,7 +170,7 @@ impl ValidatedProgramImage {
.in_function(index as u32, Some(f.code_offset))
})
};
functions.push(FunctionMeta {
functions.push(ExecutionFunction {
code_offset: f.code_offset,
code_len: f.code_len,
param_slots: narrow(slots.parameter_slots)?,
@@ -88,7 +88,7 @@ fn validate_inner(
)?;
}
instruction
.registry_stack_effect(registry)
.registry_stack_effect_in(registry, FunctionId(function_id))
.map_err(|e| contextual(e, start + pc))?;
match instruction.opcode {
Op::Jmp | Op::JmpIfTrue | Op::JmpIfFalse => {
@@ -117,19 +117,37 @@ fn validate_inner(
return Err(with_id(reference_error(fail(R::ConstantIndex)), id));
}
}
Op::Call | Op::MakeClosure | Op::Spawn => {
Op::Spawn | Op::Yield | Op::Sleep => return Err(fail(R::RemovedOpcode)),
Op::Call | Op::MakeClosure => {
let id = if instruction.opcode == Op::Call {
instruction.imm_u32().unwrap()
} else {
instruction.imm_u32x2().unwrap().0
};
let callee = registry.function_layout(FunctionId(id)).ok_or_else(|| {
reference_error(fail(R::FunctionId)).reference(IdDomain::Function, id)
})?;
if instruction.opcode == Op::Spawn
&& instruction.imm_u32x2().unwrap().1 != callee.parameter_slots
{
return Err(fail(R::Signature).reference(IdDomain::Function, id));
let target =
registry.declarations().functions.get(id as usize).ok_or_else(
|| {
reference_error(fail(R::FunctionId))
.reference(IdDomain::Function, id)
},
)?;
if instruction.opcode == Op::Call && !target.captures.is_empty() {
return Err(
fail(R::CapturedDirectCall).reference(IdDomain::Function, id)
);
}
if instruction.opcode == Op::MakeClosure {
let ty = instruction.imm_u32x2().unwrap().1;
let prometeu_bytecode::registry::TypeKind::Fn(signature) =
&registry.declarations().types[ty as usize].kind
else {
unreachable!()
};
budget
.work(signature.parameters.len() + signature.results.len() + 1)?;
if !signature.same_types(&target.signature) {
return Err(fail(R::Signature).reference(IdDomain::Function, id));
}
}
}
Op::Hostcall => {
@@ -1,6 +1,6 @@
//! Bounded basic-block stack analysis. This does not publish an image or prove
//! semantic argument types. Closure target facts preserve the existing known
//! callee restriction; no guest callable descriptor is invented here.
//! semantic argument types. Fn stack effects come from the expected Registry
//! signature; concrete target facts never gate an indirect call.
use super::*;
#[derive(Clone, Copy, PartialEq, Eq)]
@@ -108,15 +108,14 @@ fn analyze(
4
},
)?;
let effect = instruction.registry_stack_effect(registry)?.unwrap();
let effect =
instruction.registry_stack_effect_in(registry, FunctionId(id))?.unwrap();
(u64::from(effect.pops), u64::from(effect.pushes))
} else {
(u64::from(spec.pops.unwrap()), u64::from(spec.pushes.unwrap()))
};
match instruction.opcode {
Op::PopN => effect = (u64::from(instruction.imm_u32().unwrap()), 0),
Op::MakeClosure => effect = (u64::from(instruction.imm_u32x2().unwrap().1), 1),
Op::Spawn => effect = (u64::from(instruction.imm_u32x2().unwrap().1), 0),
Op::Call => {
budget.work(1)?;
let callee = registry
@@ -124,30 +123,6 @@ fn analyze(
.unwrap();
effect = (u64::from(callee.parameter_slots), u64::from(callee.result_slots));
}
Op::CallClosure => {
let arguments = u64::from(instruction.imm_u32().unwrap());
if (height as u64) < arguments + 1 {
return Err(count_error(R::StackUnderflow, height as u64, arguments + 1));
}
budget.work(2)?;
let target = match working[locals + height - 1] {
Fact::Closure(target) => target,
Fact::NonClosure => return Err(E::new(C::InvalidCode, R::NotClosure)),
Fact::Unknown => {
return Err(E::new(C::InvalidCode, R::UnknownClosureCallee));
}
};
let callee = registry.function_layout(FunctionId(target)).unwrap();
if u64::from(callee.parameter_slots) != arguments + 1 {
return Err(count_error(
R::Signature,
arguments + 1,
u64::from(callee.parameter_slots),
)
.reference(IdDomain::Function, target));
}
effect = (arguments + 1, u64::from(callee.result_slots));
}
Op::Ret => {
if height != results {
return Err(count_error(R::ReturnHeight, height as u64, results as u64));
@@ -169,9 +144,6 @@ fn analyze(
.unwrap();
effect = (native.arg_slots() as u64, native.ret_slots() as u64);
}
Op::Yield if height != 0 => {
return Err(count_error(R::InvalidYield, height as u64, 0));
}
_ => {}
}
if (height as u64) < effect.0 {
@@ -20,6 +20,14 @@ fn registry(code: &[u8], functions: Vec<FunctionDecl>) -> Registry {
TypeDecl { name: None, kind: TypeKind::Builtin(B::VEC2) },
TypeDecl { name: None, kind: TypeKind::Struct(vec![]) },
TypeDecl { name: None, kind: TypeKind::Trait(vec![]) },
TypeDecl { name: None, kind: TypeKind::Fn(Signature::default()) },
TypeDecl {
name: None,
kind: TypeKind::Fn(Signature {
parameters: vec![NamedType { type_id: TypeId(0), name: None }],
results: vec![],
}),
},
],
functions,
implementations: vec![],
@@ -221,48 +229,36 @@ fn stack_analysis_straight_line_storage_is_bounded_by_blocks_not_instruction_fra
}
#[test]
fn stack_analysis_retains_unknown_closure_and_yield_safety_rules() {
let mut code = vec![];
arg(&mut code, Op::GetLocal, 0);
arg(&mut code, Op::CallClosure, 0);
op(&mut code, Op::Halt);
fn stack_analysis_accepts_unknown_fn_targets_and_rejects_removed_opcodes() {
let code = prometeu_bytecode::assemble("GET_LOCAL 0\nCALL_CLOSURE 4\nHALT").unwrap();
let f = FunctionDecl {
signature: Signature {
parameters: vec![NamedType { type_id: TypeId(0), name: None }],
parameters: vec![NamedType { type_id: TypeId(4), name: None }],
results: vec![],
},
..function(&code)
};
let r = registry(&code, vec![f]);
assert_eq!(stacks(&code, &r).unwrap_err().reason, R::UnknownClosureCallee);
let mut code = vec![];
arg(&mut code, Op::GetLocal, 0);
arg(&mut code, Op::CallClosure, 0);
let r = registry(&code, vec![FunctionDecl { local_slots: 1, ..function(&code) }]);
assert_eq!(stacks(&code, &r).unwrap_err().reason, R::NotClosure);
let mut code = vec![];
arg(&mut code, Op::PushI32, 0);
op(&mut code, Op::Yield);
let r = registry(&code, vec![function(&code)]);
assert_eq!(stacks(&code, &r).unwrap_err().reason, R::InvalidYield);
stacks(&code, &r).unwrap();
for opcode in [Op::Yield, Op::Sleep, Op::Spawn] {
let mut code = vec![];
op(&mut code, Op::Halt);
op(&mut code, opcode);
code.resize(code.len() + opcode.spec().imm_bytes as usize, 0);
let r = registry(&code, vec![function(&code)]);
assert_eq!(check(&code, &r).unwrap_err().reason, R::RemovedOpcode);
}
}
#[test]
fn stack_analysis_preserves_closure_facts_through_permutations_before_rejecting_bad_arity() {
let mut code = vec![];
arg(&mut code, Op::PushI32, 0);
arg(&mut code, Op::MakeClosure, 1);
code.extend_from_slice(&0u32.to_le_bytes());
op(&mut code, Op::Swap);
op(&mut code, Op::Pop);
op(&mut code, Op::Dup);
op(&mut code, Op::Pop);
arg(&mut code, Op::SetLocal, 0);
arg(&mut code, Op::GetLocal, 0);
arg(&mut code, Op::CallClosure, 0);
op(&mut code, Op::Halt);
fn expected_fn_signature_checks_argument_height_after_permutations() {
let mut code=prometeu_bytecode::assemble("PUSH_I32 0\nMAKE_CLOSURE fn=1,type=5\nSWAP\nPOP\nDUP\nPOP\nSET_LOCAL 0\nGET_LOCAL 0\nCALL_CLOSURE 5\nHALT").unwrap();
let end = code.len();
op(&mut code, Op::Ret);
let signature = Signature {
parameters: vec![NamedType { type_id: TypeId(0), name: None }],
results: vec![],
};
let r = registry(
&code,
vec![
@@ -272,18 +268,14 @@ fn stack_analysis_preserves_closure_facts_through_permutations_before_rejecting_
max_stack_slots: 2,
..function(&code)
},
FunctionDecl { code_offset: end as u32, code_len: 2, ..Default::default() },
FunctionDecl { signature, code_offset: end as u32, code_len: 2, ..Default::default() },
],
);
let e = stacks(&code, &r).unwrap_err();
// The callee deliberately lacks hidden arg0: this fixture is rejected,
// and does not invent a typed descriptor for a valid guest closure.
assert_eq!((e.reason, e.referenced_id), (R::Signature, Some(1)));
assert_eq!((e.requested, e.limit), (Some(1), Some(0)));
assert_eq!(stacks(&code, &r).unwrap_err().reason, R::StackUnderflow);
}
#[test]
fn stack_analysis_checks_closure_counts_without_wraparound() {
fn expected_fn_type_ids_never_wrap_or_become_argument_counts() {
for operation in [Op::MakeClosure, Op::CallClosure] {
let mut code = vec![];
if operation == Op::MakeClosure {
@@ -294,9 +286,7 @@ fn stack_analysis_checks_closure_counts_without_wraparound() {
}
op(&mut code, Op::Halt);
let r = registry(&code, vec![function(&code)]);
let e = stacks(&code, &r).unwrap_err();
assert_eq!(e.reason, R::StackUnderflow);
assert_eq!(e.limit, Some(u64::from(u32::MAX) + u64::from(operation == Op::CallClosure)));
assert_eq!(stacks(&code, &r).unwrap_err().reason, R::TypeId);
}
}
@@ -471,7 +461,7 @@ fn unreachable_function_constant_boolean_and_native_operands_are_checked() {
#[test]
fn spawn_arity_does_not_truncate_and_closure_function_ids_are_checked() {
for (operation, function_id, count, reason) in
[(Op::Spawn, 0, 65_536, R::Signature), (Op::MakeClosure, 1, 0, R::FunctionId)]
[(Op::Spawn, 0, 65_536, R::RemovedOpcode), (Op::MakeClosure, 1, 4, R::FunctionId)]
{
let mut code = vec![];
op(&mut code, Op::Halt);
@@ -24,7 +24,6 @@ enum Fact {
Int64(i64),
Group { ty: TypeId, part: u32, origin: u64 },
Dynamic { part: u32, origin: u64 },
Closure(u32),
}
pub(crate) fn validate_registry_types(
@@ -102,7 +101,16 @@ fn analyze(
while pc < end {
*at_pc = pc;
let instruction = metered_decode(pc, body, budget)?;
transfer(&instruction, &mut working, locals, &mut height, registry, constants, budget)?;
transfer(
&instruction,
&mut working,
locals,
&mut height,
registry,
constants,
id,
budget,
)?;
let spec = instruction.opcode.spec();
if spec.is_branch {
let target = instruction.imm_u32().unwrap() as usize;
@@ -150,7 +158,16 @@ fn analyze(
*at_pc = pc;
let instruction = metered_decode(pc, body, budget)?;
check(&instruction, &working, locals, height, registry, id, budget)?;
transfer(&instruction, &mut working, locals, &mut height, registry, constants, budget)?;
transfer(
&instruction,
&mut working,
locals,
&mut height,
registry,
constants,
id,
budget,
)?;
if instruction.opcode.spec().is_terminator {
break;
}
@@ -178,7 +195,7 @@ fn group(
fn component(registry: &Registry, ty: TypeId, part: u32, budget: &mut LoadBudget) -> Result<u8, E> {
budget.work(1)?;
Ok(match &registry.declarations().types[ty.0 as usize].kind {
TypeKind::Struct(_) | TypeKind::Array(_) => REFERENCE | NULL,
TypeKind::Struct(_) | TypeKind::Array(_) | TypeKind::Fn(_) => REFERENCE | NULL,
TypeKind::Trait(_) => {
if part == 0 {
REFERENCE | NULL
@@ -208,7 +225,6 @@ fn mask(fact: Fact, registry: &Registry, budget: &mut LoadBudget) -> Result<u8,
Fact::Null => NULL,
Fact::Carrier(mask) => mask,
Fact::Int64(_) => I64,
Fact::Closure(_) => REFERENCE,
Fact::Group { ty, part, .. } => return component(registry, ty, part, budget),
Fact::Dynamic { part: 0, .. } => I64 | NULL,
Fact::Dynamic { .. } => ANY,
@@ -244,6 +260,7 @@ fn transfer(
height: &mut usize,
registry: &Registry,
constants: &[Constant],
id: u32,
budget: &mut LoadBudget,
) -> Result<(), E> {
budget.work(1)?;
@@ -251,7 +268,7 @@ fn transfer(
let spec = opcode.spec();
let (mut pops, mut pushes) = if opcode.requires_registry() {
budget.work(4)?;
let effect = instruction.registry_stack_effect(registry)?.unwrap();
let effect = instruction.registry_stack_effect_in(registry, FunctionId(id))?.unwrap();
(effect.pops as usize, effect.pushes as usize)
} else {
(spec.pops.unwrap() as usize, spec.pushes.unwrap() as usize)
@@ -260,22 +277,27 @@ fn transfer(
let mut native = None;
match opcode {
Op::PopN => pops = instruction.imm_u32().unwrap() as usize,
Op::MakeClosure => pops = instruction.imm_u32x2().unwrap().1 as usize,
Op::Spawn => pops = instruction.imm_u32x2().unwrap().1 as usize,
Op::Call | Op::CallClosure => {
Op::Call => {
let target = instruction.imm_u32().unwrap();
budget.work(1)?;
let target = if opcode == Op::Call {
instruction.imm_u32().unwrap()
} else {
let Fact::Closure(target) = working[locals + *height - 1] else {
return Err(E::new(C::InvalidCode, R::UnknownClosureCallee));
};
target
};
let layout = registry.function_layout(FunctionId(target)).unwrap();
pops = layout.parameter_slots as usize;
pushes = layout.result_slots as usize;
call = Some(target);
call = Some(&registry.declarations().functions[target as usize].signature);
}
Op::CallClosure => {
let ty = instruction.imm_u32().unwrap();
let TypeKind::Fn(s) = &registry.declarations().types[ty as usize].kind else {
unreachable!()
};
call = Some(s);
}
Op::CallTrait => {
let (ty, method) = instruction.imm_u32x2().unwrap();
let TypeKind::Trait(methods) = &registry.declarations().types[ty as usize].kind else {
unreachable!()
};
call = Some(&methods[method as usize].signature);
}
Op::Ret => {
// Stack analysis has already proved exact height; no continuation.
@@ -387,14 +409,19 @@ fn transfer(
Constant::String(_) => Fact::Carrier(STRING),
};
}
Op::MakeClosure => {
budget.work(1)?;
working[base] = Fact::Closure(instruction.imm_u32x2().unwrap().0);
Op::MakeClosure | Op::GetCapture => {
let ty = if opcode == Op::MakeClosure {
TypeId(instruction.imm_u32x2().unwrap().1)
} else {
registry.function_layout(FunctionId(id)).unwrap().captures
[instruction.imm_u32().unwrap() as usize]
.type_id
};
group(&mut working[base..], registry, ty, (instruction.pc as u64) << 32, budget)?;
}
Op::Call | Op::CallClosure => {
let signature = &registry.declarations().functions[call.unwrap() as usize].signature;
Op::Call | Op::CallClosure | Op::CallTrait => {
let mut offset = base;
for (index, ty) in signature.results.iter().enumerate() {
for (index, ty) in call.unwrap().results.iter().enumerate() {
offset += group(
&mut working[offset..],
registry,
@@ -572,11 +599,6 @@ fn check_group(
budget.work(2)?;
let kind = &registry.declarations().types[ty.0 as usize].kind;
let width = registry.type_layout(ty).unwrap().storage.slots as usize;
if matches!(values[0], Fact::Closure(_))
&& matches!(kind, TypeKind::Struct(_) | TypeKind::Array(_) | TypeKind::Trait(_))
{
return Err(mismatch(0).reference(IdDomain::Type, ty.0));
}
budget.work(1)?;
if let Fact::Group { ty: source, part: 0, origin } = values[0] {
budget.work(1)?;
@@ -634,12 +656,8 @@ fn check(
budget.work(1)?;
let end = locals + height;
match instruction.opcode {
Op::Call | Op::Spawn => {
let target = if instruction.opcode == Op::Call {
instruction.imm_u32().unwrap()
} else {
instruction.imm_u32x2().unwrap().0
};
Op::Call => {
let target = instruction.imm_u32().unwrap();
budget.work(1)?;
let callee = registry.function_layout(FunctionId(target)).unwrap();
let mut base = end - callee.parameter_slots as usize;
@@ -659,21 +677,35 @@ fn check(
base += registry.type_layout(*ty).unwrap().storage.slots as usize;
}
}
Op::CallClosure => {
budget.work(1)?;
let Fact::Closure(target) = working[end - 1] else {
return Err(E::new(C::InvalidCode, R::UnknownClosureCallee));
};
let parameters =
&registry.declarations().functions[target as usize].signature.parameters;
budget.work(1)?;
let receiver = parameters.first().unwrap();
if registry.type_layout(receiver.type_id).unwrap().storage.slots != 1 {
return Err(mismatch(0));
Op::MakeClosure => {
let target = instruction.imm_u32x2().unwrap().0;
let layout = registry.function_layout(FunctionId(target)).unwrap();
let mut base = end - layout.capture_slots as usize;
for capture in &layout.captures {
check_group(&working[base..], capture.type_id, registry, budget)?;
base += capture.slots as usize;
}
check_group(&working[end - 1..end], receiver.type_id, registry, budget)?;
let mut base = end - instruction.imm_u32().unwrap() as usize - 1;
for parameter in parameters.iter().skip(1) {
}
Op::CallClosure | Op::CallTrait => {
let (ty, view_slots, signature) = if instruction.opcode == Op::CallClosure {
let ty = TypeId(instruction.imm_u32().unwrap());
let TypeKind::Fn(signature) = &registry.declarations().types[ty.0 as usize].kind
else {
unreachable!()
};
(ty, 1, signature)
} else {
let (ty, method) = instruction.imm_u32x2().unwrap();
let TypeKind::Trait(methods) = &registry.declarations().types[ty as usize].kind
else {
unreachable!()
};
(TypeId(ty), 2, &methods[method as usize].signature)
};
check_group(&working[end - view_slots..end], ty, registry, budget)?;
let effect = instruction.registry_stack_effect_in(registry, FunctionId(id))?.unwrap();
let mut base = end - effect.pops as usize;
for parameter in &signature.parameters {
check_group(&working[base..], parameter.type_id, registry, budget)?;
budget.work(1)?;
base += registry.type_layout(parameter.type_id).unwrap().storage.slots as usize;
@@ -688,7 +720,7 @@ fn check(
(instruction.imm_u32().unwrap(), 0)
};
let ty = TypeId(id);
let effect = instruction.registry_stack_effect(registry)?.unwrap();
let effect = instruction.registry_stack_effect_in(registry, FunctionId(id))?.unwrap();
let base = end - effect.pops as usize;
check_group(&working[base..base + 1], ty, registry, budget)?;
let array = matches!(instruction.opcode, Op::ArrayGet | Op::ArraySet);
@@ -32,6 +32,7 @@ fn function(
max: u32,
) -> FunctionDecl {
FunctionDecl {
captures: vec![],
code_offset: offset as u32,
code_len: len as u32,
local_slots: locals,
@@ -283,7 +284,7 @@ fn known_closure_receivers_are_not_faked_as_user_struct_types() {
let r =
registry(&code, vec![function(0, end, &[], &[], 0, 1), function(end, 2, &[9], &[], 0, 0)]);
// No provisional callable descriptor: a Closure is never a guest Struct.
assert_eq!(check(&code, &r, &[]).unwrap_err().reason, R::TypeMismatch);
assert_eq!(check(&code, &r, &[]).unwrap_err().reason, R::Category);
}
#[test]
@@ -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];
-184
View File
@@ -1,184 +0,0 @@
use crate::resource_budget::{BudgetQueue, ResourceFailure, RuntimeBudget};
use prometeu_bytecode::HeapRef;
/// Deterministic cooperative scheduler core.
///
/// Policy:
/// - FIFO for ready coroutines.
/// - Sleeping coroutines are ordered by `wake_tick` and moved to ready when `wake_tick <= current_tick`.
/// - No randomness, no preemption, no context switching here.
#[derive(Debug)]
pub struct Scheduler {
/// Queue of runnable coroutines (FIFO)
ready_queue: BudgetQueue<HeapRef>,
/// Sleeping list kept sorted by (wake_tick, insertion_order)
sleeping: BudgetQueue<SleepEntry>,
/// Currently selected coroutine (purely informational here)
current: Option<HeapRef>,
/// Monotonic counter to preserve deterministic order for same wake_tick
next_seq: u64,
}
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
struct SleepEntry {
wake_tick: u64,
seq: u64,
coro: HeapRef,
}
impl Scheduler {
#[cfg(test)]
pub(crate) fn capacity_bytes(&self) -> u64 {
self.ready_queue.capacity_bytes() + self.sleeping.capacity_bytes()
}
#[cfg(test)]
pub fn new() -> Self {
Self::with_budget(&RuntimeBudget::default())
}
pub fn with_budget(budget: &RuntimeBudget) -> Self {
Self {
ready_queue: BudgetQueue::new(budget),
sleeping: BudgetQueue::new(budget),
current: None,
next_seq: 0,
}
}
pub fn reserve_ready(&mut self) -> Result<(), ResourceFailure> {
self.ready_queue.reserve(1)
}
// ---------- Ready queue operations ----------
/// Enqueue a coroutine to the ready FIFO.
pub fn enqueue_ready(&mut self, coro: HeapRef) -> Result<(), ResourceFailure> {
self.ready_queue.push_back(coro)
}
/// Dequeue next ready coroutine (front of FIFO).
pub fn dequeue_next(&mut self) -> Option<HeapRef> {
self.ready_queue.pop_front()
}
#[cfg(test)]
pub fn is_ready_empty(&self) -> bool {
self.ready_queue.is_empty()
}
#[cfg(test)]
pub fn ready_len(&self) -> usize {
self.ready_queue.len()
}
// ---------- Current tracking (no switching here) ----------
pub fn set_current(&mut self, coro: Option<HeapRef>) {
self.current = coro;
}
#[cfg(test)]
pub fn current(&self) -> Option<HeapRef> {
self.current
}
pub fn clear_current(&mut self) {
self.current = None;
}
// ---------- Sleeping operations ----------
/// Put a coroutine to sleep until `wake_tick`.
/// A coroutine is woken when `current_tick >= wake_tick`.
/// The sleeping list is kept stably ordered to guarantee determinism.
pub fn sleep_until(&mut self, coro: HeapRef, wake_tick: u64) -> Result<(), ResourceFailure> {
let entry = SleepEntry { wake_tick, seq: self.next_seq, coro };
let idx =
self.sleeping.partition_point(|e| (e.wake_tick, e.seq) <= (entry.wake_tick, entry.seq));
self.sleeping.insert(idx, entry)?;
self.next_seq = self.next_seq.wrapping_add(1);
Ok(())
}
/// Reserve the destination before removing any sleeping entries. A failed
/// transfer preserves both queues and never loses a runnable coroutine.
pub fn wake_ready(&mut self, current_tick: u64) -> Result<(), ResourceFailure> {
let split = self.sleeping.partition_point(|e| e.wake_tick <= current_tick);
self.ready_queue.reserve(split)?;
for _ in 0..split {
let entry = self.sleeping.pop_front().expect("validated sleeping prefix");
self.ready_queue.push_back(entry.coro)?;
}
Ok(())
}
/// Returns true if there are any sleeping coroutines.
pub fn has_sleeping(&self) -> bool {
!self.sleeping.is_empty()
}
}
#[cfg(test)]
mod tests {
use super::*;
fn hr(id: u32) -> HeapRef {
HeapRef { index: id, generation: 1 }
}
#[test]
fn fifo_ready_queue_is_deterministic() {
let mut s = Scheduler::new();
s.enqueue_ready(hr(1)).unwrap();
s.enqueue_ready(hr(2)).unwrap();
s.enqueue_ready(hr(3)).unwrap();
assert_eq!(s.ready_len(), 3);
assert_eq!(s.dequeue_next(), Some(hr(1)));
assert_eq!(s.dequeue_next(), Some(hr(2)));
assert_eq!(s.dequeue_next(), Some(hr(3)));
assert_eq!(s.dequeue_next(), None);
}
#[test]
fn sleeping_wake_is_stable_and_fifo_by_insertion() {
let mut s = Scheduler::new();
s.sleep_until(hr(10), 5).unwrap(); // first with wake at 5
s.sleep_until(hr(11), 5).unwrap(); // second with same wake
s.sleep_until(hr(12), 6).unwrap(); // later wake
// Before tick 5: nothing wakes
s.wake_ready(4).unwrap();
assert!(s.is_ready_empty());
// At tick 5: first two wake in insertion order
s.wake_ready(5).unwrap();
assert_eq!(s.dequeue_next(), Some(hr(10)));
assert_eq!(s.dequeue_next(), Some(hr(11)));
assert!(s.is_ready_empty());
// At tick 6: last one wakes
s.wake_ready(6).unwrap();
assert_eq!(s.dequeue_next(), Some(hr(12)));
assert!(s.is_ready_empty());
}
#[test]
fn wake_refusal_preserves_sleepers_and_fifo_order() {
use crate::resource_budget::{RuntimeLimits, RuntimeResource};
let budget = RuntimeBudget::new(
RuntimeLimits::default()
.lowered(RuntimeResource::AuxiliaryBytes, (2 * size_of::<SleepEntry>()) as u64)
.unwrap(),
);
let mut s = Scheduler::with_budget(&budget);
s.sleep_until(hr(1), 4).unwrap();
s.sleep_until(hr(2), 4).unwrap();
let charged = budget.used(RuntimeResource::AuxiliaryBytes);
assert!(s.wake_ready(4).is_err());
assert_eq!(budget.used(RuntimeResource::AuxiliaryBytes), charged);
assert_eq!(budget.used(RuntimeResource::TemporaryBytes), 0);
assert!(s.is_ready_empty());
assert_eq!(s.sleeping.pop_front().unwrap().coro, hr(1));
assert_eq!(s.sleeping.pop_front().unwrap().coro, hr(2));
drop(s);
assert_eq!(budget.used(RuntimeResource::AuxiliaryBytes), 0);
}
}
@@ -103,7 +103,7 @@ impl TypedStorage {
// until every native value is constructed. Count advances only after init.
unsafe {
match self.registry.declarations().types[ty.0 as usize].kind {
TypeKind::Struct(_) | TypeKind::Array(_) => {
TypeKind::Struct(_) | TypeKind::Array(_) | TypeKind::Fn(_) => {
self.data.init(offset, HeapRef::NULL)
}
TypeKind::Trait(_) => self.data.init(
@@ -135,7 +135,7 @@ impl TypedStorage {
// immutable Registry. Only matching typed writes can change its contents.
let result = unsafe {
match self.registry.declarations().types[ty.0 as usize].kind {
TypeKind::Struct(_) | TypeKind::Array(_) => {
TypeKind::Struct(_) | TypeKind::Array(_) | TypeKind::Fn(_) => {
let r = *self.data.get::<HeapRef>(offset);
ValueGroup::new(&[if r.is_null() { Value::Null } else { Value::HeapRef(r) }])
}
@@ -205,12 +205,13 @@ impl TypedStorage {
// &mut self gives exclusive access. Native assignment drops exactly once.
unsafe {
match (&self.registry.declarations().types[ty.0 as usize].kind, values) {
(TypeKind::Struct(_) | TypeKind::Array(_), [Value::Null]) => {
(TypeKind::Struct(_) | TypeKind::Array(_) | TypeKind::Fn(_), [Value::Null]) => {
self.data.replace(offset, HeapRef::NULL)
}
(TypeKind::Struct(_) | TypeKind::Array(_), [Value::HeapRef(r)]) => {
self.data.replace(offset, *r)
}
(
TypeKind::Struct(_) | TypeKind::Array(_) | TypeKind::Fn(_),
[Value::HeapRef(r)],
) => self.data.replace(offset, *r),
(TypeKind::Trait(_), [Value::Null, Value::Null]) => self.data.replace(
offset,
TraitSlot { receiver: HeapRef::NULL, implementation: 0, padding: 0 },
@@ -67,6 +67,11 @@ pub(crate) fn validate(
}
_ => false,
},
TypeKind::Fn(_) => match &values[0] {
Value::Null => true,
Value::HeapRef(r) if !r.is_null() => heap.closure_type(*r)? == type_id,
_ => false,
},
TypeKind::Trait(_) => return validate_trait(registry, heap, type_id, values),
TypeKind::Builtin(B::DYNAMIC) => return validate_dynamic(registry, heap, values),
TypeKind::Builtin(id) => match (*id, values) {
File diff suppressed because it is too large Load Diff
File diff suppressed because it is too large Load Diff
@@ -0,0 +1,291 @@
//! Typed callable boundaries: validate and reserve before consuming any owner.
use super::*;
use crate::value_contract::{self, ValueError};
use prometeu_bytecode::registry::{FunctionId, Signature, TypeId, TypeKind};
impl VirtualMachine {
pub(super) fn execute_callable(
&mut self,
op: OpCode,
a: u32,
b: u32,
pc: u32,
) -> Result<(), LogicalFrameEndingReason> {
let image = self
.validated_image
.clone()
.ok_or_else(|| self.value_trap(ValueError::Type, op, pc))?;
let registry = image.registry();
let width = match op {
OpCode::MakeClosure => {
registry.function_layout(FunctionId(a)).map_or(0, |f| u64::from(f.capture_slots))
}
OpCode::GetCapture => self
.call_stack
.last()
.and_then(|f| registry.function_layout(FunctionId(f.func_idx as u32)))
.and_then(|f| f.captures.get(a as usize))
.map_or(0, |c| u64::from(c.slots)),
_ => 0,
};
let cost = op.cycles().checked_add(width).ok_or_else(|| {
self.resource_trap(
self.budget.failure(
RuntimeResource::TemporaryBytes,
crate::resource_budget::ResourceReason::SizeOverflow,
u64::MAX,
),
op,
pc,
)
})?;
self.cycles += cost;
let end = self.operand_stack.len();
match op {
OpCode::MakeClosure => {
let target = registry
.declarations()
.functions
.get(a as usize)
.ok_or_else(|| self.value_trap(ValueError::Type, op, pc))?;
let TypeKind::Fn(signature) = &registry
.declarations()
.types
.get(b as usize)
.ok_or_else(|| self.value_trap(ValueError::Type, op, pc))?
.kind
else {
return Err(self.value_trap(ValueError::Type, op, pc));
};
if !signature.same_types(&target.signature) {
return Err(self.value_trap(ValueError::Type, op, pc));
}
let layout = registry.function_layout(FunctionId(a)).unwrap();
let count = layout.capture_slots as usize;
self.callable_stack_check(count, op, pc)?;
let base = end - count;
for capture in &layout.captures {
let start = base + capture.slot_offset as usize;
value_contract::validate(
registry,
&self.heap,
capture.type_id,
&self.operand_stack[start..start + capture.slots as usize],
)
.map_err(|e| self.value_trap(e, op, pc))?;
}
let growth = self
.operand_stack
.prepare_growth(usize::from(count == 0))
.map_err(|e| self.resource_trap(e, op, pc))?;
let instance = self
.heap
.alloc_typed_closure(a, TypeId(b), &self.operand_stack[base..])
.map_err(|e| self.resource_trap(e, op, pc))?;
self.operand_stack.commit_growth(growth);
self.operand_stack.truncate(base);
self.operand_stack
.push(Value::HeapRef(instance))
.expect("reserved callable result");
}
OpCode::GetCapture => {
let frame = self
.call_stack
.last()
.ok_or_else(|| self.value_trap(ValueError::Type, op, pc))?;
let owner =
frame.closure.ok_or_else(|| self.value_trap(ValueError::Type, op, pc))?;
let capture = registry
.function_layout(FunctionId(frame.func_idx as u32))
.and_then(|f| f.captures.get(a as usize))
.ok_or_else(|| self.value_trap(ValueError::Type, op, pc))?;
let range =
capture.slot_offset as usize..(capture.slot_offset + capture.slots) as usize;
let values = self
.heap
.closure_env_slice(owner)
.and_then(|env| env.get(range))
.ok_or_else(|| self.value_trap(ValueError::Type, op, pc))?;
value_contract::validate(registry, &self.heap, capture.type_id, values)
.map_err(|e| self.value_trap(e, op, pc))?;
// Every logical stored group has at most three slots; clone owners before growth.
let values = crate::value_contract::ValueGroup::new(values);
let growth = self
.operand_stack
.prepare_growth(capture.slots as usize)
.map_err(|e| self.resource_trap(e, op, pc))?;
self.operand_stack.commit_growth(growth);
self.operand_stack
.extend_from_slice(values.as_slice())
.expect("reserved capture group");
}
OpCode::CallClosure => {
let ty = TypeId(a);
let decl = registry
.declarations()
.types
.get(a as usize)
.ok_or_else(|| self.value_trap(ValueError::Type, op, pc))?;
let TypeKind::Fn(signature) = &decl.kind else {
return Err(self.value_trap(ValueError::Type, op, pc));
};
let p = registry.type_layout(ty).unwrap().callable.as_ref().unwrap().parameter_slots
as usize;
self.callable_stack_check(p + 1, op, pc)?;
let closure = match self.operand_stack[end - 1] {
Value::Null => return Err(self.value_trap(ValueError::NullReference, op, pc)),
Value::HeapRef(r) => r,
_ => return Err(self.value_trap(ValueError::Type, op, pc)),
};
value_contract::validate(registry, &self.heap, ty, &self.operand_stack[end - 1..])
.map_err(|e| self.value_trap(e, op, pc))?;
let target = self
.heap
.closure_fn_id(closure)
.ok_or_else(|| self.value_trap(ValueError::Type, op, pc))?
as usize;
let declaration = registry
.declarations()
.functions
.get(target)
.ok_or_else(|| self.value_trap(ValueError::Type, op, pc))?;
if !signature.same_types(&declaration.signature) {
return Err(self.value_trap(ValueError::Type, op, pc));
}
let layout = registry.function_layout(FunctionId(target as u32)).unwrap();
if self.heap.closure_env_slice(closure).map(|v| v.len())
!= Some(layout.capture_slots as usize)
{
return Err(self.value_trap(ValueError::Type, op, pc));
}
let base = end - p - 1;
self.check_signature_group(target, false, &self.operand_stack[base..end - 1])
.map_err(|(_, e)| self.value_trap(e, op, pc))?;
self.install_callable_frame(target, base, Some(closure), 1, false, op, pc)?;
}
OpCode::CallTrait => {
let TypeKind::Trait(methods) = &registry
.declarations()
.types
.get(a as usize)
.ok_or_else(|| self.value_trap(ValueError::Type, op, pc))?
.kind
else {
return Err(self.value_trap(ValueError::Type, op, pc));
};
let method = methods
.get(b as usize)
.ok_or_else(|| self.value_trap(ValueError::Type, op, pc))?;
let p = registry.type_layout(TypeId(a)).unwrap().methods[b as usize].parameter_slots
as usize;
self.callable_stack_check(p + 2, op, pc)?;
let view = &self.operand_stack[end - 2..];
value_contract::validate(registry, &self.heap, TypeId(a), view)
.map_err(|e| self.value_trap(e, op, pc))?;
if matches!(view, [Value::Null, Value::Null]) {
return Err(self.value_trap(ValueError::NullReference, op, pc));
}
let implementation = value_contract::u32_carrier(&view[1])
.map_err(|e| self.value_trap(e, op, pc))?;
let target = registry.declarations().implementations[implementation as usize]
.methods[b as usize]
.0 as usize;
if !registry.declarations().functions[target].captures.is_empty() {
return Err(self.value_trap(ValueError::Type, op, pc));
}
let base = end - p - 2;
self.check_callable_parameters(
&method.signature,
&self.operand_stack[base..end - 2],
op,
pc,
)?;
self.install_callable_frame(target, base, None, 1, true, op, pc)?;
}
_ => unreachable!(),
}
Ok(())
}
fn callable_stack_check(
&self,
count: usize,
op: OpCode,
pc: u32,
) -> Result<(), LogicalFrameEndingReason> {
if self.temporary_slots() < count {
Err(self.trap(
TRAP_STACK_UNDERFLOW,
op as u16,
"Callable argument underflow".into(),
pc,
))
} else {
Ok(())
}
}
fn check_callable_parameters(
&self,
signature: &Signature,
values: &[Value],
op: OpCode,
pc: u32,
) -> Result<(), LogicalFrameEndingReason> {
let registry = self.validated_image.as_ref().unwrap().registry();
let mut at = 0;
for parameter in &signature.parameters {
let width = registry.type_layout(parameter.type_id).unwrap().storage.slots as usize;
value_contract::validate(
registry,
&self.heap,
parameter.type_id,
&values[at..at + width],
)
.map_err(|e| self.value_trap(e, op, pc))?;
at += width;
}
Ok(())
}
fn install_callable_frame(
&mut self,
target: usize,
base: usize,
closure: Option<HeapRef>,
discard: usize,
receiver_last: bool,
op: OpCode,
pc: u32,
) -> Result<(), LogicalFrameEndingReason> {
self.check_call_depth().map_err(|e| self.resource_trap(e, op, pc))?;
let function = &self.program.functions[target];
let locals = function.local_slots as usize;
let code = function.code_offset as usize;
let stack_growth = self
.operand_stack
.prepare_growth(locals.saturating_sub(discard))
.map_err(|e| self.resource_trap(e, op, pc))?;
let frame_growth =
self.call_stack.prepare_growth(1).map_err(|e| self.resource_trap(e, op, pc))?;
self.operand_stack.commit_growth(stack_growth);
self.call_stack.commit_growth(frame_growth);
self.operand_stack.truncate(self.operand_stack.len() - discard);
if receiver_last {
self.operand_stack[base..].rotate_right(1);
}
for _ in 0..locals {
self.operand_stack.push(Value::Null).expect("reserved locals");
}
self.call_stack
.push(CallFrame {
return_pc: self.pc as u32,
stack_base: base,
func_idx: target,
closure,
})
.expect("reserved call frame");
self.pc = code;
Ok(())
}
}
@@ -0,0 +1,333 @@
use super::*;
#[path = "../../tests/support/callables.rs"]
mod support;
use support::*;
fn session(
bodies: &[(
&str,
prometeu_bytecode::registry::Signature,
Vec<prometeu_bytecode::registry::TypeId>,
)],
limits: RuntimeLimits,
) -> VirtualMachine {
let mut v = VirtualMachine::from_image(image(bodies, vec![]).unwrap(), limits);
v.prepare_boot_call().unwrap();
v
}
#[test]
fn fn_creation_identity_aliasing_and_capture_order() {
let mut v = vm(&[
(
"PUSH_I32 11\nPUSH_I32 22\nMAKE_CLOSURE fn=1,type=4\nDUP\nSET_GLOBAL 0\nSET_GLOBAL 1\nPUSH_I32 11\nPUSH_I32 22\nMAKE_CLOSURE fn=1,type=4\nSET_GLOBAL 2\nGET_GLOBAL 0\nCALL_CLOSURE 4\nRET",
sig(&[], &[0]),
vec![],
),
(
"GET_CAPTURE 0\nGET_CAPTURE 1\nSUB\nRET",
sig(&[], &[0]),
vec![prometeu_bytecode::registry::TypeId(0); 2],
),
]);
assert_eq!(run(&mut v, 1000).reason, LogicalFrameEndingReason::EndOfRom);
assert_eq!(v.operand_stack_top(1), vec![Value::Int32(-11)]);
assert_eq!(v.globals[0], v.globals[1]);
assert_ne!(v.globals[0], v.globals[2]);
}
#[test]
fn multi_slot_capture_is_one_logical_group() {
let mut v = vm(&[
(
"PUSH_F64 f64:0x3ff0000000000000\nPUSH_F64 f64:0x4000000000000000\nMAKE_CLOSURE fn=1,type=13\nCALL_CLOSURE 13\nRET",
sig(&[], &[2]),
vec![],
),
("GET_CAPTURE 0\nRET", sig(&[], &[2]), vec![prometeu_bytecode::registry::TypeId(2)]),
]);
let r = run(&mut v, 1000);
assert_eq!(r.reason, LogicalFrameEndingReason::EndOfRom);
assert_eq!(v.operand_stack_top(2), vec![Value::Float(2.), Value::Float(1.)]);
// 2 pushes + (8+2) creation + 6 call + (2+2) capture + two returns.
assert_eq!(r.cycles_used, 2 * OpCode::PushF64.cycles() + 10 + 6 + 4 + 8);
}
#[test]
fn callable_budget_zero_preserves_state_and_positive_slice_finishes_one_instruction() {
let mut v = vm(&[
(
"PUSH_F64 f64:0x3ff0000000000000\nPUSH_F64 f64:0x4000000000000000\nMAKE_CLOSURE fn=1,type=13\nCALL_CLOSURE 13\nRET",
sig(&[], &[2]),
vec![],
),
("GET_CAPTURE 0\nRET", sig(&[], &[2]), vec![prometeu_bytecode::registry::TypeId(2)]),
]);
for _ in 0..2 {
v.step(&mut Native, &mut HostContext::new(None)).unwrap();
}
// Creation, indirect call and complete-group capture are each atomic even
// when their cost exceeds the remaining positive slice.
for cost in [10, 6, 4] {
let before = (
v.pc,
v.cycles,
v.operand_stack.as_slice().to_vec(),
v.call_stack.len(),
v.heap.allocation_count(),
);
let zero = run(&mut v, 0);
assert_eq!((zero.cycles_used, zero.steps_executed), (0, 0));
assert_eq!(zero.reason, LogicalFrameEndingReason::BudgetExhausted);
assert_eq!(
(
v.pc,
v.cycles,
v.operand_stack.as_slice().to_vec(),
v.call_stack.len(),
v.heap.allocation_count()
),
before
);
let one = run(&mut v, 1);
assert_eq!((one.cycles_used, one.steps_executed), (cost, 1));
assert_eq!(one.reason, LogicalFrameEndingReason::BudgetExhausted);
}
assert_eq!(run(&mut v, 100).reason, LogicalFrameEndingReason::EndOfRom);
assert_eq!(v.operand_stack_top(2), vec![Value::Float(2.), Value::Float(1.)]);
}
#[test]
fn closure_call_depth_failure_preserves_fn_and_charges_once() {
let mut v = session(
&[
("MAKE_CLOSURE fn=1,type=9\nCALL_CLOSURE 9\nRET", sig(&[], &[]), vec![]),
("RET", sig(&[], &[]), vec![]),
],
RuntimeLimits::default().lowered(RuntimeResource::CallDepth, 1).unwrap(),
);
v.step(&mut Native, &mut HostContext::new(None)).unwrap();
let sources = v.operand_stack.as_slice().to_vec();
let before = v.cycles;
let result = v.step(&mut Native, &mut HostContext::new(None));
assert!(matches!(result,Err(LogicalFrameEndingReason::Trap(t)) if t.code==TRAP_RESOURCE_LIMIT));
assert_eq!(v.cycles - before, 6);
assert_eq!(v.call_stack.len(), 1);
assert_eq!(v.operand_stack.as_slice(), sources);
}
#[test]
fn null_and_stale_fn_calls_trap_without_consuming_source() {
for value in [Value::Null, Value::HeapRef(HeapRef { index: 99, generation: 1 })] {
let mut v = vm(&[("GET_GLOBAL 0\nCALL_CLOSURE 4\nRET", sig(&[], &[0]), vec![])]);
v.globals.push(value.clone()).unwrap();
v.step(&mut Native, &mut HostContext::new(None)).unwrap();
let before = v.cycles;
assert!(
matches!(v.step(&mut Native,&mut HostContext::new(None)),Err(LogicalFrameEndingReason::Trap(t)) if t.code==TRAP_NULL_REFERENCE || t.code==TRAP_INVALID_HANDLE)
);
assert_eq!(v.cycles - before, 6);
assert_eq!(v.operand_stack.last(), Some(&value));
}
}
#[test]
fn closure_quota_refusal_keeps_captures_and_owners() {
for resource in [RuntimeResource::HandleSlots, RuntimeResource::GuestBytes] {
let mut v = session(
&[
("PUSH_I32 7\nMAKE_CLOSURE fn=1,type=4\nPOP\nRET", sig(&[], &[]), vec![]),
(
"GET_CAPTURE 0\nRET",
sig(&[], &[0]),
vec![prometeu_bytecode::registry::TypeId(0)],
),
],
RuntimeLimits::default().lowered(resource, 0).unwrap(),
);
v.step(&mut Native, &mut HostContext::new(None)).unwrap();
let before = v.cycles;
let sources = v.operand_stack.as_slice().to_vec();
assert!(
matches!(v.step(&mut Native,&mut HostContext::new(None)),Err(LogicalFrameEndingReason::Trap(t)) if t.code==TRAP_RESOURCE_LIMIT)
);
assert_eq!(v.cycles - before, 9);
assert_eq!(v.operand_stack.as_slice(), sources);
assert_eq!(v.heap.allocation_count(), 0);
}
}
#[test]
fn closure_temporary_growth_refusal_preserves_capture() {
let mut v = vm(&[
(
"MAKE_CLOSURE fn=2,type=4\nPOP\nPUSH_I32 7\nMAKE_CLOSURE fn=1,type=4\nPOP\nRET",
sig(&[], &[]),
vec![],
),
("GET_CAPTURE 0\nRET", sig(&[], &[0]), vec![prometeu_bytecode::registry::TypeId(0)]),
("PUSH_I32 0\nRET", sig(&[], &[0]), vec![]),
]);
for _ in 0..3 {
v.step(&mut Native, &mut HostContext::new(None)).unwrap();
}
v.budget.test_lower_limit(RuntimeResource::TemporaryBytes, 0);
let sources = v.operand_stack.as_slice().to_vec();
let count = v.heap.allocation_count();
let before = v.cycles;
assert!(
matches!(v.step(&mut Native,&mut HostContext::new(None)),Err(LogicalFrameEndingReason::Trap(t)) if t.code==TRAP_RESOURCE_LIMIT)
);
assert_eq!(v.cycles - before, 9);
assert_eq!(v.operand_stack.as_slice(), sources);
assert_eq!(v.heap.allocation_count(), count);
assert_eq!(v.budget.used(RuntimeResource::TemporaryBytes), 0);
}
#[test]
fn root_return_gc_roots_fn_result_before_collecting() {
let mut v = vm(&[
("PUSH_I32 55\nMAKE_CLOSURE fn=1,type=4\nRET", sig(&[], &[4]), vec![]),
("GET_CAPTURE 0\nRET", sig(&[], &[0]), vec![prometeu_bytecode::registry::TypeId(0)]),
]);
v.gc_alloc_threshold = 1;
assert_eq!(run(&mut v, 1000).reason, LogicalFrameEndingReason::EndOfRom);
assert_eq!(v.heap.len(), 1);
assert_eq!(v.call_stack.len(), 0);
let Value::HeapRef(owner) = v.operand_stack[0] else { panic!() };
assert!(v.heap.is_valid(owner));
assert_eq!(v.heap.closure_env_slice(owner).unwrap(), &[Value::Int32(55)]);
}
#[test]
fn unreachable_closure_cell_cycle_is_collected_at_sync() {
let mut v = vm(&[
(
"STRUCT_NEW 15\nDUP\nMAKE_CLOSURE fn=1,type=4\nSTRUCT_SET type=15,field=0\nFRAME_SYNC\nRET",
sig(&[], &[]),
vec![],
),
("PUSH_I32 1\nRET", sig(&[], &[0]), vec![prometeu_bytecode::registry::TypeId(15)]),
]);
v.gc_alloc_threshold = 1;
assert_eq!(run(&mut v, 1000).reason, LogicalFrameEndingReason::FrameSync);
assert_eq!(v.heap.allocation_count(), 2);
assert_eq!(v.heap.len(), 0);
assert_eq!(v.budget.used(RuntimeResource::GuestBytes), 0);
}
#[test]
fn mixed_trait_dynamic_string_vec2_captures_survive_sync_and_root_return() {
use prometeu_bytecode::registry::*;
let root = "STRUCT_NEW 5\nREF_TO_TRAIT source=5,target=7\nPUSH_F64 f64:0x3ff0000000000000\nPUSH_F64 f64:0x4000000000000000\nDYN_PACK 2\nPUSH_CONST 0\nPUSH_F64 f64:0x4008000000000000\nPUSH_F64 f64:0x4010000000000000\nMAKE_CLOSURE fn=1,type=17\nCALL_CLOSURE 17\nRET";
let bodies = [
(root, sig(&[], &[7, 11, 3, 2]), vec![]),
(
"FRAME_SYNC\nGET_CAPTURE 0\nGET_CAPTURE 1\nGET_CAPTURE 2\nGET_CAPTURE 3\nRET",
sig(&[], &[7, 11, 3, 2]),
vec![TypeId(7), TypeId(11), TypeId(3), TypeId(2)],
),
("PUSH_I32 0\nRET", sig(&[5], &[0]), vec![]),
];
let implementation =
ImplementationDecl { owner: TypeId(5), trait_id: TypeId(7), methods: vec![FunctionId(2)] };
let image = image_constants(
&bodies,
vec![implementation],
&[prometeu_bytecode::model::ConstantPoolEntry::String("native capture".into())],
)
.unwrap();
let mut v = VirtualMachine::from_image(image, RuntimeLimits::default());
v.prepare_boot_call().unwrap();
v.gc_alloc_threshold = 1;
assert_eq!(run(&mut v, 1000).reason, LogicalFrameEndingReason::FrameSync);
assert_eq!(v.heap.len(), 3);
assert_eq!(run(&mut v, 1000).reason, LogicalFrameEndingReason::EndOfRom);
let values = v.operand_stack.as_slice();
assert_eq!(values.len(), 7);
assert_eq!(values[4], Value::string("native capture"));
assert_eq!(values[5..], [Value::Float(3.), Value::Float(4.)]);
let registry = v.validated_image.as_ref().unwrap().registry();
crate::value_contract::validate(registry, &v.heap, TypeId(7), &values[..2]).unwrap();
crate::value_contract::validate(registry, &v.heap, TypeId(11), &values[2..4]).unwrap();
}
#[test]
fn fn_snapshot_is_not_a_guest_root_or_an_import_authority() {
use prometeu_bytecode::registry::TypeId;
let mut v = vm(&[
("MAKE_CLOSURE fn=1,type=4\nRET", sig(&[], &[4]), vec![]),
("PUSH_I32 73\nRET", sig(&[], &[0]), vec![]),
("RET", sig(&[], &[]), vec![]),
]);
v.gc_alloc_threshold = 1;
assert_eq!(run(&mut v, 1000).reason, LogicalFrameEndingReason::EndOfRom);
let snapshot = v.operand_stack_top(1);
let Value::HeapRef(owner) = snapshot[0] else { panic!() };
v.prepare_call("2").unwrap();
v.heap.alloc_typed_closure(1, TypeId(4), &[]).unwrap();
assert_eq!(run(&mut v, 1000).reason, LogicalFrameEndingReason::EndOfRom);
assert!(!v.heap.is_valid(owner));
let other =
image(&[("GET_LOCAL 0\nCALL_CLOSURE 4\nRET", sig(&[4], &[0]), vec![])], vec![]).unwrap();
let mut other = VirtualMachine::from_image(other, RuntimeLimits::default());
assert!(matches!(
other.prepare_call_with_args("0", &snapshot),
Err(VmInitError::EntrypointArgumentsInvalid { trap_code: TRAP_INVALID_HANDLE, .. })
));
assert_eq!(other.call_stack.len(), 0);
}
#[test]
fn malformed_trait_views_trap_once_and_preserve_sources() {
use prometeu_bytecode::registry::*;
let bodies = [
("GET_GLOBAL 0\nGET_GLOBAL 1\nCALL_TRAIT type=7,method=0\nRET", sig(&[], &[0]), vec![]),
("PUSH_I32 1\nRET", sig(&[5], &[0]), vec![]),
];
let implementation =
ImplementationDecl { owner: TypeId(5), trait_id: TypeId(7), methods: vec![FunctionId(1)] };
let image = image(&bodies, vec![implementation]).unwrap();
for case in 0..5 {
let mut v = VirtualMachine::from_image(image.clone(), RuntimeLimits::default());
v.prepare_boot_call().unwrap();
let wrong = v.heap.allocate_typed_struct(image.registry().clone(), TypeId(8)).unwrap();
let (values, expected) = match case {
0 => ([Value::Null, Value::Null], TRAP_NULL_REFERENCE),
1 => (
[Value::HeapRef(HeapRef { index: 99, generation: 1 }), Value::Int64(0)],
TRAP_INVALID_HANDLE,
),
2 => ([Value::HeapRef(wrong), Value::Int64(0)], TRAP_TYPE),
3 => ([Value::Null, Value::Int64(99)], TRAP_TYPE),
_ => ([Value::HeapRef(wrong), Value::Int32(0)], TRAP_TYPE),
};
v.globals.extend_from_slice(&values).unwrap();
for _ in 0..2 {
v.step(&mut Native, &mut HostContext::new(None)).unwrap();
}
let sources = v.operand_stack.as_slice().to_vec();
let before = v.cycles;
assert!(
matches!(v.step(&mut Native,&mut HostContext::new(None)),Err(LogicalFrameEndingReason::Trap(t)) if t.code==expected)
);
assert_eq!(v.cycles - before, 6);
assert_eq!(v.operand_stack.as_slice(), sources);
assert_eq!(v.call_stack.len(), 1);
}
}
#[test]
fn recursive_fn_calls_use_bounded_ordinary_frames() {
let mut v = session(
&[
("MAKE_CLOSURE fn=1,type=9\nCALL_CLOSURE 9\nRET", sig(&[], &[]), vec![]),
("MAKE_CLOSURE fn=1,type=9\nCALL_CLOSURE 9\nRET", sig(&[], &[]), vec![]),
],
RuntimeLimits::default().lowered(RuntimeResource::CallDepth, 4).unwrap(),
);
assert!(
matches!(run(&mut v,1000).reason,LogicalFrameEndingReason::Trap(t) if t.code==TRAP_RESOURCE_LIMIT && t.opcode==0x53)
);
assert_eq!(v.call_stack.len(), 4);
}
@@ -51,11 +51,8 @@ fn new_attempt_costs_budget_and_transactional_refusal() {
let (vm, result) = attempt("ARRAY_NEW 12", std::slice::from_ref(&length), limits, cost);
trap(result, fault);
assert_eq!(vm.operand_stack.as_slice(), &[length]);
assert_eq!(
vm.budget.used(RuntimeResource::GuestBytes),
size_of::<crate::heap::StoredObject>() as u64
);
assert_eq!(vm.budget.used(RuntimeResource::HandleSlots), 1);
assert_eq!(vm.budget.used(RuntimeResource::GuestBytes), 0);
assert_eq!(vm.budget.used(RuntimeResource::HandleSlots), 0);
}
let mut vm = vm("PUSH_I64 10\nARRAY_NEW 12\nHALT", RuntimeLimits::default());
vm.step(&mut Native, &mut HostContext::new(None)).unwrap();
@@ -208,6 +205,9 @@ fn provisional_allocation_and_handle_refusals_publish_nothing() {
v.step(&mut Native, &mut HostContext::new(None)).unwrap();
// Test-only accounting state: lower the resource ceiling to current usage
// after boot, without changing any production constructor/check.
if quota == RuntimeResource::TemporaryBytes {
v.heap.allocate_object(crate::object::ObjectKind::Bytes, &[]).unwrap();
}
let current = v.budget.used(quota);
v.budget.test_lower_limit(quota, current);
let guest = v.budget.used(RuntimeResource::GuestBytes);
@@ -234,7 +234,7 @@ fn provisional_allocation_and_handle_refusals_publish_nothing() {
);
assert_eq!(v.budget.used(RuntimeResource::GuestBytes), guest);
assert_eq!(v.operand_stack.as_slice(), &[Value::Int64(10)]);
assert_eq!(v.heap.len(), 1);
assert_eq!(v.heap.len(), 0);
}
#[test]
fn rooted_native_owners_boxes_traits_and_cycles_survive_then_reclaim_at_real_safepoints() {
@@ -268,7 +268,7 @@ fn rooted_native_owners_boxes_traits_and_cycles_survive_then_reclaim_at_real_saf
LogicalFrameEndingReason::FrameSync
);
assert!(!v.heap.is_valid(node));
assert_eq!(v.heap.len(), 1);
assert_eq!(v.heap.len(), 0);
assert_eq!(v.budget.used(RuntimeResource::StringBytes), 0);
assert_eq!(v.budget.used(RuntimeResource::StringAllocations), 0);
assert_eq!(v.heap.concrete_type(node, &registry), Err(ValueError::InvalidHandle));
@@ -399,23 +399,18 @@ fn malformed_trait_and_dynamic_stores_reject_the_whole_group() {
}
#[test]
fn legacy_verifier_rejects_every_collection_even_when_unreachable() {
fn typed_loader_rejects_out_of_registry_collections_even_when_unreachable() {
for text in [
"STRUCT_NEW 9",
"STRUCT_GET type=9, field=0",
"STRUCT_SET type=9, field=0",
"ARRAY_NEW 11",
"ARRAY_LEN 11",
"ARRAY_GET 11",
"ARRAY_SET 11",
"STRUCT_NEW 99",
"STRUCT_GET type=99,field=0",
"STRUCT_SET type=99,field=0",
"ARRAY_NEW 99",
"ARRAY_LEN 99",
"ARRAY_GET 99",
"ARRAY_SET 99",
] {
let code = assemble(&format!("HALT\n{text}")).unwrap();
let f =
prometeu_bytecode::FunctionMeta { code_len: code.len() as u32, ..Default::default() };
assert!(matches!(
crate::verifier::Verifier::verify(&code, &[f]),
Err(crate::verifier::VerifierError::RegistryRequired { pc: 2, .. })
));
assert!(support::load(&code).is_err());
}
}
#[test]
@@ -2,114 +2,33 @@ use super::*;
impl VirtualMachine {
pub(super) fn handle_safepoint(&mut self) -> Result<(), ResourceFailure> {
if self.gc_alloc_threshold > 0 {
let live_now = self.heap.len();
let since_last = live_now.saturating_sub(self.last_gc_live_count);
if since_last >= self.gc_alloc_threshold {
// Parameters/locals are already in the operand buffer. Stream roots
// without a duplicate collection; suspended contexts are scanned by Heap.
let roots = self
.operand_stack
.iter()
.chain(self.globals.iter())
.filter_map(crate::roots::value_heap_ref)
.chain(self.current_coro);
self.heap.mark_session_roots(roots)?;
self.heap.sweep();
self.last_gc_live_count = self.heap.len();
}
if self.gc_alloc_threshold > 0
&& self.heap.len().saturating_sub(self.last_gc_live_count) >= self.gc_alloc_threshold
{
let roots = self
.operand_stack
.iter()
.chain(self.globals.iter())
.filter_map(crate::roots::value_heap_ref)
.chain(self.call_stack.iter().filter_map(|frame| frame.closure));
self.heap.mark_session_roots(roots)?;
self.heap.sweep();
self.last_gc_live_count = self.heap.len();
}
if let Some(strings) = &self.strings {
strings.reconcile();
}
self.current_tick = self.current_tick.wrapping_add(1);
self.scheduler.wake_ready(self.current_tick)?;
let mut switched_out = false;
if let Some(cur) = self.current_coro {
if let Some(wake) = self.sleep_requested_until {
self.scheduler.sleep_until(cur, wake)?;
self.sleep_requested_until = None;
if let Some(co) = self.heap.coroutine_data_mut(cur) {
co.pc = self.pc;
co.stack = self.operand_stack.take();
co.frames = self.call_stack.take();
co.state = CoroutineState::Sleeping;
co.wake_tick = wake;
}
self.current_coro = None;
self.scheduler.clear_current();
switched_out = true;
} else if self.yield_requested {
self.scheduler.enqueue_ready(cur)?;
if let Some(co) = self.heap.coroutine_data_mut(cur) {
co.pc = self.pc;
co.stack = self.operand_stack.take();
co.frames = self.call_stack.take();
co.state = CoroutineState::Ready;
}
self.current_coro = None;
self.scheduler.clear_current();
switched_out = true;
} else if self.halted || self.pc >= self.program.rom.len() {
if let Some(co) = self.heap.coroutine_data_mut(cur) {
co.pc = self.pc;
co.stack = self.operand_stack.take();
co.frames = self.call_stack.take();
co.state = CoroutineState::Finished;
}
self.current_coro = None;
self.scheduler.clear_current();
switched_out = true;
}
}
if self.current_coro.is_none() {
if let Some(next) = self.scheduler.dequeue_next() {
if let Some(co) = self.heap.coroutine_data_mut(next) {
self.pc = co.pc;
self.operand_stack = co.stack.take();
self.call_stack = co.frames.take();
co.state = CoroutineState::Running;
}
self.current_coro = Some(next);
self.scheduler.set_current(self.current_coro);
} else if switched_out && !self.scheduler.has_sleeping() {
self.halted = true;
}
} else {
self.scheduler.set_current(self.current_coro);
}
self.yield_requested = false;
Ok(())
}
pub fn visit_roots<V: RootVisitor + ?Sized>(&self, visitor: &mut V) {
for value in &self.operand_stack {
for value in self.operand_stack.iter().chain(self.globals.iter()) {
visit_value_for_roots(value, visitor);
}
for frame in &self.call_stack {
if let Some(func_meta) = self.program.functions.get(frame.func_idx) {
let start = frame.stack_base;
let frame_slots =
(func_meta.param_slots as usize) + (func_meta.local_slots as usize);
let mut end = start.saturating_add(frame_slots);
if end > self.operand_stack.len() {
end = self.operand_stack.len();
}
for index in start..end {
if let Some(value) = self.operand_stack.get(index) {
visit_value_for_roots(value, visitor);
}
}
if let Some(closure) = frame.closure {
visitor.visit_heap_ref(closure);
}
}
for global in &self.globals {
visit_value_for_roots(global, visitor);
}
}
}
@@ -1,128 +1,15 @@
use super::*;
fn patch_module_hostcalls(
module: &mut BytecodeModule,
capabilities: prometeu_hal::syscalls::CapFlags,
) -> Result<(), LoaderPatchError> {
let resolved =
prometeu_hal::syscalls::resolve_declared_program_syscalls(&module.syscalls, capabilities)
.map_err(LoaderPatchError::ResolveFailed)?;
let mut used = vec![false; module.syscalls.len()];
let mut pc = 0usize;
while pc < module.code.len() {
let instr = decode_next(pc, &module.code).map_err(LoaderPatchError::DecodeFailed)?;
let next_pc = instr.next_pc;
match instr.opcode {
OpCode::Hostcall => {
let sysc_index = instr.imm_u32().map_err(LoaderPatchError::DecodeFailed)?;
let Some(resolved_syscall) = resolved.get(sysc_index as usize) else {
return Err(LoaderPatchError::HostcallIndexOutOfBounds {
pc,
sysc_index,
syscalls_len: resolved.len(),
});
};
used[sysc_index as usize] = true;
module.code[pc..pc + 2].copy_from_slice(&(OpCode::Syscall as u16).to_le_bytes());
module.code[pc + 2..pc + 6].copy_from_slice(&resolved_syscall.id.to_le_bytes());
}
OpCode::Syscall => {
return Err(LoaderPatchError::RawSyscallInPreloadArtifact {
pc,
syscall_id: instr.imm_u32().map_err(LoaderPatchError::DecodeFailed)?,
});
}
_ => {}
}
pc = next_pc;
}
for (index, (was_used, decl)) in used.iter().zip(&module.syscalls).enumerate() {
if !was_used {
return Err(LoaderPatchError::UnusedSyscallDecl {
sysc_index: index as u32,
module: decl.module.clone(),
name: decl.name.clone(),
version: decl.version,
});
}
}
let mut pc = 0usize;
while pc < module.code.len() {
let instr = decode_next(pc, &module.code).map_err(LoaderPatchError::DecodeFailed)?;
if instr.opcode == OpCode::Hostcall {
return Err(LoaderPatchError::HostcallRemaining {
pc,
sysc_index: instr.imm_u32().map_err(LoaderPatchError::DecodeFailed)?,
});
}
pc = instr.next_pc;
}
Ok(())
}
impl VirtualMachine {
/// Load only the bounded sealed-v1 image; failure leaves an empty halted session.
pub fn initialize(&mut self, program_bytes: Vec<u8>) -> Result<(), VmInitError> {
self.program = ProgramImage::default();
self.validated_image = None;
self.strings = None;
self.pc = 0;
self.operand_stack.clear();
self.call_stack.clear();
self.globals.clear();
self.heap = Heap::with_budget(&self.budget);
self.cycles = 0;
self.halted = true;
self.last_gc_live_count = 0;
self.current_tick = 0;
self.sleep_requested_until = None;
self.scheduler = Scheduler::with_budget(&self.budget);
self.current_coro = None;
let program = match prometeu_bytecode::BytecodeLoader::load(&program_bytes) {
Ok(mut module) => {
patch_module_hostcalls(&mut module, self.capabilities)
.map_err(VmInitError::LoaderPatchFailed)?;
let max_stacks = Verifier::verify(&module.code, &module.functions)
.map_err(VmInitError::VerificationFailed)?;
let mut program = ProgramImage::from(module);
let mut functions = program.functions.as_ref().to_vec();
for (func, max_stack) in functions.iter_mut().zip(max_stacks) {
func.max_stack_slots = max_stack;
}
program.functions = std::sync::Arc::from(functions);
program
}
Err(prometeu_bytecode::LoadError::InvalidVersion) => {
return Err(VmInitError::UnsupportedFormat);
}
Err(prometeu_bytecode::LoadError::InvalidMagic) => {
return Err(VmInitError::InvalidFormat);
}
Err(prometeu_bytecode::LoadError::UnexpectedEof) if program_bytes.len() < 32 => {
return Err(VmInitError::InvalidFormat);
}
Err(e) => return Err(VmInitError::ImageLoadFailed(e)),
};
let pc = program
.functions
.first()
.map(|f| f.code_offset as usize)
.ok_or(VmInitError::EntrypointNotFound)?;
self.program = program;
self.pc = pc;
self.halted = false;
let caps = self.capabilities;
let limits = self.budget.limits().clone();
*self = Self::empty(limits.clone());
self.capabilities = caps;
let mut load = prometeu_bytecode::load_limits::LoadBudget::new(Default::default());
let image = crate::ValidatedProgramImage::load(&program_bytes, &mut load, caps)?;
*self = Self::from_image(image, limits);
Ok(())
}
@@ -153,7 +40,11 @@ impl VirtualMachine {
.map(|export| export.func_idx as usize)
.ok_or(VmInitError::EntrypointNotFound)?
} else {
self.program.exports.get(entrypoint).map(|&idx| idx as usize).ok_or(()).unwrap_or(0)
self.program
.exports
.get(entrypoint)
.map(|&idx| idx as usize)
.ok_or(VmInitError::EntrypointNotFound)?
};
self.prepare_call_by_index(func_idx, arguments)
@@ -164,7 +55,28 @@ impl VirtualMachine {
func_idx: usize,
arguments: &[Value],
) -> Result<(), VmInitError> {
#[cfg(not(test))]
if self.validated_image.is_none() {
return Err(VmInitError::EntrypointNotFound);
}
if self.validated_image.is_some() {
if self
.validated_image
.as_ref()
.unwrap()
.registry()
.declarations()
.functions
.get(func_idx)
.is_some_and(|f| !f.captures.is_empty())
{
return Err(prometeu_bytecode::load_limits::LoadFailure::new(
prometeu_bytecode::load_limits::LoadCode::InvalidEntrypoint,
prometeu_bytecode::load_limits::LoadReason::CapturedDirectCall,
)
.in_function(func_idx as u32, None)
.into());
}
self.check_signature_group(func_idx, false, arguments).map_err(|(slot, error)| {
if self.program.functions.get(func_idx).is_none() {
VmInitError::EntrypointNotFound
@@ -192,13 +104,6 @@ impl VirtualMachine {
.prepare_growth(total_slots.saturating_sub(self.operand_stack.len()))?;
let frame_growth =
self.call_stack.prepare_growth(1usize.saturating_sub(self.call_stack.len()))?;
let main_href = self.heap.allocate_coroutine(
callee.code_offset as usize,
CoroutineState::Running,
0,
BudgetVec::new(&self.budget, RuntimeResource::AuxiliaryBytes),
BudgetVec::new(&self.budget, RuntimeResource::AuxiliaryBytes),
)?;
self.operand_stack.commit_growth(stack_growth);
self.call_stack.commit_growth(frame_growth);
self.pc = callee.code_offset as usize;
@@ -223,10 +128,9 @@ impl VirtualMachine {
return_pc: self.program.rom.len() as u32,
stack_base: 0,
func_idx,
closure: None,
})?;
self.current_coro = Some(main_href);
self.scheduler.set_current(self.current_coro);
Ok(())
}
}
@@ -36,6 +36,7 @@ fn function(
max: u32,
) -> FunctionDecl {
FunctionDecl {
captures: vec![],
name: Some(format!("f{offset}")),
code_offset: offset as u32,
code_len: len as u32,
@@ -162,7 +163,7 @@ fn decoded_dynamic_scalar_string_reference_and_null_paths_have_exact_attempt_cos
let mut vm = dynamic_vm(OpCode::DynCanUnpack, target, 2, 1, RuntimeLimits::default());
load_globals_and_step(&mut vm, &[Value::Null, Value::Null]).unwrap();
assert_eq!(vm.operand_stack.as_slice(), &[Value::Boolean(expected)]);
assert_eq!(vm.heap.len(), 1); // Only the entry coroutine, no query allocation.
assert_eq!(vm.heap.len(), 0); // Only the entry coroutine, no query allocation.
}
}
@@ -199,7 +200,7 @@ fn decoded_dynamic_box_roundtrip_and_identity_never_nest_boxes() {
vm.step(&mut Native, &mut HostContext::new(None)).unwrap();
assert_eq!(vm.cycles - before, 4);
assert_eq!(vm.operand_stack.as_slice(), values.as_slice());
assert_eq!(vm.heap.len(), 2);
assert_eq!(vm.heap.len(), 1);
}
}
@@ -231,7 +232,7 @@ fn decoded_trait_box_is_the_only_receiver_root_across_frame_sync_gc() {
));
assert!(vm.heap.is_valid(receiver));
assert!(vm.heap.is_valid(box_handle));
assert_eq!(vm.heap.len(), 3); // Coroutine, immutable box and its receiver.
assert_eq!(vm.heap.len(), 2); // Immutable box and its receiver.
vm.step(&mut Native, &mut HostContext::new(None)).unwrap();
assert_eq!(vm.operand_stack.as_slice(), &[Value::HeapRef(receiver), Value::Int64(0)]);
vm.step(&mut Native, &mut HostContext::new(None)).unwrap();
@@ -244,7 +245,7 @@ fn decoded_trait_box_is_the_only_receiver_root_across_frame_sync_gc() {
));
assert!(!vm.heap.is_valid(receiver));
assert!(!vm.heap.is_valid(box_handle));
assert_eq!(vm.heap.len(), 1);
assert_eq!(vm.heap.len(), 0);
}
#[test]
@@ -274,7 +275,7 @@ fn decoded_box_quota_failure_leaves_unpacked_values_rooted_and_unchanged() {
5,
2,
2,
RuntimeLimits::default().lowered(RuntimeResource::HandleSlots, 1).unwrap(),
RuntimeLimits::default().lowered(RuntimeResource::HandleSlots, 0).unwrap(),
);
let input = [Value::Float(1.), Value::Float(2.)];
let guest_before = vm.budget.used(RuntimeResource::GuestBytes);
@@ -282,7 +283,7 @@ fn decoded_box_quota_failure_leaves_unpacked_values_rooted_and_unchanged() {
matches!(load_globals_and_step(&mut vm,&input),Err(LogicalFrameEndingReason::Trap(info)) if info.code==TRAP_RESOURCE_LIMIT)
);
assert_eq!(vm.operand_stack.as_slice(), &input);
assert_eq!(vm.heap.len(), 1);
assert_eq!(vm.heap.len(), 0);
assert_eq!(vm.budget.used(RuntimeResource::GuestBytes), guest_before);
}
@@ -389,7 +390,7 @@ fn decoded_null_queries_are_false_and_null_conversions_are_absent() {
_ => vec![Value::Null],
};
assert_eq!(vm.operand_stack.as_slice(), expected.as_slice());
assert_eq!(vm.heap.len(), 1);
assert_eq!(vm.heap.len(), 0);
}
}
}
@@ -460,7 +461,7 @@ fn decoded_stale_handle_is_an_invalid_handle_even_when_target_type_differs() {
let mut vm = reference_vm(operation, 9, target);
let registry = vm.validated_image.as_ref().unwrap().registry().clone();
let receiver = vm.heap.allocate_typed_struct(registry, TypeId(9)).unwrap();
vm.heap.mark_from_roots(vm.current_coro).unwrap();
vm.heap.mark_from_roots([]).unwrap();
vm.heap.sweep();
let input = [Value::HeapRef(receiver)];
assert!(
@@ -553,19 +554,26 @@ fn native_string_failures_cannot_publish_partial_results_even_if_handler_ignores
Ok(())
}
}
let mut code = vec![];
arg(&mut code, OpCode::Syscall, prometeu_hal::syscalls::Syscall::SystemHasCart as u32);
let mut vm = VirtualMachine::with_runtime_limits(
code,
vec![],
let code = prometeu_bytecode::assemble("HOSTCALL 0\nHALT").unwrap();
let mut program =
prometeu_test_support::program::TestProgram::single(code, Default::default(), 0, 1);
program.syscalls = vec![prometeu_bytecode::model::SyscallDecl {
module: "system".into(),
name: "has_cart".into(),
version: 1,
arg_slots: 0,
ret_slots: 1,
}];
let image = crate::ValidatedProgramImage::load(
&program.serialize(),
&mut LoadBudget::new(Default::default()),
prometeu_hal::syscalls::caps::SYSTEM,
)
.unwrap();
let mut vm = VirtualMachine::from_image(
image,
RuntimeLimits::default().lowered(RuntimeResource::StringBytes, 2).unwrap(),
);
vm.program.functions = Arc::from(vec![prometeu_bytecode::FunctionMeta {
code_len: 6,
max_stack_slots: 1,
..Default::default()
}]);
vm.set_capabilities(prometeu_hal::syscalls::caps::SYSTEM);
vm.prepare_boot_call().unwrap();
let report = vm.run_budget(100, &mut ReturnsString, &mut HostContext::new(None)).unwrap();
// This synthetic native implementation tests the bounded writer, not the