Move Storm Eagle playback and source assets to Stress Console and keep Dummy Boy silent. Exercise VM math, seeded Random and persistent typed particles with a projected tunnel, bounded 512-sprite heavy workload, reproducible replays and measured costs.
199 lines
7.2 KiB
Rust
199 lines
7.2 KiB
Rust
mod support;
|
|
use pbxgen_stress::{Preset, DEFAULT_SEED};
|
|
use support::*;
|
|
|
|
#[test]
|
|
fn presets_replay_native_state_without_churn_or_sprite_overflow() {
|
|
for preset in [Preset::Light, Preset::Normal, Preset::Heavy] {
|
|
let mut a = vm(preset, DEFAULT_SEED);
|
|
let mut b = vm(preset, DEFAULT_SEED);
|
|
let mut other = vm(preset, DEFAULT_SEED + 1);
|
|
let mut na = Workload::default();
|
|
let mut nb = Workload::default();
|
|
let mut no = Workload::default();
|
|
let mut previous = vec![];
|
|
for f in 1..=6 {
|
|
let cycles = frame(&mut a, &mut na);
|
|
assert_eq!(cycles, frame(&mut b, &mut nb));
|
|
frame(&mut other, &mut no);
|
|
let state = particle_bits(&a);
|
|
assert_eq!(state, particle_bits(&b));
|
|
assert_ne!(state, particle_bits(&other));
|
|
assert_ne!(state, previous);
|
|
previous = state;
|
|
assert_eq!(previous.len(), preset.particles() as usize * 6);
|
|
assert_eq!(a.heap().len(), preset.particles() as usize + 2);
|
|
assert_eq!(na.submitted, f * (preset.particles() as usize + 128));
|
|
assert_eq!(na.sprites.sprite_count(), preset.particles() as usize + 128);
|
|
assert_eq!(na.sprites.dropped_sprites(), 0);
|
|
assert_eq!(na.errors, 0);
|
|
}
|
|
assert_eq!(na.binds, 1);
|
|
assert_eq!(na.plays, 1);
|
|
assert_eq!(na.camera, 6);
|
|
assert_eq!(na.text, 24);
|
|
let expected = match preset {
|
|
Preset::Light => 0xa0277985ff4cefcd,
|
|
Preset::Normal => 0x3a9cf871667c92ee,
|
|
Preset::Heavy => 0x57257956419e88d2,
|
|
};
|
|
assert_eq!(hash(&previous), expected, "guest numeric replay changed");
|
|
println!("replay={} hash={:016x}", preset.name(), hash(&previous));
|
|
}
|
|
}
|
|
|
|
#[test]
|
|
fn actual_intrinsic_execution_and_particle_rebirth() {
|
|
use prometeu_bytecode::{
|
|
decode_next, isa::core::CoreOpCode, load_limits::LoadBudget, registry_codec::PbxEnvelope,
|
|
};
|
|
use prometeu_hal::HostContext;
|
|
use prometeu_vm::LogicalFrameEndingReason as End;
|
|
use std::collections::BTreeMap;
|
|
let bytes = pbxgen_stress::build_program_with(Preset::Light, 42);
|
|
let mut budget = LoadBudget::new(Default::default());
|
|
let envelope = PbxEnvelope::parse(&bytes, &mut budget).unwrap();
|
|
let section = envelope.section(2).unwrap();
|
|
let code = section.bytes;
|
|
let mut sites = BTreeMap::new();
|
|
let mut pc = 0;
|
|
while pc < code.len() {
|
|
let i = decode_next(pc, code).unwrap();
|
|
if i.opcode == CoreOpCode::Intrinsic {
|
|
sites.insert(pc, i.imm_u32().unwrap());
|
|
}
|
|
pc = i.next_pc;
|
|
}
|
|
let mut v = vm(Preset::Light, 42);
|
|
for &pc in sites.keys() {
|
|
v.insert_breakpoint(pc);
|
|
}
|
|
let mut n = Workload::default();
|
|
v.prepare_boot_call().unwrap();
|
|
let mut calls = BTreeMap::<u32, usize>::new();
|
|
loop {
|
|
if let Some(&id) = sites.get(&v.pc()) {
|
|
*calls.entry(id).or_default() += 1;
|
|
v.step(&mut n, &mut HostContext::new(None)).unwrap();
|
|
continue;
|
|
}
|
|
let r = v.run_budget(250_000, &mut n, &mut HostContext::new(None)).unwrap();
|
|
match r.reason {
|
|
End::Breakpoint | End::BudgetExhausted => {}
|
|
End::EndOfRom => break,
|
|
x => panic!("{x:?}"),
|
|
}
|
|
}
|
|
println!("executed_intrinsic_calls={calls:?}");
|
|
for (owner, name, min) in [
|
|
("random", "new", 1),
|
|
("random", "nextf", 256),
|
|
("random", "range", 64),
|
|
("random", "next", 64),
|
|
("mathf", "sin", 192),
|
|
("mathf", "cos", 192),
|
|
("mathf", "atan2", 64),
|
|
("mathf", "sqrt", 64),
|
|
("mathf", "clamp", 256),
|
|
("vec2", "dot", 64),
|
|
("vec2", "length", 64),
|
|
] {
|
|
let id = prometeu_vm::lookup_intrinsic(owner, name, 1).unwrap().id;
|
|
assert!(calls.get(&id).copied().unwrap_or(0) >= min, "{owner}.{name}: {calls:?}");
|
|
}
|
|
for pc in sites.keys() {
|
|
v.remove_breakpoint(*pc);
|
|
}
|
|
// Every initial lifetime is <225 frames: all particles must eventually be reborn.
|
|
for _ in 1..230 {
|
|
frame(&mut v, &mut n);
|
|
}
|
|
let lifetimes: Vec<_> = particle_bits(&v).as_chunks::<6>().0.iter().map(|s| s[4]).collect();
|
|
assert!(lifetimes.iter().all(|&life| (1..225).contains(&life)));
|
|
assert_eq!(v.heap().len(), 66);
|
|
assert_eq!(n.plays, 1);
|
|
assert_eq!(n.errors, 0);
|
|
}
|
|
|
|
#[test]
|
|
fn sprite_overflow_is_a_separate_bounded_controller_case() {
|
|
let mut n = Workload::default();
|
|
let mut v = vm(Preset::Heavy, 42);
|
|
frame(&mut v, &mut n);
|
|
let sprite = prometeu_hal::sprite::Sprite {
|
|
glyph: prometeu_hal::glyph::Glyph { glyph_id: 0, palette_id: 8 },
|
|
x: 0,
|
|
y: 0,
|
|
layer: 3,
|
|
bank_id: 0,
|
|
active: false,
|
|
flip_x: false,
|
|
flip_y: false,
|
|
priority: 3,
|
|
};
|
|
for _ in n.sprites.sprite_count()..512 {
|
|
assert!(n.sprites.emit_sprite(sprite));
|
|
}
|
|
assert!(!n.sprites.emit_sprite(sprite));
|
|
assert_eq!(n.sprites.sprite_count(), 512);
|
|
assert_eq!(n.sprites.dropped_sprites(), 1);
|
|
}
|
|
|
|
#[test]
|
|
fn guest_reports_a_failed_submission_instead_of_discarding_status() {
|
|
let mut v = vm(Preset::Light, 42);
|
|
let mut n = Workload { reject_first_sprite: true, ..Default::default() };
|
|
frame(&mut v, &mut n);
|
|
assert_eq!(n.errors, 1);
|
|
frame(&mut v, &mut n);
|
|
assert_eq!(n.errors, 1, "frame status must reset after the failed frame");
|
|
}
|
|
|
|
#[test]
|
|
fn faster_travel_changes_actual_guest_positions() {
|
|
use prometeu_bytecode::{
|
|
decode_next, isa::core::CoreOpCode, load_limits::LoadBudget, registry_codec::PbxEnvelope,
|
|
};
|
|
use prometeu_hal::HostContext;
|
|
use prometeu_vm::LogicalFrameEndingReason as End;
|
|
let bytes = pbxgen_stress::build_program_with(Preset::Light, DEFAULT_SEED);
|
|
let mut budget = LoadBudget::new(Default::default());
|
|
let envelope = PbxEnvelope::parse(&bytes, &mut budget).unwrap();
|
|
let code = envelope.section(2).unwrap().bytes;
|
|
let mut pc = 0;
|
|
let before_update = loop {
|
|
let op = decode_next(pc, code).unwrap();
|
|
if op.opcode == CoreOpCode::Hostcall && op.imm_u32().unwrap() == 2 {
|
|
break pc;
|
|
}
|
|
pc = op.next_pc;
|
|
};
|
|
let mut v = vm(Preset::Light, DEFAULT_SEED);
|
|
let mut n = Workload::default();
|
|
v.insert_breakpoint(before_update);
|
|
v.prepare_boot_call().unwrap();
|
|
assert_eq!(
|
|
v.run_budget(1_000_000, &mut n, &mut HostContext::new(None)).unwrap().reason,
|
|
End::Breakpoint
|
|
);
|
|
let initial = particle_bits(&v);
|
|
v.remove_breakpoint(before_update);
|
|
assert_eq!(
|
|
v.run_budget(1_000_000, &mut n, &mut HostContext::new(None)).unwrap().reason,
|
|
End::EndOfRom
|
|
);
|
|
let updated = particle_bits(&v);
|
|
assert_eq!(initial.len(), updated.len());
|
|
for (before, after) in initial.as_chunks::<6>().0.iter().zip(updated.as_chunks::<6>().0) {
|
|
for (position, velocity) in [(0, 2), (1, 3)] {
|
|
let old = f64::from_bits(before[position]);
|
|
let speed = f64::from_bits(after[velocity]);
|
|
let actual = f64::from_bits(after[position]);
|
|
assert!(
|
|
(actual - (old + 1.5 * speed)).abs() < 1e-10,
|
|
"light preset has one pass: position must advance by 1.5 times velocity"
|
|
);
|
|
}
|
|
}
|
|
}
|