feat(vm): execute Dynamic instructions and exact costs for PLN-0176 step 21
This commit is contained in:
@@ -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)]);
|
||||
|
||||
Reference in New Issue
Block a user