feat(runtime): add optional pause and resume lifecycle hooks
Intrepid/Prometeu/Runtime/pipeline/pr-master Build started...
Intrepid/Prometeu/Runtime/pipeline/pr-master Build started...
This commit is contained in:
@@ -25,6 +25,7 @@ fn fixture(
|
||||
kind: TypeKind::Builtin(BuiltinId::BOOL),
|
||||
}],
|
||||
functions: vec![FunctionDecl {
|
||||
lifecycle_role: Default::default(),
|
||||
name: Some("boot".into()),
|
||||
code_len: code.len() as u32,
|
||||
max_stack_slots: max,
|
||||
|
||||
@@ -38,7 +38,12 @@ fn registry(code: &[u8], functions: Vec<FunctionDecl>) -> Registry {
|
||||
.unwrap()
|
||||
}
|
||||
fn function(code: &[u8]) -> FunctionDecl {
|
||||
FunctionDecl { code_len: code.len() as u32, max_stack_slots: 4, ..Default::default() }
|
||||
FunctionDecl {
|
||||
lifecycle_role: Default::default(),
|
||||
code_len: code.len() as u32,
|
||||
max_stack_slots: 4,
|
||||
..Default::default()
|
||||
}
|
||||
}
|
||||
fn check(code: &[u8], registry: &Registry) -> Result<(), E> {
|
||||
validate_registry_instructions(code, registry, 1, &mut LoadBudget::new(Default::default()))
|
||||
@@ -53,7 +58,14 @@ fn stack_analysis_honors_literal_zero_and_wide_pop_operands() {
|
||||
let mut code = vec![];
|
||||
arg(&mut code, Op::PushI32, 0);
|
||||
op(&mut code, Op::Halt);
|
||||
let r = registry(&code, vec![FunctionDecl { max_stack_slots: 0, ..function(&code) }]);
|
||||
let r = registry(
|
||||
&code,
|
||||
vec![FunctionDecl {
|
||||
lifecycle_role: Default::default(),
|
||||
max_stack_slots: 0,
|
||||
..function(&code)
|
||||
}],
|
||||
);
|
||||
let e = stacks(&code, &r).unwrap_err();
|
||||
assert_eq!(
|
||||
(e.reason, e.requested, e.limit, e.pc),
|
||||
@@ -78,6 +90,7 @@ fn stack_analysis_cannot_consume_parameters_or_extra_locals_as_temporaries() {
|
||||
let r = registry(
|
||||
&code,
|
||||
vec![FunctionDecl {
|
||||
lifecycle_role: Default::default(),
|
||||
local_slots: 100,
|
||||
signature: Signature {
|
||||
parameters: vec![NamedType { type_id: TypeId(1), name: None }],
|
||||
@@ -112,8 +125,14 @@ fn stack_analysis_resolves_multislot_calls_and_registry_operations() {
|
||||
let r = registry(
|
||||
&code,
|
||||
vec![
|
||||
FunctionDecl { code_len: callee as u32, max_stack_slots: 2, ..function(&code) },
|
||||
FunctionDecl {
|
||||
lifecycle_role: Default::default(),
|
||||
code_len: callee as u32,
|
||||
max_stack_slots: 2,
|
||||
..function(&code)
|
||||
},
|
||||
FunctionDecl {
|
||||
lifecycle_role: Default::default(),
|
||||
code_offset: callee as u32,
|
||||
code_len: (code.len() - callee) as u32,
|
||||
signature,
|
||||
@@ -136,6 +155,7 @@ fn stack_analysis_checks_returns_empty_bodies_and_implicit_end_branches() {
|
||||
op(&mut code, operation);
|
||||
}
|
||||
let f = FunctionDecl {
|
||||
lifecycle_role: Default::default(),
|
||||
signature: Signature { parameters: vec![], results: vec![TypeId(0)] },
|
||||
..function(&code)
|
||||
};
|
||||
@@ -172,7 +192,14 @@ fn stack_analysis_rejects_different_join_heights_and_accepts_a_bounded_loop() {
|
||||
assert_eq!(stacks(&code, &r).unwrap_err().reason, R::StackJoin);
|
||||
let mut code = vec![];
|
||||
arg(&mut code, Op::Jmp, 0);
|
||||
let r = registry(&code, vec![FunctionDecl { max_stack_slots: 0, ..function(&code) }]);
|
||||
let r = registry(
|
||||
&code,
|
||||
vec![FunctionDecl {
|
||||
lifecycle_role: Default::default(),
|
||||
max_stack_slots: 0,
|
||||
..function(&code)
|
||||
}],
|
||||
);
|
||||
assert!(stacks(&code, &r).is_ok());
|
||||
}
|
||||
|
||||
@@ -181,7 +208,14 @@ fn stack_analysis_accounts_only_reachable_transfers_but_preflights_dead_operands
|
||||
let mut code = vec![];
|
||||
op(&mut code, Op::Halt);
|
||||
arg(&mut code, Op::PopN, u32::MAX);
|
||||
let r = registry(&code, vec![FunctionDecl { max_stack_slots: 0, ..function(&code) }]);
|
||||
let r = registry(
|
||||
&code,
|
||||
vec![FunctionDecl {
|
||||
lifecycle_role: Default::default(),
|
||||
max_stack_slots: 0,
|
||||
..function(&code)
|
||||
}],
|
||||
);
|
||||
assert!(stacks(&code, &r).is_ok());
|
||||
let mut code = vec![];
|
||||
op(&mut code, Op::Halt);
|
||||
@@ -220,7 +254,12 @@ fn stack_analysis_straight_line_storage_is_bounded_by_blocks_not_instruction_fra
|
||||
op(&mut code, Op::Halt);
|
||||
let r = registry(
|
||||
&code,
|
||||
vec![FunctionDecl { local_slots: 300, max_stack_slots: 0, ..function(&code) }],
|
||||
vec![FunctionDecl {
|
||||
lifecycle_role: Default::default(),
|
||||
local_slots: 300,
|
||||
max_stack_slots: 0,
|
||||
..function(&code)
|
||||
}],
|
||||
);
|
||||
let limits = LoadLimits { temporary_bytes: 41_000, ..Default::default() };
|
||||
let mut b = LoadBudget::new(limits);
|
||||
@@ -232,6 +271,7 @@ fn stack_analysis_straight_line_storage_is_bounded_by_blocks_not_instruction_fra
|
||||
fn stack_analysis_accepts_unknown_fn_targets_and_rejects_removed_opcodes() {
|
||||
let code = prometeu_bytecode::assemble("GET_LOCAL 0\nCALL_CLOSURE 4\nHALT").unwrap();
|
||||
let f = FunctionDecl {
|
||||
lifecycle_role: Default::default(),
|
||||
signature: Signature {
|
||||
parameters: vec![NamedType { type_id: TypeId(4), name: None }],
|
||||
results: vec![],
|
||||
@@ -263,12 +303,19 @@ fn expected_fn_signature_checks_argument_height_after_permutations() {
|
||||
&code,
|
||||
vec![
|
||||
FunctionDecl {
|
||||
lifecycle_role: Default::default(),
|
||||
code_len: end as u32,
|
||||
local_slots: 1,
|
||||
max_stack_slots: 2,
|
||||
..function(&code)
|
||||
},
|
||||
FunctionDecl { signature, code_offset: end as u32, code_len: 2, ..Default::default() },
|
||||
FunctionDecl {
|
||||
lifecycle_role: Default::default(),
|
||||
signature,
|
||||
code_offset: end as u32,
|
||||
code_len: 2,
|
||||
..Default::default()
|
||||
},
|
||||
],
|
||||
);
|
||||
assert_eq!(stacks(&code, &r).unwrap_err().reason, R::StackUnderflow);
|
||||
@@ -309,12 +356,14 @@ fn stack_analysis_charges_work_for_loop_reprocessing_and_refunds_on_exhaustion()
|
||||
&code,
|
||||
vec![
|
||||
FunctionDecl {
|
||||
lifecycle_role: Default::default(),
|
||||
code_len: end as u32,
|
||||
local_slots: 1,
|
||||
max_stack_slots: 1,
|
||||
..function(&code)
|
||||
},
|
||||
FunctionDecl {
|
||||
lifecycle_role: Default::default(),
|
||||
code_offset: end as u32,
|
||||
code_len: (code.len() - end) as u32,
|
||||
max_stack_slots: 1,
|
||||
@@ -353,8 +402,13 @@ fn typed_opcodes_and_relative_jumps_are_resolved_in_declared_ranges() {
|
||||
let r = registry(
|
||||
&code,
|
||||
vec![
|
||||
FunctionDecl { code_len: start as u32, ..function(&code) },
|
||||
FunctionDecl {
|
||||
lifecycle_role: Default::default(),
|
||||
code_len: start as u32,
|
||||
..function(&code)
|
||||
},
|
||||
FunctionDecl {
|
||||
lifecycle_role: Default::default(),
|
||||
code_offset: start as u32,
|
||||
code_len: 6,
|
||||
max_stack_slots: 0,
|
||||
@@ -394,8 +448,13 @@ fn jumps_reject_cross_range_and_mid_instruction_even_when_unreachable() {
|
||||
let r = registry(
|
||||
&code,
|
||||
vec![
|
||||
FunctionDecl { code_len: 6, ..function(&code) },
|
||||
FunctionDecl { code_offset: 6, code_len: 2, ..function(&code) },
|
||||
FunctionDecl { lifecycle_role: Default::default(), code_len: 6, ..function(&code) },
|
||||
FunctionDecl {
|
||||
lifecycle_role: Default::default(),
|
||||
code_offset: 6,
|
||||
code_len: 2,
|
||||
..function(&code)
|
||||
},
|
||||
],
|
||||
);
|
||||
let e = check(&code, &r).unwrap_err();
|
||||
@@ -479,7 +538,10 @@ fn spawn_arity_does_not_truncate_and_closure_function_ids_are_checked() {
|
||||
#[test]
|
||||
fn declared_range_is_not_extended_into_gaps_or_neighbor_functions() {
|
||||
let code = vec![Op::Halt as u8, 0, 0xff, 0xff];
|
||||
let r = registry(&code, vec![FunctionDecl { code_len: 2, ..function(&code) }]);
|
||||
let r = registry(
|
||||
&code,
|
||||
vec![FunctionDecl { lifecycle_role: Default::default(), code_len: 2, ..function(&code) }],
|
||||
);
|
||||
assert!(check(&code, &r).is_ok()); // Unowned gap is outside this phase's ranges.
|
||||
let r = registry(&code, vec![function(&code)]);
|
||||
assert_eq!(check(&code, &r).unwrap_err().reason, R::UnknownOpcode);
|
||||
@@ -493,8 +555,13 @@ fn scratch_is_refunded_per_function_and_preserves_prior_load_ownership() {
|
||||
let r = registry(
|
||||
&code,
|
||||
vec![
|
||||
FunctionDecl { code_len: 2, ..function(&code) },
|
||||
FunctionDecl { code_offset: 2, code_len: 2, ..function(&code) },
|
||||
FunctionDecl { lifecycle_role: Default::default(), code_len: 2, ..function(&code) },
|
||||
FunctionDecl {
|
||||
lifecycle_role: Default::default(),
|
||||
code_offset: 2,
|
||||
code_len: 2,
|
||||
..function(&code)
|
||||
},
|
||||
],
|
||||
);
|
||||
let limits = LoadLimits { temporary_bytes: 8, ..Default::default() };
|
||||
@@ -531,8 +598,13 @@ fn truncated_immediates_cannot_borrow_bytes_from_the_next_function() {
|
||||
let r = registry(
|
||||
&code,
|
||||
vec![
|
||||
FunctionDecl { code_len: 2, ..function(&code) },
|
||||
FunctionDecl { code_offset: 2, code_len: 2, ..function(&code) },
|
||||
FunctionDecl { lifecycle_role: Default::default(), code_len: 2, ..function(&code) },
|
||||
FunctionDecl {
|
||||
lifecycle_role: Default::default(),
|
||||
code_offset: 2,
|
||||
code_len: 2,
|
||||
..function(&code)
|
||||
},
|
||||
],
|
||||
);
|
||||
let e = check(&code, &r).unwrap_err();
|
||||
|
||||
@@ -32,6 +32,7 @@ fn function(
|
||||
max: u32,
|
||||
) -> FunctionDecl {
|
||||
FunctionDecl {
|
||||
lifecycle_role: Default::default(),
|
||||
captures: vec![],
|
||||
code_offset: offset as u32,
|
||||
code_len: len as u32,
|
||||
|
||||
@@ -7,6 +7,7 @@ mod collections_tests;
|
||||
mod control;
|
||||
mod dynamic;
|
||||
mod gc;
|
||||
mod lifecycle;
|
||||
mod loader;
|
||||
mod random;
|
||||
mod reference;
|
||||
@@ -49,6 +50,8 @@ use prometeu_test_support::program::{TestProgram, int64_signature};
|
||||
pub enum LogicalFrameEndingReason {
|
||||
/// Execution reached a `FRAME_SYNC` instruction, marking the end of the logical frame.
|
||||
FrameSync,
|
||||
/// The outer lifecycle callback returned; gameplay has not resumed.
|
||||
LifecycleComplete,
|
||||
/// The cycle budget for the current host tick was exhausted before reaching `FRAME_SYNC`.
|
||||
BudgetExhausted,
|
||||
/// A `HALT` instruction was executed, terminating the program.
|
||||
@@ -109,6 +112,8 @@ pub struct VirtualMachine {
|
||||
cycles: u64,
|
||||
/// Stop flag: true if a `HALT` opcode was encountered.
|
||||
halted: bool,
|
||||
lifecycle: Option<lifecycle::LifecycleCall>,
|
||||
lifecycle_failure: Option<LogicalFrameEndingReason>,
|
||||
/// Set of ROM addresses used for software breakpoints in the debugger.
|
||||
breakpoints: std::collections::HashSet<usize>,
|
||||
/// GC: number of newly allocated live objects threshold to trigger a collection at safepoint.
|
||||
@@ -229,6 +234,8 @@ impl VirtualMachine {
|
||||
heap: Heap::with_budget(&budget),
|
||||
cycles: 0,
|
||||
halted: true,
|
||||
lifecycle: None,
|
||||
lifecycle_failure: None,
|
||||
breakpoints: std::collections::HashSet::new(),
|
||||
gc_alloc_threshold: 1024, // conservative default; tests may override
|
||||
last_gc_live_count: 0,
|
||||
@@ -257,7 +264,7 @@ impl VirtualMachine {
|
||||
/// 1. Fetch: Read the opcode from memory.
|
||||
/// 2. Decode: Identify what operation to perform.
|
||||
/// 3. Execute: Perform the operation, updating stacks, memory, or calling peripherals.
|
||||
pub fn step(
|
||||
fn step_inner(
|
||||
&mut self,
|
||||
native: &mut dyn NativeInterface,
|
||||
ctx: &mut HostContext,
|
||||
@@ -1039,6 +1046,14 @@ impl VirtualMachine {
|
||||
return self.execute_collection(opcode, ty, field, start_pc as u32);
|
||||
}
|
||||
OpCode::FrameSync => {
|
||||
if self.lifecycle.is_some() {
|
||||
return Err(self.trap(
|
||||
TRAP_TYPE,
|
||||
opcode as u16,
|
||||
"FRAME_SYNC is forbidden in lifecycle hooks".into(),
|
||||
start_pc as u32,
|
||||
));
|
||||
}
|
||||
// Marks the logical end of a frame: consume cycles and signal to the driver
|
||||
self.cycles += OpCode::FrameSync.cycles();
|
||||
self.handle_safepoint()
|
||||
@@ -1152,7 +1167,11 @@ mod tests {
|
||||
typed_test_vm(
|
||||
code,
|
||||
constant_pool,
|
||||
vec![FunctionDecl { max_stack_slots: 256, ..Default::default() }],
|
||||
vec![FunctionDecl {
|
||||
lifecycle_role: Default::default(),
|
||||
max_stack_slots: 256,
|
||||
..Default::default()
|
||||
}],
|
||||
)
|
||||
}
|
||||
fn limited_session(code: Vec<u8>, limits: RuntimeLimits) -> VirtualMachine {
|
||||
@@ -1196,6 +1215,7 @@ mod tests {
|
||||
TestProgram {
|
||||
const_pool: vec![],
|
||||
functions: vec![FunctionDecl {
|
||||
lifecycle_role: Default::default(),
|
||||
code_offset: 0,
|
||||
code_len: code.len() as u32,
|
||||
|
||||
@@ -1511,8 +1531,13 @@ mod tests {
|
||||
rom,
|
||||
vec![],
|
||||
vec![
|
||||
FunctionDecl { max_stack_slots: 256, ..Default::default() },
|
||||
FunctionDecl {
|
||||
lifecycle_role: Default::default(),
|
||||
max_stack_slots: 256,
|
||||
..Default::default()
|
||||
},
|
||||
FunctionDecl {
|
||||
lifecycle_role: Default::default(),
|
||||
code_offset: func_addr as u32,
|
||||
signature: int64_signature(1, 1),
|
||||
max_stack_slots: 256,
|
||||
@@ -1593,8 +1618,13 @@ mod tests {
|
||||
rom2,
|
||||
vec![],
|
||||
vec![
|
||||
FunctionDecl { max_stack_slots: 256, ..Default::default() },
|
||||
FunctionDecl {
|
||||
lifecycle_role: Default::default(),
|
||||
max_stack_slots: 256,
|
||||
..Default::default()
|
||||
},
|
||||
FunctionDecl {
|
||||
lifecycle_role: Default::default(),
|
||||
code_offset: func_addr2 as u32,
|
||||
signature: int64_signature(0, 1),
|
||||
max_stack_slots: 256,
|
||||
@@ -1834,6 +1864,7 @@ mod tests {
|
||||
rom.clone(),
|
||||
vec![],
|
||||
vec![FunctionDecl {
|
||||
lifecycle_role: Default::default(),
|
||||
code_offset: 0,
|
||||
|
||||
signature: scalar_signature(0, 0, 1),
|
||||
@@ -2449,6 +2480,7 @@ mod tests {
|
||||
let header = TestProgram {
|
||||
const_pool: vec![],
|
||||
functions: vec![FunctionDecl {
|
||||
lifecycle_role: Default::default(),
|
||||
code_offset: 0,
|
||||
code_len: code.len() as u32,
|
||||
|
||||
@@ -2964,6 +2996,7 @@ mod tests {
|
||||
vec![],
|
||||
vec![
|
||||
FunctionDecl {
|
||||
lifecycle_role: Default::default(),
|
||||
code_offset: f0_start as u32,
|
||||
|
||||
signature: scalar_signature(0, 0, 1),
|
||||
@@ -2974,6 +3007,7 @@ mod tests {
|
||||
local_slots: 0,
|
||||
},
|
||||
FunctionDecl {
|
||||
lifecycle_role: Default::default(),
|
||||
code_offset: f1_start,
|
||||
|
||||
signature: scalar_signature(2, 1, 1),
|
||||
@@ -3025,6 +3059,7 @@ mod tests {
|
||||
vec![],
|
||||
vec![
|
||||
FunctionDecl {
|
||||
lifecycle_role: Default::default(),
|
||||
code_offset: f0_start as u32,
|
||||
|
||||
signature: scalar_signature(0, 0, 1),
|
||||
@@ -3035,6 +3070,7 @@ mod tests {
|
||||
local_slots: 0,
|
||||
},
|
||||
FunctionDecl {
|
||||
lifecycle_role: Default::default(),
|
||||
code_offset: f1_start,
|
||||
|
||||
signature: scalar_signature(0, 2, 1),
|
||||
@@ -3085,6 +3121,7 @@ mod tests {
|
||||
vec![],
|
||||
vec![
|
||||
FunctionDecl {
|
||||
lifecycle_role: Default::default(),
|
||||
code_offset: f0_start as u32,
|
||||
|
||||
signature: scalar_signature(0, 0, 1),
|
||||
@@ -3095,6 +3132,7 @@ mod tests {
|
||||
local_slots: 0,
|
||||
},
|
||||
FunctionDecl {
|
||||
lifecycle_role: Default::default(),
|
||||
code_offset: f1_start,
|
||||
|
||||
signature: scalar_signature(1, 0, 1),
|
||||
@@ -3210,6 +3248,7 @@ mod tests {
|
||||
rom.clone(),
|
||||
vec![],
|
||||
vec![FunctionDecl {
|
||||
lifecycle_role: Default::default(),
|
||||
code_offset: 0,
|
||||
local_slots: 1,
|
||||
|
||||
@@ -3269,6 +3308,7 @@ mod tests {
|
||||
vec![],
|
||||
vec![
|
||||
FunctionDecl {
|
||||
lifecycle_role: Default::default(),
|
||||
code_offset: f0_start as u32,
|
||||
|
||||
signature: scalar_signature(0, 0, 4),
|
||||
@@ -3279,6 +3319,7 @@ mod tests {
|
||||
local_slots: 0,
|
||||
},
|
||||
FunctionDecl {
|
||||
lifecycle_role: Default::default(),
|
||||
code_offset: f1_start,
|
||||
local_slots: 1,
|
||||
|
||||
@@ -3391,6 +3432,7 @@ mod tests {
|
||||
rom.clone(),
|
||||
vec![],
|
||||
vec![FunctionDecl {
|
||||
lifecycle_role: Default::default(),
|
||||
code_offset: 0,
|
||||
|
||||
signature: scalar_signature(0, 0, 1),
|
||||
@@ -3439,6 +3481,7 @@ mod tests {
|
||||
rom.clone(),
|
||||
vec![],
|
||||
vec![FunctionDecl {
|
||||
lifecycle_role: Default::default(),
|
||||
code_offset: 0,
|
||||
|
||||
signature: scalar_signature(0, 0, 1),
|
||||
@@ -3506,6 +3549,7 @@ mod tests {
|
||||
rom.clone(),
|
||||
vec![],
|
||||
vec![FunctionDecl {
|
||||
lifecycle_role: Default::default(),
|
||||
code_offset: 0,
|
||||
|
||||
signature: scalar_signature(0, 0, 1),
|
||||
@@ -3556,6 +3600,7 @@ mod tests {
|
||||
rom.clone(),
|
||||
vec![],
|
||||
vec![FunctionDecl {
|
||||
lifecycle_role: Default::default(),
|
||||
code_offset: 0,
|
||||
|
||||
signature: scalar_signature(0, 0, 1),
|
||||
@@ -3606,6 +3651,7 @@ mod tests {
|
||||
rom.clone(),
|
||||
vec![],
|
||||
vec![FunctionDecl {
|
||||
lifecycle_role: Default::default(),
|
||||
code_offset: 0,
|
||||
|
||||
signature: scalar_signature(0, 0, 1),
|
||||
@@ -3661,6 +3707,7 @@ mod tests {
|
||||
rom.clone(),
|
||||
vec![],
|
||||
vec![FunctionDecl {
|
||||
lifecycle_role: Default::default(),
|
||||
code_offset: 0,
|
||||
|
||||
signature: scalar_signature(0, 0, 1),
|
||||
|
||||
@@ -0,0 +1,109 @@
|
||||
//! Bounded calls that retain the suspended guest continuation and its GC roots.
|
||||
use super::*;
|
||||
use prometeu_bytecode::registry::LifecycleRole;
|
||||
|
||||
pub(super) struct LifecycleCall {
|
||||
depth: usize,
|
||||
pc: usize,
|
||||
halted: bool,
|
||||
pub(super) remaining: u64,
|
||||
pub(super) breakpoint: Option<usize>,
|
||||
}
|
||||
|
||||
impl VirtualMachine {
|
||||
pub const LIFECYCLE_CYCLES: u64 = 1_500_000;
|
||||
pub const LIFECYCLE_SLICE: u64 = 250_000;
|
||||
|
||||
pub fn has_lifecycle_hook(&self, role: LifecycleRole) -> bool {
|
||||
self.validated_image.as_ref().is_some_and(|i| i.registry().lifecycle_hook(role).is_some())
|
||||
}
|
||||
|
||||
pub fn lifecycle_active(&self) -> bool {
|
||||
self.lifecycle.is_some()
|
||||
}
|
||||
|
||||
pub fn lifecycle_remaining_cycles(&self) -> Option<u64> {
|
||||
self.lifecycle.as_ref().map(|call| call.remaining)
|
||||
}
|
||||
|
||||
/// Returns false for an absent role. Entry is transactional with respect to quotas.
|
||||
pub fn begin_lifecycle(&mut self, role: LifecycleRole) -> Result<bool, VmInitError> {
|
||||
if self.lifecycle.is_some() || self.lifecycle_failure.is_some() {
|
||||
return Err(VmInitError::EntrypointNotFound);
|
||||
}
|
||||
let Some(id) =
|
||||
self.validated_image.as_ref().and_then(|i| i.registry().lifecycle_hook(role))
|
||||
else {
|
||||
return Ok(false);
|
||||
};
|
||||
let func_idx = id.0 as usize;
|
||||
let callee = &self.program.functions[func_idx];
|
||||
let locals = callee.local_slots as usize;
|
||||
let offset = callee.code_offset as usize;
|
||||
self.budget.check(RuntimeResource::CallDepth, (self.call_stack.len() + 1) as u64)?;
|
||||
let operands = self.operand_stack.prepare_growth(locals)?;
|
||||
let frames = self.call_stack.prepare_growth(1)?;
|
||||
self.operand_stack.commit_growth(operands);
|
||||
self.call_stack.commit_growth(frames);
|
||||
let base = self.operand_stack.len();
|
||||
let call = LifecycleCall {
|
||||
depth: self.call_stack.len(),
|
||||
pc: self.pc,
|
||||
halted: self.halted,
|
||||
remaining: Self::LIFECYCLE_CYCLES,
|
||||
breakpoint: None,
|
||||
};
|
||||
for _ in 0..locals {
|
||||
self.operand_stack.push(Value::Null)?;
|
||||
}
|
||||
self.call_stack.push(CallFrame {
|
||||
return_pc: self.pc as u32,
|
||||
stack_base: base,
|
||||
func_idx,
|
||||
closure: None,
|
||||
})?;
|
||||
self.lifecycle = Some(call);
|
||||
self.pc = offset;
|
||||
self.halted = false;
|
||||
Ok(true)
|
||||
}
|
||||
|
||||
/// Both the debugger and normal slices pass through the same accounting boundary.
|
||||
pub fn step(
|
||||
&mut self,
|
||||
native: &mut dyn NativeInterface,
|
||||
ctx: &mut HostContext,
|
||||
) -> Result<(), LogicalFrameEndingReason> {
|
||||
if let Some(reason) = &self.lifecycle_failure {
|
||||
return Err(reason.clone());
|
||||
}
|
||||
if let Some(call) = &mut self.lifecycle {
|
||||
call.breakpoint = None;
|
||||
}
|
||||
let before = self.cycles;
|
||||
let result = self.step_inner(native, ctx);
|
||||
let Some(call) = self.lifecycle.as_mut() else {
|
||||
return result;
|
||||
};
|
||||
call.remaining = call.remaining.saturating_sub(self.cycles - before);
|
||||
if result.is_ok() && !self.halted && self.call_stack.len() == call.depth {
|
||||
let call = self.lifecycle.take().unwrap();
|
||||
self.pc = call.pc;
|
||||
self.halted = call.halted;
|
||||
return Err(LogicalFrameEndingReason::LifecycleComplete);
|
||||
}
|
||||
let failure = match result {
|
||||
Err(reason) => Some(reason),
|
||||
Ok(()) if self.halted => Some(LogicalFrameEndingReason::Halted),
|
||||
Ok(()) if call.remaining == 0 => Some(LogicalFrameEndingReason::Panic(
|
||||
"lifecycle total cycle budget exhausted".into(),
|
||||
)),
|
||||
Ok(()) => None,
|
||||
};
|
||||
if let Some(reason) = failure {
|
||||
self.lifecycle_failure = Some(reason.clone());
|
||||
return Err(reason);
|
||||
}
|
||||
Ok(())
|
||||
}
|
||||
}
|
||||
@@ -55,6 +55,9 @@ impl VirtualMachine {
|
||||
func_idx: usize,
|
||||
arguments: &[Value],
|
||||
) -> Result<(), VmInitError> {
|
||||
if self.lifecycle.is_some() || self.lifecycle_failure.is_some() {
|
||||
return Err(VmInitError::EntrypointNotFound);
|
||||
}
|
||||
#[cfg(not(test))]
|
||||
if self.validated_image.is_none() {
|
||||
return Err(VmInitError::EntrypointNotFound);
|
||||
|
||||
@@ -7,6 +7,11 @@ impl VirtualMachine {
|
||||
native: &mut dyn NativeInterface,
|
||||
ctx: &mut HostContext,
|
||||
) -> Result<BudgetReport, String> {
|
||||
if let Some(reason) = &self.lifecycle_failure {
|
||||
return Ok(BudgetReport { cycles_used: 0, steps_executed: 0, reason: reason.clone() });
|
||||
}
|
||||
let budget =
|
||||
if self.lifecycle.is_some() { budget.min(Self::LIFECYCLE_SLICE) } else { budget };
|
||||
let start_cycles = self.cycles;
|
||||
let mut steps_executed = 0;
|
||||
let mut ending_reason: Option<LogicalFrameEndingReason> = None;
|
||||
@@ -15,7 +20,13 @@ impl VirtualMachine {
|
||||
&& !self.halted
|
||||
&& self.pc < self.program.rom.len()
|
||||
{
|
||||
if steps_executed > 0 && self.breakpoints.contains(&self.pc) {
|
||||
if self.breakpoints.contains(&self.pc)
|
||||
&& (steps_executed > 0
|
||||
|| self.lifecycle.as_ref().is_some_and(|c| c.breakpoint != Some(self.pc)))
|
||||
{
|
||||
if let Some(call) = &mut self.lifecycle {
|
||||
call.breakpoint = Some(self.pc);
|
||||
}
|
||||
ending_reason = Some(LogicalFrameEndingReason::Breakpoint);
|
||||
break;
|
||||
}
|
||||
@@ -70,7 +81,8 @@ impl VirtualMachine {
|
||||
let rep = self.run_budget(budget_per_slice, native, ctx)?;
|
||||
let terminal = matches!(
|
||||
rep.reason,
|
||||
LogicalFrameEndingReason::Halted
|
||||
LogicalFrameEndingReason::LifecycleComplete
|
||||
| LogicalFrameEndingReason::Halted
|
||||
| LogicalFrameEndingReason::EndOfRom
|
||||
| LogicalFrameEndingReason::Panic(_)
|
||||
| LogicalFrameEndingReason::Trap(_)
|
||||
@@ -113,7 +125,8 @@ impl VirtualMachine {
|
||||
let rep = self.run_budget(budget_per_slice, native, ctx)?;
|
||||
let terminal = matches!(
|
||||
rep.reason,
|
||||
LogicalFrameEndingReason::Halted
|
||||
LogicalFrameEndingReason::LifecycleComplete
|
||||
| LogicalFrameEndingReason::Halted
|
||||
| LogicalFrameEndingReason::EndOfRom
|
||||
| LogicalFrameEndingReason::Panic(_)
|
||||
| LogicalFrameEndingReason::Trap(_)
|
||||
|
||||
@@ -36,6 +36,7 @@ fn function(
|
||||
max: u32,
|
||||
) -> FunctionDecl {
|
||||
FunctionDecl {
|
||||
lifecycle_role: Default::default(),
|
||||
captures: vec![],
|
||||
name: Some(format!("f{offset}")),
|
||||
code_offset: offset as u32,
|
||||
@@ -777,3 +778,171 @@ fn call_growth_refusal_does_not_publish_frame_or_keep_provisional_capacity() {
|
||||
assert_eq!(vm.budget.used(RuntimeResource::AuxiliaryBytes), before);
|
||||
assert_eq!(vm.budget.used(RuntimeResource::TemporaryBytes), 0);
|
||||
}
|
||||
|
||||
mod lifecycle_tests {
|
||||
use super::*;
|
||||
use prometeu_bytecode::registry::LifecycleRole;
|
||||
|
||||
fn machine(hook: Vec<u8>) -> VirtualMachine {
|
||||
let mut code = vec![];
|
||||
arg(&mut code, OpCode::PushI32, 17);
|
||||
op(&mut code, OpCode::FrameSync);
|
||||
arg(&mut code, OpCode::SetGlobal, 0);
|
||||
op(&mut code, OpCode::Ret);
|
||||
let len = code.len();
|
||||
code.extend(&hook);
|
||||
let mut callback = function(len, hook.len(), &[], &[], 0, 8);
|
||||
callback.lifecycle_role = LifecycleRole::BeforePause;
|
||||
let image = image(&code, vec![function(0, len, &[], &[], 0, 8), callback]);
|
||||
let mut vm = VirtualMachine::from_image(image, RuntimeLimits::default());
|
||||
vm.prepare_boot_call().unwrap();
|
||||
assert_eq!(run(&mut vm), LogicalFrameEndingReason::FrameSync);
|
||||
vm
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn lifecycle_preserves_continuation_and_does_not_run_gameplay_after_return() {
|
||||
let mut hook = vec![];
|
||||
arg(&mut hook, OpCode::PushI32, 42);
|
||||
arg(&mut hook, OpCode::SetGlobal, 1);
|
||||
op(&mut hook, OpCode::Ret);
|
||||
let mut vm = machine(hook);
|
||||
let pc = vm.pc;
|
||||
let depth = vm.call_stack.len();
|
||||
let stack = vm.operand_stack.to_vec();
|
||||
assert!(vm.begin_lifecycle(LifecycleRole::BeforePause).unwrap());
|
||||
assert!(vm.begin_lifecycle(LifecycleRole::BeforePause).is_err());
|
||||
assert_eq!(run(&mut vm), LogicalFrameEndingReason::LifecycleComplete);
|
||||
assert_eq!(vm.pc, pc);
|
||||
assert_eq!(vm.call_stack.len(), depth);
|
||||
assert_eq!(&vm.operand_stack[..], stack.as_slice());
|
||||
assert_eq!(vm.globals[1], Value::Int32(42));
|
||||
assert_eq!(run(&mut vm), LogicalFrameEndingReason::EndOfRom);
|
||||
assert_eq!(vm.globals[0], Value::Int32(17));
|
||||
assert!(!vm.begin_lifecycle(LifecycleRole::BeforeResume).unwrap());
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn lifecycle_budget_survives_slices_breakpoints_and_single_steps() {
|
||||
let mut hook = vec![];
|
||||
arg(&mut hook, OpCode::Jmp, 0);
|
||||
let mut vm = machine(hook);
|
||||
vm.begin_lifecycle(LifecycleRole::BeforePause).unwrap();
|
||||
vm.insert_breakpoint(vm.pc);
|
||||
let rep = vm.run_budget(u64::MAX, &mut Native, &mut HostContext::new(None)).unwrap();
|
||||
assert_eq!(rep.reason, LogicalFrameEndingReason::Breakpoint);
|
||||
assert_eq!(rep.cycles_used, 0);
|
||||
let before = vm.lifecycle_remaining_cycles().unwrap();
|
||||
vm.step(&mut Native, &mut HostContext::new(None)).unwrap();
|
||||
assert!(vm.lifecycle_remaining_cycles().unwrap() < before);
|
||||
vm.breakpoints.clear();
|
||||
let mut total = VirtualMachine::LIFECYCLE_CYCLES - vm.lifecycle_remaining_cycles().unwrap();
|
||||
loop {
|
||||
let rep = vm.run_budget(u64::MAX, &mut Native, &mut HostContext::new(None)).unwrap();
|
||||
assert!(rep.cycles_used <= VirtualMachine::LIFECYCLE_SLICE + OpCode::Jmp.cycles());
|
||||
total += rep.cycles_used;
|
||||
if let LogicalFrameEndingReason::Panic(message) = rep.reason {
|
||||
assert!(message.contains("total cycle budget"));
|
||||
break;
|
||||
}
|
||||
assert_eq!(rep.reason, LogicalFrameEndingReason::BudgetExhausted);
|
||||
}
|
||||
assert!(total >= VirtualMachine::LIFECYCLE_CYCLES);
|
||||
let pc = vm.pc;
|
||||
assert!(vm.step(&mut Native, &mut HostContext::new(None)).is_err());
|
||||
assert_eq!(vm.pc, pc);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn lifecycle_normal_return_wins_at_budget_boundary_and_halt_does_not_complete() {
|
||||
for remaining in [1, OpCode::Ret.cycles()] {
|
||||
let mut hook = vec![];
|
||||
op(&mut hook, OpCode::Ret);
|
||||
let mut vm = machine(hook);
|
||||
vm.begin_lifecycle(LifecycleRole::BeforePause).unwrap();
|
||||
vm.lifecycle.as_mut().unwrap().remaining = remaining;
|
||||
assert_eq!(run(&mut vm), LogicalFrameEndingReason::LifecycleComplete);
|
||||
}
|
||||
let mut hook = vec![];
|
||||
op(&mut hook, OpCode::Halt);
|
||||
let mut vm = machine(hook);
|
||||
vm.begin_lifecycle(LifecycleRole::BeforePause).unwrap();
|
||||
assert_eq!(run(&mut vm), LogicalFrameEndingReason::Halted);
|
||||
assert!(vm.lifecycle_active());
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn lifecycle_forbids_frame_sync_and_preserves_failure() {
|
||||
let mut hook = vec![];
|
||||
op(&mut hook, OpCode::FrameSync);
|
||||
op(&mut hook, OpCode::Ret);
|
||||
let mut vm = machine(hook);
|
||||
vm.begin_lifecycle(LifecycleRole::BeforePause).unwrap();
|
||||
let reason = run(&mut vm);
|
||||
assert!(
|
||||
matches!(&reason, LogicalFrameEndingReason::Trap(t) if t.message.contains("FRAME_SYNC"))
|
||||
);
|
||||
assert_eq!(run(&mut vm), reason);
|
||||
}
|
||||
#[test]
|
||||
fn lifecycle_nested_calls_keep_saved_roots_and_branch_returns_stop_at_boundary() {
|
||||
let main = prometeu_bytecode::assembler::assemble("FRAME_SYNC\nRET").unwrap();
|
||||
let hook = prometeu_bytecode::assembler::assemble("CALL 2\nJMP 12").unwrap();
|
||||
for callee_source in ["PUSH_I32 9\nSET_GLOBAL 0\nRET", "FRAME_SYNC\nRET"] {
|
||||
let callee = prometeu_bytecode::assembler::assemble(callee_source).unwrap();
|
||||
let mut callback = function(main.len(), hook.len(), &[], &[], 0, 8);
|
||||
callback.lifecycle_role = LifecycleRole::BeforePause;
|
||||
let code = [main.as_slice(), hook.as_slice(), callee.as_slice()].concat();
|
||||
let image = image(
|
||||
&code,
|
||||
vec![
|
||||
function(0, main.len(), &[], &[], 0, 8),
|
||||
callback,
|
||||
function(main.len() + hook.len(), callee.len(), &[], &[], 0, 8),
|
||||
],
|
||||
);
|
||||
let mut vm = VirtualMachine::from_image(image, RuntimeLimits::default());
|
||||
vm.prepare_boot_call().unwrap();
|
||||
assert_eq!(run(&mut vm), LogicalFrameEndingReason::FrameSync);
|
||||
let retained = vm.heap.alloc_closure(0, &[]).unwrap();
|
||||
vm.operand_stack.push(Value::HeapRef(retained)).unwrap();
|
||||
vm.begin_lifecycle(LifecycleRole::BeforePause).unwrap();
|
||||
vm.gc_alloc_threshold = 1;
|
||||
vm.handle_safepoint().unwrap();
|
||||
assert!(vm.heap.is_valid(retained));
|
||||
let result = run(&mut vm);
|
||||
if callee_source.starts_with("FRAME_SYNC") {
|
||||
assert!(matches!(result, LogicalFrameEndingReason::Trap(_)));
|
||||
} else {
|
||||
assert_eq!(result, LogicalFrameEndingReason::LifecycleComplete);
|
||||
assert_eq!(vm.call_stack.len(), 1);
|
||||
assert_eq!(vm.operand_stack.last(), Some(&Value::HeapRef(retained)));
|
||||
assert_eq!(vm.globals[0], Value::Int32(9));
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn lifecycle_entry_quota_refusal_is_transactional_and_empty_context_is_supported() {
|
||||
let mut vm = machine(prometeu_bytecode::assembler::assemble("RET").unwrap());
|
||||
let image = vm.validated_image.clone().unwrap();
|
||||
let limits = RuntimeLimits::default().lowered(RuntimeResource::CallDepth, 1).unwrap();
|
||||
vm = VirtualMachine::from_image(image.clone(), limits);
|
||||
vm.prepare_boot_call().unwrap();
|
||||
let pc = vm.pc;
|
||||
let stack = vm.operand_stack.to_vec();
|
||||
assert!(vm.begin_lifecycle(LifecycleRole::BeforePause).is_err());
|
||||
assert_eq!(vm.pc, pc);
|
||||
assert_eq!(&vm.operand_stack[..], stack.as_slice());
|
||||
assert_eq!(vm.call_stack.len(), 1);
|
||||
assert!(!vm.lifecycle_active());
|
||||
let mut vm = VirtualMachine::from_image(image, RuntimeLimits::default());
|
||||
let halted = vm.halted;
|
||||
let pc = vm.pc;
|
||||
vm.begin_lifecycle(LifecycleRole::BeforePause).unwrap();
|
||||
assert_eq!(run(&mut vm), LogicalFrameEndingReason::LifecycleComplete);
|
||||
assert_eq!(vm.pc, pc);
|
||||
assert_eq!(vm.halted, halted);
|
||||
assert!(vm.call_stack.is_empty());
|
||||
}
|
||||
}
|
||||
|
||||
@@ -45,6 +45,7 @@ fn named_arguments_preserve_source_effect_order_and_call_in_signature_order_with
|
||||
vec![]
|
||||
};
|
||||
functions.push(FunctionDecl {
|
||||
lifecycle_role: Default::default(),
|
||||
captures: vec![],
|
||||
name: Some(["main", "effectX", "effectY", "combine"][index].into()),
|
||||
signature: Signature {
|
||||
|
||||
@@ -7,20 +7,20 @@ use prometeu_vm::{
|
||||
};
|
||||
|
||||
// Independent executable oracle: 32-byte header, eight directory entries,
|
||||
// payload at 128, one Bool import, one zero-slot HALT function; total 193.
|
||||
// payload at 128, one Bool import, one zero-slot HALT function; total 194.
|
||||
fn minimal() -> Vec<u8> {
|
||||
"50 42 58 00 01 00 00 00 08 00 00 00
|
||||
00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00
|
||||
00 00 00 00 80 00 00 00 04 00 00 00
|
||||
01 00 00 00 84 00 00 00 1d 00 00 00
|
||||
02 00 00 00 a1 00 00 00 02 00 00 00
|
||||
04 00 00 00 a3 00 00 00 04 00 00 00
|
||||
05 00 00 00 a7 00 00 00 04 00 00 00
|
||||
06 00 00 00 ab 00 00 00 0a 00 00 00
|
||||
07 00 00 00 b5 00 00 00 04 00 00 00
|
||||
08 00 00 00 b9 00 00 00 08 00 00 00
|
||||
01 00 00 00 84 00 00 00 1e 00 00 00
|
||||
02 00 00 00 a2 00 00 00 02 00 00 00
|
||||
04 00 00 00 a4 00 00 00 04 00 00 00
|
||||
05 00 00 00 a8 00 00 00 04 00 00 00
|
||||
06 00 00 00 ac 00 00 00 0a 00 00 00
|
||||
07 00 00 00 b6 00 00 00 04 00 00 00
|
||||
08 00 00 00 ba 00 00 00 08 00 00 00
|
||||
00 00 00 00
|
||||
01 00 00 00 00 00 00 00 00 00 00 00 00
|
||||
01 00 00 00 00 00 00 00 00 00 00 00 00 00
|
||||
00 00 00 00 02 00 00 00 00 00 00 00 00 00 00 00
|
||||
01 00
|
||||
00 00 00 00
|
||||
@@ -48,7 +48,7 @@ impl NativeInterface for Native {
|
||||
#[test]
|
||||
fn independent_v1_bytes_load_publish_and_execute_through_the_public_sealed_boundary() {
|
||||
let bytes = minimal();
|
||||
assert_eq!(bytes.len(), 193);
|
||||
assert_eq!(bytes.len(), 194);
|
||||
let mut load = LoadBudget::new(Default::default());
|
||||
let image = ValidatedProgramImage::load(&bytes, &mut load, caps::NONE).unwrap();
|
||||
assert_eq!(load.used(LoadResource::TemporaryBytes), 0);
|
||||
@@ -65,9 +65,9 @@ fn independent_v1_bytes_load_publish_and_execute_through_the_public_sealed_bound
|
||||
fn single_violation_oracles_reject_before_image_publication_with_typed_context() {
|
||||
for (offset, replacement, code, reason, pc) in [
|
||||
(4, 0, LoadCode::UnsupportedFormat, LoadReason::Version, None),
|
||||
(177, 0, LoadCode::UnsupportedFormat, LoadReason::Builtin, None),
|
||||
(161, 0xff, LoadCode::InvalidCode, LoadReason::UnknownOpcode, Some(0)),
|
||||
(161, 0x11, LoadCode::InvalidCode, LoadReason::StackUnderflow, Some(0)),
|
||||
(178, 0, LoadCode::UnsupportedFormat, LoadReason::Builtin, None),
|
||||
(162, 0xff, LoadCode::InvalidCode, LoadReason::UnknownOpcode, Some(0)),
|
||||
(162, 0x11, LoadCode::InvalidCode, LoadReason::StackUnderflow, Some(0)),
|
||||
] {
|
||||
let mut bytes = minimal();
|
||||
bytes[offset] = replacement;
|
||||
|
||||
@@ -89,6 +89,7 @@ pub fn bytes_with_syscalls(
|
||||
for (source, signature, captures) in bodies {
|
||||
let body = assemble(source).unwrap();
|
||||
functions.push(FunctionDecl {
|
||||
lifecycle_role: Default::default(),
|
||||
signature: signature.clone(),
|
||||
captures: captures.clone(),
|
||||
code_offset: code.len() as u32,
|
||||
|
||||
@@ -60,6 +60,7 @@ pub fn declarations(code_len: usize) -> RegistryDeclarations {
|
||||
RegistryDeclarations {
|
||||
types,
|
||||
functions: vec![FunctionDecl {
|
||||
lifecycle_role: Default::default(),
|
||||
code_len: code_len as u32,
|
||||
local_slots: 0,
|
||||
max_stack_slots: 32,
|
||||
|
||||
@@ -50,6 +50,7 @@ pub fn bytes(bodies: &[Body<'_>]) -> Vec<u8> {
|
||||
for (text, signature, captures, locals) in bodies {
|
||||
let body = assemble(text).unwrap();
|
||||
functions.push(FunctionDecl {
|
||||
lifecycle_role: Default::default(),
|
||||
signature: signature.clone(),
|
||||
captures: captures.clone(),
|
||||
local_slots: *locals,
|
||||
|
||||
Reference in New Issue
Block a user