220 lines
13 KiB
Rust
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");
|
|
}
|