feat(vm): add typed array and struct guest operations
Intrepid/Prometeu/Runtime/pipeline/pr-master This commit looks good

Add seven Registry-backed collection opcodes with bounded verification, complete value groups, transactional publication and exact attempt costs. Publish ISA, memory and cycle contracts, producer handoff and the completed lesson.

Validate with 925 workspace tests, optimized collection suites and all eight coverage domain gates. Make headless fixture directory names unique for parallel tests.
This commit is contained in:
2026-10-08 10:36:20 +01:00
parent 8732f4b0f4
commit 86bade3e1f
27 changed files with 1591 additions and 46 deletions
+77 -31
View File
@@ -3,6 +3,7 @@ use crate::call_frame::CallFrame;
use crate::object::{ObjectHeader, ObjectKind};
use crate::resource_budget::{
BudgetVec, Reservation, ResourceFailure, ResourceReason, RuntimeBudget, RuntimeResource as Q,
VecGrowth,
};
use crate::typed_storage::TypedStorage;
use crate::value_contract::{self, ValueError, ValueGroup};
@@ -62,6 +63,19 @@ impl StoredAllocation {
}
}
// Candidate allocations own all reservations until a fully initialized object
// is published. Dropping the candidate leaves handle tables unchanged.
struct PreparedInsertion {
storage: BudgetVec<StoredObject>,
new_slot: Option<PreparedSlot>,
}
struct PreparedSlot {
charge: Reservation,
objects: Option<VecGrowth<Option<StoredAllocation>>>,
generations: Option<VecGrowth<u32>>,
free: Option<VecGrowth<usize>>,
}
/// Execution state of a coroutine.
#[derive(Debug, Copy, Clone, Eq, PartialEq)]
pub enum CoroutineState {
@@ -157,24 +171,35 @@ impl Heap {
Ok(())
}
fn insert_object(&mut self, obj: StoredObject) -> Result<HeapRef, ResourceFailure> {
fn prepare_insertion(&self) -> Result<PreparedInsertion, ResourceFailure> {
self.check_slot()?;
let mut storage = BudgetVec::new(&self.budget, Q::GuestBytes);
storage.push(obj)?;
let obj = StoredAllocation(storage);
let bytes = obj.bytes();
let handle = if let Some(&idx) = self.free_list.last() {
self.free_list.pop();
debug_assert!(self.objects[idx].is_none());
self.objects[idx] = Some(obj);
HeapRef { index: idx as u32, generation: self.generations[idx] }
storage.reserve(1)?;
let new_slot = if self.free_list.is_empty() {
Some(PreparedSlot {
charge: self.budget.reserve(Q::HandleSlots, 1)?,
objects: self.objects.prepare_growth(1)?,
generations: self.generations.prepare_growth(1)?,
free: self
.free_list
.prepare_growth(self.objects.len() + 1 - self.free_list.len())?,
})
} else {
let slot_charge = self.budget.reserve(Q::HandleSlots, 1)?;
// Stage all three capacities. Failure drops the candidate buffers and
// object, without publishing a slot or retaining partial table growth.
let objects = self.objects.prepare_growth(1)?;
let generations = self.generations.prepare_growth(1)?;
let free =
self.free_list.prepare_growth(self.objects.len() + 1 - self.free_list.len())?;
None
};
Ok(PreparedInsertion { storage, new_slot })
}
fn insert_object(&mut self, obj: StoredObject) -> Result<HeapRef, ResourceFailure> {
let prepared = self.prepare_insertion()?;
Ok(self.commit_insertion(prepared, obj))
}
fn commit_insertion(&mut self, mut prepared: PreparedInsertion, obj: StoredObject) -> HeapRef {
prepared.storage.push(obj).expect("object header reserved before initialization");
let obj = StoredAllocation(prepared.storage);
let bytes = obj.bytes();
let handle = if let Some(PreparedSlot { charge: slot_charge, objects, generations, free }) =
prepared.new_slot
{
self.objects.commit_growth(objects);
self.generations.commit_growth(generations);
self.free_list.commit_growth(free);
@@ -183,10 +208,15 @@ impl Heap {
self.generations.push(1).expect("reserved generation slot");
self.slots_charge.absorb(slot_charge);
HeapRef { index: idx as u32, generation: 1 }
} else {
let idx = self.free_list.pop().expect("reserved reusable handle");
debug_assert!(self.objects[idx].is_none());
self.objects[idx] = Some(obj);
HeapRef { index: idx as u32, generation: self.generations[idx] }
};
self.used_bytes.fetch_add(bytes, Ordering::Relaxed);
self.allocation_count.fetch_add(1, Ordering::Relaxed);
Ok(handle)
handle
}
#[cfg(test)]
@@ -523,14 +553,26 @@ impl Heap {
}
Ok(storage.type_id())
}
pub(crate) fn typed_array_len(
&self,
r: HeapRef,
registry: &Registry,
) -> Result<usize, ValueError> {
self.concrete_type(r, registry)?;
let storage = self.typed_object(r)?;
if registry.type_layout(storage.type_id()).unwrap().array.is_none() {
return Err(ValueError::Type);
}
Ok(storage.len())
}
pub(crate) fn allocate_typed_struct(
&mut self,
registry: Arc<Registry>,
type_id: TypeId,
) -> Result<HeapRef, ValueError> {
self.check_slot()?;
let prepared = self.prepare_insertion()?;
let storage = TypedStorage::new_struct(registry, type_id, &self.budget)?;
self.insert_typed(ObjectKind::Struct, 0, storage)
Ok(self.insert_typed(prepared, ObjectKind::Struct, 0, storage))
}
pub(crate) fn allocate_typed_array(
&mut self,
@@ -538,25 +580,29 @@ impl Heap {
type_id: TypeId,
count: u32,
) -> Result<HeapRef, ValueError> {
self.check_slot()?;
let prepared = self.prepare_insertion()?;
let storage = TypedStorage::new_array(registry, type_id, count, &self.budget)?;
self.insert_typed(ObjectKind::Array, count, storage)
Ok(self.insert_typed(prepared, ObjectKind::Array, count, storage))
}
fn insert_typed(
&mut self,
prepared: PreparedInsertion,
kind: ObjectKind,
count: u32,
storage: TypedStorage,
) -> Result<HeapRef, ValueError> {
Ok(self.insert_object(StoredObject {
header: ObjectHeader::new(kind, count),
payload: BudgetVec::new(&self.budget, Q::GuestBytes),
array_elems: None,
closure_env: None,
coroutine: None,
typed: Some(storage),
dynamic_box: None,
})?)
) -> HeapRef {
self.commit_insertion(
prepared,
StoredObject {
header: ObjectHeader::new(kind, count),
payload: BudgetVec::new(&self.budget, Q::GuestBytes),
array_elems: None,
closure_env: None,
coroutine: None,
typed: Some(storage),
dynamic_box: None,
},
)
}
pub(crate) fn load_typed(
&self,