diff --git a/crates/console/prometeu-vm/src/virtual_machine.rs b/crates/console/prometeu-vm/src/virtual_machine.rs index ebce5b6..24eafdd 100644 --- a/crates/console/prometeu-vm/src/virtual_machine.rs +++ b/crates/console/prometeu-vm/src/virtual_machine.rs @@ -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(); diff --git a/crates/console/prometeu-vm/src/virtual_machine/dynamic.rs b/crates/console/prometeu-vm/src/virtual_machine/dynamic.rs new file mode 100644 index 0000000..00b894a --- /dev/null +++ b/crates/console/prometeu-vm/src/virtual_machine/dynamic.rs @@ -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(()) + } +} diff --git a/crates/console/prometeu-vm/src/virtual_machine/typed_tests.rs b/crates/console/prometeu-vm/src/virtual_machine/typed_tests.rs index ac1562d..e668102 100644 --- a/crates/console/prometeu-vm/src/virtual_machine/typed_tests.rs +++ b/crates/console/prometeu-vm/src/virtual_machine/typed_tests.rs @@ -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)]);