feat(vm): execute Dynamic instructions and exact costs for PLN-0176 step 21

This commit is contained in:
2026-10-07 20:34:11 +01:00
parent ba603ce64a
commit c7236f1269
3 changed files with 272 additions and 7 deletions
@@ -1,4 +1,5 @@
use crate::resource_budget::BudgetVec;
mod dynamic;
mod gc;
mod loader;
mod runtime;
@@ -1358,13 +1359,12 @@ impl VirtualMachine {
self.push_trap(value, opcode, start_pc as u32)?;
}
}
OpCode::DynPack
| OpCode::DynUnpack
| OpCode::DynCanUnpack
| OpCode::RefIsExact
| OpCode::RefImplements
| OpCode::RefToTrait
| OpCode::RefCast => {
OpCode::DynPack | OpCode::DynUnpack | OpCode::DynCanUnpack => {
self.cycles += opcode.cycles();
let target = instr.imm_u32().unwrap();
return self.execute_dynamic(opcode, target, start_pc as u32);
}
OpCode::RefIsExact | OpCode::RefImplements | OpCode::RefToTrait | OpCode::RefCast => {
// Slot-only ProgramImage cannot authorize typed instructions. The
// v1 image/verifier integration supplies their execution context.
self.cycles += opcode.cycles();
@@ -0,0 +1,69 @@
use super::*;
use crate::value_contract::{self, ValueGroup};
use prometeu_bytecode::registry::TypeId;
impl VirtualMachine {
pub(super) fn execute_dynamic(
&mut self,
opcode: OpCode,
target: u32,
pc: u32,
) -> Result<(), LogicalFrameEndingReason> {
let image = self.validated_image.clone().ok_or_else(|| {
self.trap(
prometeu_bytecode::TRAP_ILLEGAL_INSTRUCTION,
opcode as u16,
"Instruction requires a validated Program Registry".into(),
pc,
)
})?;
let registry = image.registry();
let target = TypeId(target);
let width =
registry.type_layout(target).expect("validated instruction TypeId").storage.slots
as usize;
let consumed = if opcode == OpCode::DynPack { width } else { 2 };
let produced = match opcode {
OpCode::DynPack => 2,
OpCode::DynUnpack => width,
OpCode::DynCanUnpack => 1,
_ => unreachable!(),
};
if self.temporary_slots() < consumed {
return Err(self.trap(
TRAP_STACK_UNDERFLOW,
opcode as u16,
"Incomplete Dynamic source group".into(),
pc,
));
}
// Keep source roots and provisional capacity until a complete result is
// available. A refused box allocation cannot consume the source group.
let growth = self
.operand_stack
.prepare_growth(produced.saturating_sub(consumed))
.map_err(|e| self.resource_trap(e, opcode, pc))?;
let base = self.operand_stack.len() - consumed;
let values = &self.operand_stack[base..];
let result = match opcode {
OpCode::DynPack => {
value_contract::pack_dynamic(registry, &mut self.heap, target, values)
}
OpCode::DynUnpack => {
value_contract::unpack_dynamic(registry, &self.heap, target, values)
}
OpCode::DynCanUnpack => {
value_contract::can_unpack_dynamic(registry, &self.heap, target, values)
.map(|yes| ValueGroup::new(&[Value::Boolean(yes)]))
}
_ => unreachable!(),
}
.map_err(|e| self.value_trap(e, opcode, pc))?;
self.operand_stack.commit_growth(growth);
self.operand_stack.truncate(base);
self.operand_stack
.extend_from_slice(result.as_slice())
.expect("result capacity reserved before evaluation");
Ok(())
}
}
@@ -94,6 +94,202 @@ fn run(vm: &mut VirtualMachine) -> LogicalFrameEndingReason {
vm.run_budget(1000, &mut Native, &mut HostContext::new(None)).unwrap().reason
}
fn dynamic_vm(
operation: OpCode,
target: u32,
input_slots: usize,
output_slots: usize,
limits: RuntimeLimits,
) -> VirtualMachine {
let mut code = vec![];
for slot in 0..input_slots {
arg(&mut code, OpCode::GetGlobal, slot as u32);
}
arg(&mut code, operation, target);
op(&mut code, OpCode::Halt);
let image = image(
&code,
vec![function(0, code.len(), &[], &[], 0, input_slots.max(output_slots) as u32)],
);
let mut vm = VirtualMachine::from_image(image, limits);
vm.prepare_boot_call().unwrap();
vm
}
fn load_globals_and_step(
vm: &mut VirtualMachine,
inputs: &[Value],
) -> Result<(), LogicalFrameEndingReason> {
vm.globals.extend_from_slice(inputs).unwrap();
for _ in inputs {
vm.step(&mut Native, &mut HostContext::new(None)).unwrap();
}
let before = vm.cycles;
let opcode = decode_next(vm.pc, &vm.program.rom).unwrap().opcode;
let result = vm.step(&mut Native, &mut HostContext::new(None));
let expected = match opcode {
OpCode::DynPack => 8,
OpCode::DynUnpack => 4,
OpCode::DynCanUnpack => 3,
OpCode::RefIsExact | OpCode::RefImplements | OpCode::RefCast => 4,
OpCode::RefToTrait => 5,
_ => panic!("not a typed conversion"),
};
assert_eq!(vm.cycles - before, expected);
result
}
#[test]
fn decoded_dynamic_scalar_string_reference_and_null_paths_have_exact_attempt_costs() {
for (ty, value) in [
(0, Value::Int32(17)),
(1, Value::Int64(17)),
(2, Value::Float(17.)),
(3, Value::Boolean(true)),
(4, Value::String(Arc::from("shared"))),
(4, Value::Null),
(9, Value::Null),
(13, Value::Null),
] {
let mut pack = dynamic_vm(OpCode::DynPack, ty, 1, 2, RuntimeLimits::default());
load_globals_and_step(&mut pack, &[value.clone()]).unwrap();
assert_eq!(pack.operand_stack.as_slice(), &[Value::Int64(ty.into()), value.clone()]);
let pair = pack.operand_stack.as_slice();
let mut unpack = dynamic_vm(OpCode::DynUnpack, ty, 2, 1, RuntimeLimits::default());
load_globals_and_step(&mut unpack, pair).unwrap();
assert_eq!(unpack.operand_stack.as_slice(), &[value]);
}
for (target, expected) in [(0, false), (4, true), (5, false), (8, true), (11, true)] {
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.
}
}
#[test]
fn decoded_dynamic_box_roundtrip_and_identity_never_nest_boxes() {
for (ty, values) in [
(5, vec![Value::Float(1.), Value::Float(2.)]),
(7, vec![Value::Int64(-1), Value::Int64(2), Value::Int64(u32::MAX as i64)]),
] {
let mut code = vec![];
for slot in 0..values.len() {
arg(&mut code, OpCode::GetGlobal, slot as u32);
}
arg(&mut code, OpCode::DynPack, ty);
arg(&mut code, OpCode::DynPack, 8);
arg(&mut code, OpCode::DynUnpack, 8);
arg(&mut code, OpCode::DynUnpack, ty);
op(&mut code, OpCode::Halt);
let image = image(&code, vec![function(0, code.len(), &[], &[], 0, 3)]);
let mut vm = VirtualMachine::from_image(image, RuntimeLimits::default());
vm.prepare_boot_call().unwrap();
load_globals_and_step(&mut vm, &values).unwrap();
let heap_len = vm.heap.len();
let boxed = vm.operand_stack[1].clone();
for _ in 0..2 {
let opcode = decode_next(vm.pc, &vm.program.rom).unwrap().opcode;
let before = vm.cycles;
vm.step(&mut Native, &mut HostContext::new(None)).unwrap();
assert_eq!(vm.cycles - before, if opcode == OpCode::DynPack { 8 } else { 4 });
assert_eq!(vm.heap.len(), heap_len);
assert_eq!(vm.operand_stack[1], boxed);
}
let before = vm.cycles;
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);
}
}
#[test]
fn decoded_dynamic_malformed_pairs_trap_once_without_consuming_source() {
for operation in [OpCode::DynUnpack, OpCode::DynCanUnpack] {
for pair in [
vec![Value::Null, Value::Int32(3)],
vec![Value::Int64(0), Value::Boolean(true)],
vec![Value::Int64(8), Value::Null],
vec![Value::Int64(-1), Value::Null],
vec![Value::Int64(5), Value::HeapRef(HeapRef { index: 99, generation: 1 })],
] {
let mut vm = dynamic_vm(operation, 0, 2, 1, RuntimeLimits::default());
let result = load_globals_and_step(&mut vm, &pair);
assert!(
matches!(result,Err(LogicalFrameEndingReason::Trap(info)) if info.code==TRAP_TYPE || info.code==TRAP_INVALID_HANDLE)
);
assert_eq!(vm.operand_stack.as_slice(), pair.as_slice());
}
}
}
#[test]
fn decoded_box_quota_failure_leaves_unpacked_values_rooted_and_unchanged() {
let mut vm = dynamic_vm(
OpCode::DynPack,
5,
2,
2,
RuntimeLimits::default().lowered(RuntimeResource::HandleSlots, 1).unwrap(),
);
let input = [Value::Float(1.), Value::Float(2.)];
let guest_before = vm.budget.used(RuntimeResource::GuestBytes);
assert!(
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.budget.used(RuntimeResource::GuestBytes), guest_before);
}
#[test]
fn decoded_dynamic_preserves_present_struct_array_and_trait_identity_in_one_session() {
for (ty, width) in [(9, 1), (13, 1), (11, 2)] {
let mut code = vec![];
for slot in 0..width {
arg(&mut code, OpCode::GetGlobal, slot);
}
arg(&mut code, OpCode::DynPack, ty);
arg(&mut code, OpCode::DynUnpack, ty);
op(&mut code, OpCode::Halt);
let image = image(&code, vec![function(0, code.len(), &[], &[], 0, 2)]);
let registry = image.registry().clone();
let mut vm = VirtualMachine::from_image(image, RuntimeLimits::default());
vm.prepare_boot_call().unwrap();
let reference = if ty == 13 {
vm.heap.allocate_typed_array(registry, TypeId(13), 4).unwrap()
} else {
vm.heap.allocate_typed_struct(registry, TypeId(9)).unwrap()
};
let values = if width == 2 {
vec![Value::HeapRef(reference), Value::Int64(0)]
} else {
vec![Value::HeapRef(reference)]
};
let before = vm.heap.len();
load_globals_and_step(&mut vm, &values).unwrap();
assert_eq!(vm.heap.len(), before + if width == 2 { 1 } else { 0 });
let cycles = vm.cycles;
vm.step(&mut Native, &mut HostContext::new(None)).unwrap();
assert_eq!(vm.cycles - cycles, 4);
assert_eq!(vm.operand_stack.as_slice(), values.as_slice());
}
}
#[test]
fn dynamic_query_consumes_pair_and_reports_fixed_cost_through_budget_report() {
let mut vm = dynamic_vm(OpCode::DynCanUnpack, 0, 2, 1, RuntimeLimits::default());
vm.globals.extend_from_slice(&[Value::Int64(0), Value::Int32(2)]).unwrap();
for _ in 0..2 {
vm.step(&mut Native, &mut HostContext::new(None)).unwrap();
}
let report = vm.run_budget(3, &mut Native, &mut HostContext::new(None)).unwrap();
assert_eq!(report.cycles_used, 3);
assert_eq!(report.steps_executed, 1);
assert_eq!(report.reason, LogicalFrameEndingReason::BudgetExhausted);
assert_eq!(vm.operand_stack.as_slice(), &[Value::Boolean(true)]);
}
#[test]
fn typed_sessions_share_image_but_have_independent_execution_and_heap() {
let image = image(&[1, 0], vec![function(0, 2, &[], &[], 0, 0)]);