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;
|
use crate::resource_budget::BudgetVec;
|
||||||
|
mod dynamic;
|
||||||
mod gc;
|
mod gc;
|
||||||
mod loader;
|
mod loader;
|
||||||
mod runtime;
|
mod runtime;
|
||||||
@@ -1358,13 +1359,12 @@ impl VirtualMachine {
|
|||||||
self.push_trap(value, opcode, start_pc as u32)?;
|
self.push_trap(value, opcode, start_pc as u32)?;
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
OpCode::DynPack
|
OpCode::DynPack | OpCode::DynUnpack | OpCode::DynCanUnpack => {
|
||||||
| OpCode::DynUnpack
|
self.cycles += opcode.cycles();
|
||||||
| OpCode::DynCanUnpack
|
let target = instr.imm_u32().unwrap();
|
||||||
| OpCode::RefIsExact
|
return self.execute_dynamic(opcode, target, start_pc as u32);
|
||||||
| OpCode::RefImplements
|
}
|
||||||
| OpCode::RefToTrait
|
OpCode::RefIsExact | OpCode::RefImplements | OpCode::RefToTrait | OpCode::RefCast => {
|
||||||
| OpCode::RefCast => {
|
|
||||||
// Slot-only ProgramImage cannot authorize typed instructions. The
|
// Slot-only ProgramImage cannot authorize typed instructions. The
|
||||||
// v1 image/verifier integration supplies their execution context.
|
// v1 image/verifier integration supplies their execution context.
|
||||||
self.cycles += opcode.cycles();
|
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
|
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]
|
#[test]
|
||||||
fn typed_sessions_share_image_but_have_independent_execution_and_heap() {
|
fn typed_sessions_share_image_but_have_independent_execution_and_heap() {
|
||||||
let image = image(&[1, 0], vec![function(0, 2, &[], &[], 0, 0)]);
|
let image = image(&[1, 0], vec![function(0, 2, &[], &[], 0, 0)]);
|
||||||
|
|||||||
Reference in New Issue
Block a user