feat(vm)!: implement typed callables and single-context execution
Intrepid/Prometeu/Runtime/pipeline/pr-master This commit looks good
Intrepid/Prometeu/Runtime/pipeline/pr-master This commit looks good
Add structural Fn signatures, typed capture environments, indirect calls and Trait dispatch while preserving logical parameter and result groups, ownership and budgets. Remove guest coroutine execution and legacy loading. Activate bounded sealed PBX v1 with mandatory capture metadata, preserve frame continuations and root return results, and migrate producers and shipped cartridges. Publish coordinated specs, handoffs and the completed runtime lesson. Validation: 880 workspace tests passed, 9 existing tests ignored; both cartridges completed six production-host frames.
This commit is contained in:
@@ -22,3 +22,6 @@ getrandom = "0.3"
|
||||
[[bench]]
|
||||
name = "temporal"
|
||||
harness = false
|
||||
|
||||
[dev-dependencies]
|
||||
prometeu-test-support = { path = "../../dev/prometeu-test-support" }
|
||||
|
||||
@@ -1,3 +1,5 @@
|
||||
use prometeu_bytecode::registry::FunctionDecl;
|
||||
use prometeu_test_support::program::{TestProgram, int64_signature};
|
||||
use std::fs;
|
||||
use std::hint::black_box;
|
||||
use std::path::{Path, PathBuf};
|
||||
@@ -5,7 +7,7 @@ use std::time::{Instant, SystemTime, UNIX_EPOCH};
|
||||
|
||||
use prometeu_bytecode::SourceSpan;
|
||||
use prometeu_bytecode::assembler::assemble;
|
||||
use prometeu_bytecode::model::{BytecodeModule, DebugInfo, Export, FunctionMeta};
|
||||
use prometeu_bytecode::model::{DebugInfo, Export};
|
||||
use prometeu_host_headless::{AdvanceFramesStop, HeadlessHost};
|
||||
|
||||
const SAMPLE_FRAMES: u64 = 300;
|
||||
@@ -47,17 +49,17 @@ fn benchmark_cartridge() -> PathBuf {
|
||||
));
|
||||
fs::create_dir_all(&directory).expect("create benchmark cartridge");
|
||||
|
||||
let code = assemble("FRAME_SYNC\nRET\n").expect("assemble benchmark program");
|
||||
let module = BytecodeModule {
|
||||
version: 0,
|
||||
let code = assemble("RET\n").expect("assemble benchmark program");
|
||||
let module = TestProgram {
|
||||
const_pool: vec![],
|
||||
functions: vec![FunctionMeta {
|
||||
functions: vec![FunctionDecl {
|
||||
code_offset: 0,
|
||||
code_len: code.len() as u32,
|
||||
param_slots: 0,
|
||||
local_slots: 0,
|
||||
return_slots: 0,
|
||||
max_stack_slots: 1,
|
||||
signature: int64_signature(0, 0),
|
||||
captures: vec![],
|
||||
name: None,
|
||||
}],
|
||||
code,
|
||||
debug_info: Some(DebugInfo {
|
||||
|
||||
@@ -45,3 +45,107 @@ fn load_failure_wire_uses_shared_structured_serializer_and_no_runtime_pc() {
|
||||
assert_eq!(wire["initError"]["load"]["requested"], 23);
|
||||
assert_eq!(wire["initError"]["load"]["limit"], 22);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn executed_closure_quota_refusal_reaches_wire_with_machine_fields() {
|
||||
use prometeu_bytecode::{
|
||||
assemble, load_limits::LoadBudget, registry::*, registry_codec::PbxModule,
|
||||
};
|
||||
use prometeu_hal::{HostContext, HostReturn, NativeInterface};
|
||||
use prometeu_vm::{
|
||||
LogicalFrameEndingReason, ValidatedProgramImage, VirtualMachine,
|
||||
resource_budget::RuntimeLimits,
|
||||
};
|
||||
let mut code = assemble("MAKE_CLOSURE fn=1,type=0\nPOP\nRET").unwrap();
|
||||
let end = code.len() as u32;
|
||||
code.extend(assemble("RET").unwrap());
|
||||
let mut budget = LoadBudget::new(Default::default());
|
||||
let registry = Registry::resolve(
|
||||
RegistryDeclarations {
|
||||
types: vec![TypeDecl { name: None, kind: TypeKind::Fn(Default::default()) }],
|
||||
functions: vec![
|
||||
FunctionDecl { code_len: end, max_stack_slots: 1, ..Default::default() },
|
||||
FunctionDecl { code_offset: end, code_len: 2, ..Default::default() },
|
||||
],
|
||||
implementations: vec![],
|
||||
},
|
||||
code.len(),
|
||||
&mut budget,
|
||||
)
|
||||
.unwrap();
|
||||
let bytes = PbxModule {
|
||||
registry: ®istry,
|
||||
code: &code,
|
||||
constants: &[],
|
||||
debug: None,
|
||||
exports: &[],
|
||||
syscalls: &[],
|
||||
}
|
||||
.serialize(&mut budget)
|
||||
.unwrap();
|
||||
let image =
|
||||
ValidatedProgramImage::load(&bytes, &mut LoadBudget::new(Default::default()), 0).unwrap();
|
||||
let mut vm = VirtualMachine::from_image(
|
||||
image,
|
||||
RuntimeLimits::default().lowered(RuntimeResource::HandleSlots, 0).unwrap(),
|
||||
);
|
||||
vm.prepare_boot_call().unwrap();
|
||||
struct NoNative;
|
||||
impl NativeInterface for NoNative {
|
||||
fn syscall(
|
||||
&mut self,
|
||||
_: u32,
|
||||
_: &[prometeu_bytecode::Value],
|
||||
_: &mut HostReturn,
|
||||
_: &mut HostContext,
|
||||
) -> Result<(), prometeu_hal::vm_fault::VmFault> {
|
||||
panic!("no native call expected")
|
||||
}
|
||||
}
|
||||
let LogicalFrameEndingReason::Trap(trap) =
|
||||
vm.run_budget(100, &mut NoNative, &mut HostContext::new(None)).unwrap().reason
|
||||
else {
|
||||
panic!("quota must refuse creation")
|
||||
};
|
||||
let wire = fault(&CrashReport::VmTrap { trap });
|
||||
assert_eq!(wire["trap"]["code"], TRAP_RESOURCE_LIMIT);
|
||||
assert_eq!(wire["trap"]["opcode"], 0x52);
|
||||
assert_eq!(wire["trap"]["pc"], 0);
|
||||
assert_eq!(wire["trap"]["resource"]["resource"], "HandleSlots");
|
||||
assert_eq!(wire["trap"]["resource"]["requested"], 1);
|
||||
assert_eq!(wire["trap"]["resource"]["limit"], 0);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn active_host_native_type_fault_preserves_wire_machine_fields() {
|
||||
use prometeu_bytecode::{assemble, model::SyscallDecl};
|
||||
let mut program = prometeu_test_support::program::TestProgram::single(
|
||||
assemble("PUSH_BOOL 1\nHOSTCALL 0\nRET").unwrap(),
|
||||
Default::default(),
|
||||
0,
|
||||
1,
|
||||
);
|
||||
program.syscalls.push(SyscallDecl {
|
||||
module: "gfx2d".into(),
|
||||
name: "clear".into(),
|
||||
version: 1,
|
||||
arg_slots: 1,
|
||||
ret_slots: 0,
|
||||
});
|
||||
let dir = std::env::temp_dir().join(format!("prometeu-native-wire-{}", std::process::id()));
|
||||
std::fs::create_dir_all(&dir).unwrap();
|
||||
std::fs::write(dir.join("program.pbx"), program.serialize()).unwrap();
|
||||
std::fs::write(dir.join("manifest.json"), r#"{"magic":"PMTU","cartridge_version":1,"app_id":78,"title":"Native fault","app_version":"1.0.0","app_mode":"Game","capabilities":["gfx2d"]}"#).unwrap();
|
||||
let mut host = crate::HeadlessHost::new();
|
||||
host.boot(dir.to_string_lossy()).unwrap();
|
||||
let crate::AdvanceFrameOutcome::Faulted(report) = host.advance_frame().unwrap() else {
|
||||
panic!("clear requires an integer color")
|
||||
};
|
||||
let wire = fault(&report);
|
||||
assert_eq!(wire["trap"]["code"], prometeu_bytecode::TRAP_TYPE);
|
||||
assert_eq!(wire["trap"]["opcode"], 0x70);
|
||||
assert_eq!(wire["trap"]["pc"], 3);
|
||||
assert_eq!(wire["pc"], 3);
|
||||
assert_eq!(wire["initError"], Value::Null);
|
||||
std::fs::remove_dir_all(dir).unwrap();
|
||||
}
|
||||
|
||||
@@ -431,10 +431,12 @@ impl RuntimePlatform for HeadlessPlatform {
|
||||
|
||||
#[cfg(test)]
|
||||
mod tests {
|
||||
use prometeu_bytecode::registry::FunctionDecl;
|
||||
use prometeu_test_support::program::{TestProgram, int64_signature};
|
||||
use std::fs;
|
||||
|
||||
use prometeu_bytecode::assembler::assemble;
|
||||
use prometeu_bytecode::model::{BytecodeModule, Export, FunctionMeta};
|
||||
use prometeu_bytecode::model::Export;
|
||||
|
||||
use super::{AdvanceFrameOutcome, HeadlessHost};
|
||||
|
||||
@@ -467,16 +469,16 @@ mod tests {
|
||||
fs::create_dir_all(&directory).expect("create test cartridge");
|
||||
|
||||
let code = assemble("JMP 0\n").expect("assemble non-closing program");
|
||||
let module = BytecodeModule {
|
||||
version: 0,
|
||||
let module = TestProgram {
|
||||
const_pool: vec![],
|
||||
functions: vec![FunctionMeta {
|
||||
functions: vec![FunctionDecl {
|
||||
code_offset: 0,
|
||||
code_len: code.len() as u32,
|
||||
param_slots: 0,
|
||||
local_slots: 0,
|
||||
return_slots: 0,
|
||||
max_stack_slots: 1,
|
||||
signature: int64_signature(0, 0),
|
||||
captures: vec![],
|
||||
name: None,
|
||||
}],
|
||||
code,
|
||||
debug_info: None,
|
||||
|
||||
@@ -1,9 +1,11 @@
|
||||
use prometeu_bytecode::registry::FunctionDecl;
|
||||
use prometeu_test_support::program::{TestProgram, int64_signature};
|
||||
use std::fs;
|
||||
use std::path::Path;
|
||||
|
||||
use prometeu_bytecode::SourceSpan;
|
||||
use prometeu_bytecode::assembler::assemble;
|
||||
use prometeu_bytecode::model::{BytecodeModule, DebugInfo, Export, FunctionMeta, SyscallDecl};
|
||||
use prometeu_bytecode::model::{DebugInfo, Export, SyscallDecl};
|
||||
use prometeu_hal::InputSignals;
|
||||
use prometeu_hal::app_mode::AppMode;
|
||||
use prometeu_hal::color::Color;
|
||||
@@ -487,9 +489,9 @@ fn color_program() -> Vec<u8> {
|
||||
INTRINSIC 0x210E\n"));
|
||||
let jump_to_blue = rom.len() + 2;
|
||||
rom.extend(asm("JMP_IF_FALSE 0"));
|
||||
rom.extend(asm(&format!("PUSH_I64 {RED}\nHOSTCALL 0\nFRAME_SYNC\nRET\n")));
|
||||
rom.extend(asm(&format!("PUSH_I64 {RED}\nHOSTCALL 0\nRET\n")));
|
||||
let blue_at = rom.len() as u32;
|
||||
rom.extend(asm(&format!("PUSH_I64 {BLUE}\nHOSTCALL 0\nFRAME_SYNC\nRET\n")));
|
||||
rom.extend(asm(&format!("PUSH_I64 {BLUE}\nHOSTCALL 0\nRET\n")));
|
||||
rom[jump_to_blue..jump_to_blue + 4].copy_from_slice(&blue_at.to_le_bytes());
|
||||
module(rom, color_syscalls())
|
||||
}
|
||||
@@ -497,20 +499,20 @@ fn color_program() -> Vec<u8> {
|
||||
fn input_edge_program() -> Vec<u8> {
|
||||
let mut rom = Vec::new();
|
||||
let pressed_jump = emit_right_predicate(&mut rom, 0x210C);
|
||||
rom.extend(asm(&format!("PUSH_I64 {RED}\nHOSTCALL 0\nFRAME_SYNC\nRET\n")));
|
||||
rom.extend(asm(&format!("PUSH_I64 {RED}\nHOSTCALL 0\nRET\n")));
|
||||
let released_at = rom.len() as u32;
|
||||
rom[pressed_jump..pressed_jump + 4].copy_from_slice(&released_at.to_le_bytes());
|
||||
|
||||
let released_jump = emit_right_predicate(&mut rom, 0x210D);
|
||||
rom.extend(asm(&format!("PUSH_I64 {GREEN}\nHOSTCALL 0\nFRAME_SYNC\nRET\n")));
|
||||
rom.extend(asm(&format!("PUSH_I64 {GREEN}\nHOSTCALL 0\nRET\n")));
|
||||
let down_at = rom.len() as u32;
|
||||
rom[released_jump..released_jump + 4].copy_from_slice(&down_at.to_le_bytes());
|
||||
|
||||
let down_jump = emit_right_predicate(&mut rom, 0x210E);
|
||||
rom.extend(asm(&format!("PUSH_I64 {BLUE}\nHOSTCALL 0\nFRAME_SYNC\nRET\n")));
|
||||
rom.extend(asm(&format!("PUSH_I64 {BLUE}\nHOSTCALL 0\nRET\n")));
|
||||
let idle_at = rom.len() as u32;
|
||||
rom[down_jump..down_jump + 4].copy_from_slice(&idle_at.to_le_bytes());
|
||||
rom.extend(asm(&format!("PUSH_I64 {BLACK}\nHOSTCALL 0\nFRAME_SYNC\nRET\n")));
|
||||
rom.extend(asm(&format!("PUSH_I64 {BLACK}\nHOSTCALL 0\nRET\n")));
|
||||
|
||||
module(rom, gfx_syscalls())
|
||||
}
|
||||
@@ -525,20 +527,20 @@ fn emit_right_predicate(rom: &mut Vec<u8>, predicate: u32) -> usize {
|
||||
fn touch_edge_program() -> Vec<u8> {
|
||||
let mut rom = Vec::new();
|
||||
let pressed_jump = emit_touch_predicate(&mut rom, 0x2130);
|
||||
rom.extend(asm(&format!("PUSH_I64 {RED}\nHOSTCALL 0\nFRAME_SYNC\nRET\n")));
|
||||
rom.extend(asm(&format!("PUSH_I64 {RED}\nHOSTCALL 0\nRET\n")));
|
||||
let released_at = rom.len() as u32;
|
||||
rom[pressed_jump..pressed_jump + 4].copy_from_slice(&released_at.to_le_bytes());
|
||||
|
||||
let released_jump = emit_touch_predicate(&mut rom, 0x2131);
|
||||
rom.extend(asm(&format!("PUSH_I64 {GREEN}\nHOSTCALL 0\nFRAME_SYNC\nRET\n")));
|
||||
rom.extend(asm(&format!("PUSH_I64 {GREEN}\nHOSTCALL 0\nRET\n")));
|
||||
let down_at = rom.len() as u32;
|
||||
rom[released_jump..released_jump + 4].copy_from_slice(&down_at.to_le_bytes());
|
||||
|
||||
let down_jump = emit_touch_predicate(&mut rom, 0x2132);
|
||||
rom.extend(asm(&format!("PUSH_I64 {BLUE}\nHOSTCALL 0\nFRAME_SYNC\nRET\n")));
|
||||
rom.extend(asm(&format!("PUSH_I64 {BLUE}\nHOSTCALL 0\nRET\n")));
|
||||
let idle_at = rom.len() as u32;
|
||||
rom[down_jump..down_jump + 4].copy_from_slice(&idle_at.to_le_bytes());
|
||||
rom.extend(asm(&format!("PUSH_I64 {BLACK}\nHOSTCALL 0\nFRAME_SYNC\nRET\n")));
|
||||
rom.extend(asm(&format!("PUSH_I64 {BLACK}\nHOSTCALL 0\nRET\n")));
|
||||
|
||||
module(rom, gfx_syscalls())
|
||||
}
|
||||
@@ -557,7 +559,7 @@ fn emit_touch_predicate(rom: &mut Vec<u8>, predicate: u32) -> usize {
|
||||
fn fault_program() -> Vec<u8> {
|
||||
// `INTRINSIC 0xDEADBEEF` is rejected by the loader as `VerificationFailed`.
|
||||
// `TRAP` is a legal instruction that becomes `CrashReport::VmTrap` at runtime.
|
||||
module(asm("TRAP\nFRAME_SYNC\nRET\n"), vec![])
|
||||
module(asm("TRAP\nRET\n"), vec![])
|
||||
}
|
||||
|
||||
fn delayed_fault_program() -> Vec<u8> {
|
||||
@@ -567,7 +569,7 @@ fn delayed_fault_program() -> Vec<u8> {
|
||||
rom.extend(asm("JMP_IF_FALSE 0\nTRAP\n"));
|
||||
let continue_at = rom.len() as u32;
|
||||
rom[continue_jump..continue_jump + 4].copy_from_slice(&continue_at.to_le_bytes());
|
||||
rom.extend(asm(&format!("PUSH_I64 {BLACK}\nHOSTCALL 0\nFRAME_SYNC\nRET\n")));
|
||||
rom.extend(asm(&format!("PUSH_I64 {BLACK}\nHOSTCALL 0\nRET\n")));
|
||||
module(rom, gfx_syscalls())
|
||||
}
|
||||
|
||||
@@ -575,7 +577,7 @@ fn multi_tick_program() -> Vec<u8> {
|
||||
let mut rom = asm("PUSH_I32 30000\nSET_LOCAL 0\n");
|
||||
let loop_at = rom.len() as u32;
|
||||
rom.extend(asm("GET_LOCAL 0\nPUSH_I32 1\nSUB\nSET_LOCAL 0\nGET_LOCAL 0\nPUSH_I32 0\nGT\n"));
|
||||
rom.extend(asm(&format!("JMP_IF_TRUE {loop_at}\nFRAME_SYNC\nRET\n")));
|
||||
rom.extend(asm(&format!("JMP_IF_TRUE {loop_at}\nRET\n")));
|
||||
module_with_locals(rom, vec![], 1)
|
||||
}
|
||||
|
||||
@@ -613,16 +615,16 @@ fn module(code: Vec<u8>, syscalls: Vec<SyscallDecl>) -> Vec<u8> {
|
||||
}
|
||||
|
||||
fn module_with_locals(code: Vec<u8>, syscalls: Vec<SyscallDecl>, local_slots: u16) -> Vec<u8> {
|
||||
BytecodeModule {
|
||||
version: 0,
|
||||
TestProgram {
|
||||
const_pool: vec![],
|
||||
functions: vec![FunctionMeta {
|
||||
functions: vec![FunctionDecl {
|
||||
code_offset: 0,
|
||||
code_len: code.len() as u32,
|
||||
param_slots: 0,
|
||||
local_slots,
|
||||
return_slots: 0,
|
||||
local_slots: u32::from(local_slots),
|
||||
max_stack_slots: 8,
|
||||
signature: int64_signature(0, 0),
|
||||
captures: vec![],
|
||||
name: None,
|
||||
}],
|
||||
code,
|
||||
debug_info: Some(DebugInfo {
|
||||
|
||||
@@ -1,5 +1,7 @@
|
||||
//! Independent catalogue and execution oracles for the fixed input ABI.
|
||||
use prometeu_bytecode::{TRAP_INVALID_INTRINSIC, TRAP_UNAVAILABLE, Value, assembler::assemble};
|
||||
use prometeu_test_support::program::{TestProgram, int64_signature};
|
||||
use prometeu_vm::ValidatedProgramImage;
|
||||
// Independent catalogue and execution oracles for the fixed input ABI.
|
||||
use prometeu_bytecode::{TRAP_UNAVAILABLE, Value, assembler::assemble};
|
||||
use prometeu_drivers::TestPlatform;
|
||||
use prometeu_hal::{InputSignals, RuntimePlatform, vm_fault::VmFault};
|
||||
use prometeu_vm::{
|
||||
@@ -188,7 +190,7 @@ fn vm_queries_charge_one_cycle_each_and_allocate_no_guest_objects() {
|
||||
for id in 0x2100..=0x2135 {
|
||||
source.push_str(&format!("INTRINSIC {id}\n"));
|
||||
}
|
||||
let mut vm = VirtualMachine::new(assemble(&source).unwrap(), vec![]);
|
||||
let mut vm = query_vm(assemble(&(source + "HALT\n")).unwrap());
|
||||
vm.prepare_call("0").expect("prepare entry call");
|
||||
let objects = vm.heap().len();
|
||||
let mut platform = TestPlatform::new();
|
||||
@@ -216,16 +218,36 @@ fn every_known_query_faults_when_unavailable_and_rejects_arguments() {
|
||||
(meta.implementation)(&[Value::Int64(0)], &mut ctx),
|
||||
Err(IntrinsicExecutionError::ArityMismatch { expected: 0, got: 1 })
|
||||
);
|
||||
let mut vm = VirtualMachine::new(assemble(&format!("INTRINSIC {id}\n")).unwrap(), vec![]);
|
||||
let mut vm = query_vm(assemble(&format!("INTRINSIC {id}\nHALT")).unwrap());
|
||||
vm.prepare_call("0").expect("prepare entry call");
|
||||
let report = vm.run_budget(10, &mut NoSyscalls, &mut ctx).unwrap();
|
||||
assert!(matches!(report.reason, LogicalFrameEndingReason::Trap(trap)
|
||||
if trap.code == TRAP_UNAVAILABLE && trap.pc == 0));
|
||||
assert!(vm.operand_stack_top(1).is_empty());
|
||||
}
|
||||
let mut vm = VirtualMachine::new(assemble("INTRINSIC 0x2136\n").unwrap(), vec![]);
|
||||
vm.prepare_call("0").expect("prepare entry call");
|
||||
let report = vm.run_budget(10, &mut NoSyscalls, &mut HostContext::new(None)).unwrap();
|
||||
assert!(matches!(report.reason, LogicalFrameEndingReason::Trap(trap)
|
||||
if trap.code == TRAP_INVALID_INTRINSIC));
|
||||
let bytes = TestProgram::single(
|
||||
assemble("INTRINSIC 0x2136\nHALT").unwrap(),
|
||||
int64_signature(0, 0),
|
||||
0,
|
||||
64,
|
||||
)
|
||||
.serialize();
|
||||
let error = ValidatedProgramImage::load(
|
||||
&bytes,
|
||||
&mut prometeu_bytecode::load_limits::LoadBudget::new(Default::default()),
|
||||
0,
|
||||
)
|
||||
.unwrap_err();
|
||||
assert!(matches!(error, prometeu_vm::VmInitError::RegistryLoadFailed(_)));
|
||||
}
|
||||
|
||||
fn query_vm(code: Vec<u8>) -> VirtualMachine {
|
||||
let bytes = TestProgram::single(code, int64_signature(0, 0), 0, 64).serialize();
|
||||
let image = ValidatedProgramImage::load(
|
||||
&bytes,
|
||||
&mut prometeu_bytecode::load_limits::LoadBudget::new(Default::default()),
|
||||
0,
|
||||
)
|
||||
.unwrap();
|
||||
VirtualMachine::from_image(image, Default::default())
|
||||
}
|
||||
|
||||
@@ -0,0 +1,248 @@
|
||||
#[allow(dead_code)]
|
||||
#[path = "../../../console/prometeu-vm/tests/support/callables.rs"]
|
||||
mod callables;
|
||||
use callables::{bytes, sig};
|
||||
use prometeu_bytecode::{Value, registry::TypeId};
|
||||
use prometeu_host_headless::{AdvanceFrameOutcome, HeadlessHost};
|
||||
|
||||
fn cartridge(program: &[u8], name: &str) -> std::path::PathBuf {
|
||||
let dir =
|
||||
std::env::temp_dir().join(format!("prometeu-typed-runtime-{}-{name}", std::process::id()));
|
||||
std::fs::create_dir_all(&dir).unwrap();
|
||||
std::fs::write(dir.join("program.pbx"), program).unwrap();
|
||||
std::fs::write(dir.join("manifest.json"),r#"{"magic":"PMTU","cartridge_version":1,"app_id":77,"title":"Typed runtime","app_version":"1.0.0","app_mode":"Game","capabilities":[]}"#).unwrap();
|
||||
dir
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn sync_in_callee_or_closure_resumes_next_pc_with_locals_and_init_once() {
|
||||
for captured in [false, true] {
|
||||
let root = "GET_GLOBAL 0\nPUSH_I32 0\nEQ\nJMP_IF_FALSE 52\nPUSH_I32 1\nSET_GLOBAL 0\nGET_GLOBAL 1\nPUSH_I32 1\nADD\nSET_GLOBAL 1\nGET_GLOBAL 2\nPUSH_I32 1\nADD\nSET_GLOBAL 2\nCALL 1\nGET_GLOBAL 1\nGET_GLOBAL 2\nGET_GLOBAL 3\nRET";
|
||||
let callee = "PUSH_I32 73\nSET_LOCAL 0\nFRAME_SYNC\nGET_LOCAL 0\nSET_GLOBAL 3\nRET";
|
||||
let adapter = "PUSH_I32 73\nMAKE_CLOSURE fn=2,type=9\nCALL_CLOSURE 9\nRET";
|
||||
let closure = "GET_CAPTURE 0\nSET_LOCAL 0\nFRAME_SYNC\nGET_LOCAL 0\nSET_GLOBAL 3\nRET";
|
||||
let mut bodies = vec![
|
||||
(root, sig(&[], &[0, 0, 0]), vec![]),
|
||||
(if captured { adapter } else { callee }, sig(&[], &[]), vec![]),
|
||||
];
|
||||
if captured {
|
||||
bodies.push((closure, sig(&[], &[]), vec![TypeId(0)]));
|
||||
}
|
||||
let program = bytes(&bodies, vec![], &[]).unwrap();
|
||||
let dir = cartridge(&program, if captured { "closure" } else { "callee" });
|
||||
let mut host = HeadlessHost::new();
|
||||
host.boot(dir.to_string_lossy()).unwrap();
|
||||
for entry in 1..=3 {
|
||||
let AdvanceFrameOutcome::FrameCompleted { logical_frame_index: sync, .. } =
|
||||
host.advance_frame().unwrap()
|
||||
else {
|
||||
panic!("sync failed {:?}", host.get_fault())
|
||||
};
|
||||
assert_eq!(sync, (entry * 2 - 1) as u64);
|
||||
let sync_pc = host.get_state().pc;
|
||||
assert!(sync_pc > 0);
|
||||
let first = host.capture_frame().unwrap();
|
||||
let AdvanceFrameOutcome::FrameCompleted { logical_frame_index: completion, .. } =
|
||||
host.advance_frame().unwrap()
|
||||
else {
|
||||
panic!("root failed {:?}", host.get_fault())
|
||||
};
|
||||
assert_eq!(completion, (entry * 2) as u64);
|
||||
assert_eq!(
|
||||
&*host.get_state().stack_top,
|
||||
&[Value::Int32(73), Value::Int32(entry), Value::Int32(1)]
|
||||
);
|
||||
let second = host.capture_frame().unwrap();
|
||||
assert_ne!(first.frame.frame_id, second.frame.frame_id);
|
||||
}
|
||||
std::fs::remove_dir_all(dir).unwrap();
|
||||
}
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn regenerated_cartridges_run_six_complete_frames_on_production_host() {
|
||||
use prometeu_hal::{
|
||||
HostContext, HostReturn, NativeInterface,
|
||||
syscalls::{Syscall, caps},
|
||||
};
|
||||
struct Effects {
|
||||
scene_binds: usize,
|
||||
frame_commands: usize,
|
||||
}
|
||||
impl NativeInterface for Effects {
|
||||
fn syscall(
|
||||
&mut self,
|
||||
id: u32,
|
||||
_: &[Value],
|
||||
results: &mut HostReturn,
|
||||
_: &mut HostContext,
|
||||
) -> Result<(), prometeu_hal::vm_fault::VmFault> {
|
||||
let syscall = Syscall::from_u32(id).unwrap();
|
||||
if syscall == Syscall::ComposerBindScene {
|
||||
self.scene_binds += 1;
|
||||
}
|
||||
if matches!(syscall, Syscall::GfxClear | Syscall::ComposerSetCamera) {
|
||||
self.frame_commands += 1;
|
||||
}
|
||||
for _ in 0..syscall.results_count() {
|
||||
results.push_int(0);
|
||||
}
|
||||
Ok(())
|
||||
}
|
||||
}
|
||||
let root =
|
||||
std::path::Path::new(env!("CARGO_MANIFEST_DIR")).join("../../..").join("test-cartridges");
|
||||
for name in ["dummy-boy", "stress-console"] {
|
||||
let mut host = HeadlessHost::new();
|
||||
host.boot(root.join(name).to_string_lossy()).unwrap();
|
||||
let mut hashes = vec![];
|
||||
for expected in 1..=6 {
|
||||
let AdvanceFrameOutcome::FrameCompleted { logical_frame_index, .. } =
|
||||
host.advance_frame().unwrap()
|
||||
else {
|
||||
panic!("{name}: {:?}", host.get_fault())
|
||||
};
|
||||
assert_eq!(logical_frame_index, expected);
|
||||
let frame = host.capture_frame().unwrap();
|
||||
hashes.push(
|
||||
frame
|
||||
.frame
|
||||
.pixels
|
||||
.iter()
|
||||
.fold(0u64, |sum, &p| sum.wrapping_mul(31).wrapping_add(p as u64)),
|
||||
);
|
||||
assert_eq!(frame.logical_frame_index, expected);
|
||||
}
|
||||
assert!(hashes.windows(2).all(|h| h[0] != h[1]), "{name} visuals did not progress");
|
||||
assert!(host.get_fault().is_none());
|
||||
// Observe the original program's one-time scene binding separately
|
||||
// from the real host's visual smoke; no guest globals are exposed.
|
||||
let program = std::fs::read(root.join(name).join("program.pbx")).unwrap();
|
||||
let image = prometeu_vm::ValidatedProgramImage::load(
|
||||
&program,
|
||||
&mut prometeu_bytecode::load_limits::LoadBudget::new(Default::default()),
|
||||
caps::ALL,
|
||||
)
|
||||
.unwrap();
|
||||
let mut vm = prometeu_vm::VirtualMachine::from_image(image, Default::default());
|
||||
let mut effects = Effects { scene_binds: 0, frame_commands: 0 };
|
||||
for _ in 0..6 {
|
||||
vm.prepare_boot_call().unwrap();
|
||||
assert_eq!(
|
||||
vm.run_budget(1_000_000, &mut effects, &mut HostContext::new(None)).unwrap().reason,
|
||||
prometeu_vm::LogicalFrameEndingReason::EndOfRom,
|
||||
);
|
||||
}
|
||||
assert_eq!(effects.frame_commands, 6);
|
||||
assert_eq!(effects.scene_binds, usize::from(name == "stress-console"));
|
||||
}
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn budget_exhaustion_inside_fn_keeps_the_same_open_logical_frame() {
|
||||
let mut body = "NOP\n".repeat(260_000);
|
||||
body.push_str("GET_CAPTURE 0\nRET");
|
||||
let program = bytes(
|
||||
&[
|
||||
("PUSH_I32 37\nMAKE_CLOSURE fn=1,type=4\nCALL_CLOSURE 4\nRET", sig(&[], &[0]), vec![]),
|
||||
(&body, sig(&[], &[0]), vec![TypeId(0)]),
|
||||
],
|
||||
vec![],
|
||||
&[],
|
||||
)
|
||||
.unwrap();
|
||||
let dir = cartridge(&program, "budget");
|
||||
let mut host = HeadlessHost::new();
|
||||
host.boot(dir.to_string_lossy()).unwrap();
|
||||
let before = host.get_state();
|
||||
assert!(matches!(
|
||||
host.advance_frame().unwrap(),
|
||||
AdvanceFrameOutcome::FrameCompleted { logical_frame_index: 1, .. }
|
||||
));
|
||||
let after = host.get_state();
|
||||
assert!(after.tick_index >= before.tick_index + 2);
|
||||
assert_eq!(&*after.stack_top, &[Value::Int32(37)]);
|
||||
assert_eq!(host.capture_frame().unwrap().logical_frame_index, 1);
|
||||
std::fs::remove_dir_all(dir).unwrap();
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn active_host_preserves_removed_opcode_load_context_and_null_fn_trap() {
|
||||
let mut program = bytes(&[("HALT", sig(&[], &[]), vec![])], vec![], &[]).unwrap();
|
||||
let mut budget = prometeu_bytecode::load_limits::LoadBudget::new(Default::default());
|
||||
let code = prometeu_bytecode::registry_codec::PbxEnvelope::parse(&program, &mut budget)
|
||||
.unwrap()
|
||||
.section(2)
|
||||
.unwrap()
|
||||
.offset;
|
||||
program[code..code + 2].copy_from_slice(&0x55u16.to_le_bytes());
|
||||
let dir = cartridge(&program, "removed");
|
||||
let mut host = HeadlessHost::new();
|
||||
let Err(prometeu_host_headless::HostError::BootFailed { report: Some(report), .. }) =
|
||||
host.boot(dir.to_string_lossy())
|
||||
else {
|
||||
panic!("invalid opcode must fail boot")
|
||||
};
|
||||
let diagnostic = report.init_diagnostic().unwrap();
|
||||
assert_eq!(diagnostic["load"]["code"], "LOAD_INVALID_CODE");
|
||||
assert_eq!(diagnostic["load"]["reason"], "RemovedOpcode");
|
||||
assert_eq!(diagnostic["load"]["section"], 2);
|
||||
assert_eq!(diagnostic["load"]["function"], 0);
|
||||
std::fs::remove_dir_all(dir).unwrap();
|
||||
let program = bytes(
|
||||
&[(
|
||||
"STRUCT_NEW 15\nSTRUCT_GET type=15,field=0\nCALL_CLOSURE 4\nRET",
|
||||
sig(&[], &[0]),
|
||||
vec![],
|
||||
)],
|
||||
vec![],
|
||||
&[],
|
||||
)
|
||||
.unwrap();
|
||||
let dir = cartridge(&program, "null");
|
||||
let mut host = HeadlessHost::new();
|
||||
host.boot(dir.to_string_lossy()).unwrap();
|
||||
let AdvanceFrameOutcome::Faulted(prometeu_system::CrashReport::VmTrap { trap }) =
|
||||
host.advance_frame().unwrap()
|
||||
else {
|
||||
panic!("null callback must trap")
|
||||
};
|
||||
assert_eq!(
|
||||
(trap.code, trap.opcode, trap.pc),
|
||||
(prometeu_bytecode::TRAP_NULL_REFERENCE, 0x53, 16)
|
||||
);
|
||||
std::fs::remove_dir_all(dir).unwrap();
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn typed_native_argument_fault_inside_callback_reaches_active_host() {
|
||||
let program = callables::bytes_with_syscalls(
|
||||
&[
|
||||
("MAKE_CLOSURE fn=1,type=9\nCALL_CLOSURE 9\nRET", sig(&[], &[]), vec![]),
|
||||
("PUSH_BOOL 1\nSET_GLOBAL 0\nGET_GLOBAL 0\nHOSTCALL 0\nRET", sig(&[], &[]), vec![]),
|
||||
],
|
||||
vec![],
|
||||
&[],
|
||||
&[prometeu_bytecode::model::SyscallDecl {
|
||||
module: "gfx2d".into(),
|
||||
name: "clear".into(),
|
||||
version: 1,
|
||||
arg_slots: 1,
|
||||
ret_slots: 0,
|
||||
}],
|
||||
)
|
||||
.unwrap();
|
||||
let dir = cartridge(&program, "native-fault");
|
||||
std::fs::write(dir.join("manifest.json"), r#"{"magic":"PMTU","cartridge_version":1,"app_id":77,"title":"Typed runtime","app_version":"1.0.0","app_mode":"Game","capabilities":["gfx2d"]}"#).unwrap();
|
||||
let mut host = HeadlessHost::new();
|
||||
host.boot(dir.to_string_lossy()).unwrap();
|
||||
let AdvanceFrameOutcome::Faulted(report @ prometeu_system::CrashReport::VmTrap { .. }) =
|
||||
host.advance_frame().unwrap()
|
||||
else {
|
||||
panic!("clear requires an integer color carrier")
|
||||
};
|
||||
let prometeu_system::CrashReport::VmTrap { trap } = &report else { unreachable!() };
|
||||
assert_eq!((trap.code, trap.opcode, trap.pc), (prometeu_bytecode::TRAP_TYPE, 0x70, 33));
|
||||
assert_eq!(host.get_fault().as_ref(), Some(&report));
|
||||
std::fs::remove_dir_all(dir).unwrap();
|
||||
}
|
||||
Reference in New Issue
Block a user