Files
prometeu-studio/tools/pbx-conformance/lifecycle.rs
T

220 lines
13 KiB
Rust

//! Studio-produced PBS images through the production VM and foreground firmware.
use prometeu_bytecode::{Value, registry::LifecycleRole};
use prometeu_drivers::TestPlatform;
use prometeu_firmware::firmware::{Firmware, FirmwareState};
use prometeu_hal::{InputSignals, app_mode::AppMode, cartridge::{Cartridge, AssetsPayloadSource}};
use prometeu_system::task::{TaskId, TaskState};
use prometeu_vm::{HostContext, LogicalFrameEndingReason as Reason, ValidatedProgramImage, VirtualMachine};
use std::path::Path;
fn bytes(root: &Path, name: &str) -> Vec<u8> {
std::fs::read(root.join(format!("{name}.pbx"))).unwrap_or_else(|e| panic!("{name}: {e}"))
}
fn load(root: &Path, name: &str) -> VirtualMachine {
let image = ValidatedProgramImage::load(&bytes(root, name), &mut super::LoadBudget::new(Default::default()), super::caps::NONE).unwrap();
for role in [LifecycleRole::BeforePause, LifecycleRole::BeforeResume] {
if let Some(id) = image.registry().lifecycle_hook(role) { assert_ne!(id.0, 0); }
}
let mut vm = VirtualMachine::from_image(image, Default::default());
vm.prepare_boot_call().unwrap();
let report = vm.run_budget(100_000, &mut super::NoNative, &mut HostContext::new(None)).unwrap();
assert!(matches!(report.reason, Reason::EndOfRom | Reason::Halted), "{name}: {report:?}");
vm
}
fn query(root: &Path, name: &str, vm: &mut VirtualMachine) -> i32 {
let id = std::fs::read_to_string(root.join(format!("{name}.probe"))).unwrap();
vm.prepare_call(id.trim()).unwrap();
let report = vm.run_budget(100_000, &mut super::NoNative, &mut HostContext::new(None)).unwrap();
assert!(matches!(report.reason, Reason::EndOfRom | Reason::Halted), "{name}: {report:?}");
match vm.operand_stack_top(1)[0] { Value::Int32(value) => value, ref other => panic!("{other:?}") }
}
fn finish_hook(vm: &mut VirtualMachine, expected: Reason) -> usize {
let mut previous = vm.lifecycle_remaining_cycles().unwrap();
let mut slices = 0;
loop {
slices += 1; assert!(slices < 16);
let report = vm.run_budget(u64::MAX, &mut super::NoNative, &mut HostContext::new(None)).unwrap();
// Includes the specified whole-instruction overshoot; this corpus uses scalar instructions.
assert!(report.cycles_used <= VirtualMachine::LIFECYCLE_SLICE + 100);
if report.reason != Reason::BudgetExhausted {
assert_eq!(report.reason, expected); break;
}
let remaining = vm.lifecycle_remaining_cycles().unwrap();
assert!(remaining < previous);
assert_eq!(previous.saturating_sub(report.cycles_used), remaining);
previous = remaining;
}
slices
}
fn snapshot(fw: &mut Firmware, task: TaskId) -> (usize, u64, u64) {
// The active foreground facade switches to the crash UI after failure.
// Observe the retained game session so a foreground change cannot reset the oracle.
let sessions = fw.os.sessions();
let session = sessions.vm_session_for_task(task).unwrap();
(session.vm.pc(), session.runtime.tick_index,
session.runtime.atomic_telemetry.completed_logical_frames.load(std::sync::atomic::Ordering::Relaxed) as u64)
}
fn firmware(root: &Path, name: &str) -> (Firmware, TestPlatform, TaskId) {
let mut fw = Firmware::new(None); let mut platform = TestPlatform::new();
fw.load_cartridge(Cartridge {
app_id: 86, title: "Studio PBS lifecycle".into(), app_version: "1.0.0".into(),
app_mode: AppMode::Game, capabilities: super::caps::NONE, memcard_slots: None,
program: bytes(root, name), assets: AssetsPayloadSource::empty(), asset_table: vec![], preload: vec![],
});
fw.tick(&InputSignals::default(), &mut platform);
let task = fw.os.lifecycle().resident_game_task().unwrap();
fw.tick(&InputSignals::default(), &mut platform);
assert!(fw.os.vm().last_crash_report().is_none());
(fw, platform, task)
}
fn foreground_case(root: &Path, name: &str, expected: i32, resume: bool) {
let (mut fw, mut platform, task) = firmware(root, name);
let signals = InputSignals::default();
fw.request_home_from_host();
fw.tick(&signals, &mut platform); // Existing Home handoff, including its gameplay reaction.
let suspended = snapshot(&mut fw, task);
fw.tick(&signals, &mut platform); // Hook only, or already-suspended case without a hook.
assert_eq!(fw.os.lifecycle().task_state(task), Some(TaskState::Suspended), "{name}");
assert_eq!(snapshot(&mut fw, task), suspended, "pause changed gameplay state: {name}");
assert!(fw.resume_resident_game_from_home());
if resume {
fw.tick(&signals, &mut platform); // BeforeResume only.
assert_eq!(snapshot(&mut fw, task), suspended, "resume changed gameplay state: {name}");
}
fw.tick(&signals, &mut platform); // First eligible gameplay frame validates guest stage/init/heap.
assert!(fw.os.vm().last_crash_report().is_none(), "{name}");
assert_eq!(snapshot(&mut fw, task).1, suspended.1 + 1);
let actual = {
let mut sessions = fw.os.sessions();
let session = sessions.vm_session_for_task_mut(task).unwrap();
// Terminal observation only, after all continuation/frame assertions; no later host tick.
query(root, name, &mut session.vm)
};
assert_eq!(actual, expected, "ordered guest effects/init/heap: {name}");
println!("FIRMWARE HOME/RESUME PASS {name}: pc={}, gameplayTicks={}, frames={}, guest={actual}", suspended.0, suspended.1, suspended.2);
}
fn other_foreground_paths(root: &Path, name: &str) {
for shell in [false, true] {
let (mut fw, mut platform, task) = firmware(root, name);
let before = snapshot(&mut fw, task);
if shell { fw.os.sessions().try_create_native_shell_task(99, "Tools").unwrap(); }
else { fw.os.lifecycle().suspend_task(task).unwrap(); }
fw.tick(&InputSignals::default(), &mut platform);
assert_eq!(fw.os.lifecycle().task_state(task), Some(TaskState::Suspended));
assert_eq!(snapshot(&mut fw, task), before);
println!("DIRECT/SHELL SUSPEND PASS {name}: shell={shell}, no reaction tick");
}
let mut vm = load(root, name);
vm.prepare_boot_call().unwrap();
let partial = vm.run_budget(1, &mut super::NoNative, &mut HostContext::new(None)).unwrap();
assert_eq!(partial.reason, Reason::BudgetExhausted);
assert!(!vm.call_stack_is_empty());
let pc = vm.pc(); let stack = vm.operand_stack_top(1000).to_vec();
assert!(!stack.is_empty(), "suspended wrapper must retain an operand");
for role in [LifecycleRole::BeforePause, LifecycleRole::BeforeResume] {
assert!(vm.begin_lifecycle(role).unwrap());
finish_hook(&mut vm, Reason::LifecycleComplete);
assert_eq!(vm.pc(), pc); assert_eq!(vm.operand_stack_top(1000).to_vec(), stack);
assert!(!vm.call_stack_is_empty());
}
let resumed = vm.run_budget(100_000, &mut super::NoNative, &mut HostContext::new(None)).unwrap();
assert!(matches!(resumed.reason, Reason::EndOfRom | Reason::Halted));
assert_eq!(query(root, name, &mut vm), 230112);
println!("SUSPENDED STACK/CONTINUATION PASS {name}: retained operand, frame and heap");
}
pub fn verify(root: &Path) {
for suffix in ["", "-optimized"] {
for (case, expected, resume) in [("both", 230112, true), ("pause", 20109, false), ("resume", 30110, true), ("none", 107, false)] {
let name = format!("pbs-lifecycle-{case}{suffix}");
let mut vm = load(root, &name);
for (role, present) in [(LifecycleRole::BeforePause, case == "both" || case == "pause"), (LifecycleRole::BeforeResume, resume)] {
let pc = vm.pc(); let stack = vm.operand_stack_top(1000).to_vec();
assert_eq!(vm.begin_lifecycle(role).unwrap(), present);
if present {
assert!(vm.begin_lifecycle(role).is_err(), "controlled calls cannot reenter");
finish_hook(&mut vm, Reason::LifecycleComplete);
}
assert_eq!(vm.pc(), pc); assert_eq!(vm.operand_stack_top(1000).to_vec(), stack);
}
vm.prepare_boot_call().unwrap();
let next = vm.run_budget(100_000, &mut super::NoNative, &mut HostContext::new(None)).unwrap();
assert!(matches!(next.reason, Reason::Halted | Reason::EndOfRom));
assert_eq!(query(root, &name, &mut vm), expected);
foreground_case(root, &name, expected, resume);
}
other_foreground_paths(root, &format!("pbs-lifecycle-both{suffix}"));
let name = format!("pbs-lifecycle-direct{suffix}");
let mut vm = load(root, &name);
assert!(!vm.lifecycle_active()); assert_eq!(query(root, &name, &mut vm), 230112);
println!("ORDINARY CALL PASS {name}: no controlled invocation");
let name = format!("pbs-lifecycle-slices{suffix}");
let mut vm = load(root, &name);
vm.begin_lifecycle(LifecycleRole::BeforePause).unwrap();
let hook_pc = vm.pc(); vm.insert_breakpoint(hook_pc);
let remaining = vm.lifecycle_remaining_cycles();
let stopped = vm.run_budget(250_000, &mut super::NoNative, &mut HostContext::new(None)).unwrap();
assert_eq!(stopped.reason, Reason::Breakpoint); assert_eq!(stopped.cycles_used, 0);
assert_eq!(vm.lifecycle_remaining_cycles(), remaining);
vm.remove_breakpoint(hook_pc);
vm.step(&mut super::NoNative, &mut HostContext::new(None)).unwrap();
assert!(vm.lifecycle_remaining_cycles().unwrap() < remaining.unwrap());
assert!(finish_hook(&mut vm, Reason::LifecycleComplete) > 1);
println!("SLICES + DEBUGGER PASS {name}: one retained total fuel budget");
for case in ["trap", "fuel"] {
let name = format!("pbs-lifecycle-{case}{suffix}");
let mut vm = load(root, &name);
vm.begin_lifecycle(LifecycleRole::BeforePause).unwrap();
let mut slices = 0;
let terminal = loop {
slices += 1; assert!(slices < 16);
let report = vm.run_budget(u64::MAX, &mut super::NoNative, &mut HostContext::new(None)).unwrap();
if report.reason != Reason::BudgetExhausted { break report.reason; }
};
if case == "trap" { assert!(matches!(terminal, Reason::Trap(_))); }
else { assert!(matches!(&terminal, Reason::Panic(text) if text.contains("lifecycle total cycle budget exhausted"))); assert!(slices > 1); }
let blocked = vm.run_budget(1000, &mut super::NoNative, &mut HostContext::new(None)).unwrap();
assert_eq!(blocked.reason, terminal); assert_eq!(blocked.steps_executed, 0);
assert!(vm.prepare_boot_call().is_err());
let (mut fw, mut platform, task) = firmware(root, &name);
fw.request_home_from_host(); fw.tick(&InputSignals::default(), &mut platform);
let before = snapshot(&mut fw, task);
for _ in 0..16 {
fw.tick(&InputSignals::default(), &mut platform);
if matches!(fw.state, FirmwareState::AppCrashes(_)) { break; }
}
assert!(matches!(fw.state, FirmwareState::AppCrashes(_)), "{name}");
assert_eq!(snapshot(&mut fw, task).1, before.1);
assert_eq!(snapshot(&mut fw, task).2, before.2);
println!("FATAL + GAMEPLAY BLOCK PASS {name}: {terminal:?}, slices={slices}");
}
}
// These binaries are explicitly synthetic; no PBS sync surface is claimed.
for case in ["direct", "transitive"] {
let name = format!("synthetic-lifecycle-sync-{case}");
let mut vm = load(root, &name);
vm.begin_lifecycle(LifecycleRole::BeforePause).unwrap();
let report = vm.run_budget(100_000, &mut super::NoNative, &mut HostContext::new(None)).unwrap();
assert!(matches!(report.reason, Reason::Trap(_)), "{report:?}");
let again = vm.run_budget(1000, &mut super::NoNative, &mut HostContext::new(None)).unwrap();
assert_eq!(again.steps_executed, 0); assert_eq!(again.reason, report.reason);
let (mut fw, mut platform, task) = firmware(root, &name);
fw.request_home_from_host(); fw.tick(&InputSignals::default(), &mut platform);
let before = snapshot(&mut fw, task);
fw.tick(&InputSignals::default(), &mut platform);
assert!(matches!(fw.state, FirmwareState::AppCrashes(_)));
assert_eq!(snapshot(&mut fw, task).1, before.1); assert_eq!(snapshot(&mut fw, task).2, before.2);
println!("SYNTHETIC SYNC REJECTION PASS {case}: no gameplay/frame publication");
}
let name = "pbs-lifecycle-imports";
let mut vm = load(root, name);
assert!(vm.begin_lifecycle(LifecycleRole::BeforePause).unwrap());
finish_hook(&mut vm, Reason::LifecycleComplete);
assert!(!vm.has_lifecycle_hook(LifecycleRole::BeforeResume));
println!("PRODUCTION PIPELINE IMPORTS PASS: alias/reexport selected one original hook");
}