feat(stress): add a deterministic particle demo with sequenced music
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.
This commit is contained in:
@@ -0,0 +1,82 @@
|
||||
use pbxgen_stress::{Preset, DEFAULT_SEED};
|
||||
use prometeu_host_headless::{AdvanceFrameOutcome, HeadlessHost};
|
||||
use std::path::PathBuf;
|
||||
struct Cart(PathBuf);
|
||||
impl Cart {
|
||||
fn new(seed: i64) -> Self {
|
||||
let unique =
|
||||
std::time::SystemTime::now().duration_since(std::time::UNIX_EPOCH).unwrap().as_nanos();
|
||||
let path =
|
||||
std::env::temp_dir().join(format!("prometeu-demo-{}-{unique}", std::process::id()));
|
||||
pbxgen_stress::generate_with(Preset::Normal, seed, Some(path.clone())).unwrap();
|
||||
Self(path)
|
||||
}
|
||||
fn boot(&self) -> HeadlessHost {
|
||||
let mut h = HeadlessHost::new();
|
||||
h.boot(self.0.to_string_lossy()).unwrap();
|
||||
h
|
||||
}
|
||||
}
|
||||
impl Drop for Cart {
|
||||
fn drop(&mut self) {
|
||||
let _ = std::fs::remove_dir_all(&self.0);
|
||||
}
|
||||
}
|
||||
fn advance(h: &mut HeadlessHost) -> Vec<u32> {
|
||||
assert!(matches!(h.advance_frame().unwrap(), AdvanceFrameOutcome::FrameCompleted { .. }));
|
||||
assert!(h.get_fault().is_none());
|
||||
h.capture_frame().unwrap().frame.pixels
|
||||
}
|
||||
fn hash(v: &[u32]) -> u64 {
|
||||
v.iter().fold(14695981039346656037, |h, &p| (h ^ u64::from(p)).wrapping_mul(1099511628211))
|
||||
}
|
||||
#[test]
|
||||
fn native_visual_replay_seed_and_pause_resume() {
|
||||
let cart = Cart::new(DEFAULT_SEED);
|
||||
let other = Cart::new(DEFAULT_SEED + 1);
|
||||
let mut a = cart.boot();
|
||||
let mut b = cart.boot();
|
||||
let mut changed = other.boot();
|
||||
let mut last = vec![];
|
||||
let mut hashes = vec![];
|
||||
for frame in 0..6 {
|
||||
let actual = advance(&mut a);
|
||||
let expected = advance(&mut b);
|
||||
assert_eq!(actual, expected);
|
||||
assert_ne!(actual, last);
|
||||
hashes.push(hash(&actual));
|
||||
if frame == 0 {
|
||||
assert_ne!(actual, advance(&mut changed));
|
||||
}
|
||||
// Explicit pause freezes audio and does not alter the displayed guest state.
|
||||
a.resume().unwrap();
|
||||
a.pause().unwrap();
|
||||
let before = a.audio_diagnostics().frames;
|
||||
let mut silence = [1.0; 1600];
|
||||
a.render_audio(&mut silence);
|
||||
assert_eq!(silence, [0.0; 1600]);
|
||||
assert_eq!(a.audio_diagnostics().frames, before);
|
||||
assert_eq!(a.capture_frame().unwrap().frame.pixels, actual);
|
||||
a.resume().unwrap();
|
||||
b.resume().unwrap();
|
||||
let mut left = [0.0; 1600];
|
||||
let mut right = [0.0; 1600];
|
||||
a.render_audio(&mut left);
|
||||
b.render_audio(&mut right);
|
||||
assert_eq!(left, right);
|
||||
last = actual;
|
||||
}
|
||||
assert!(a.audio_diagnostics().maximum_voices > 0);
|
||||
println!("visual_hashes={hashes:?}");
|
||||
assert_eq!(
|
||||
hashes,
|
||||
[
|
||||
509059057377717011,
|
||||
11639740206223880472,
|
||||
10144685766373560685,
|
||||
12298401095609708800,
|
||||
8400916329250932746,
|
||||
12687665705214954737
|
||||
]
|
||||
);
|
||||
}
|
||||
@@ -0,0 +1,200 @@
|
||||
use prometeu_drivers::bank_format::{decode_audio_bank, DecodedAudioBank};
|
||||
use prometeu_host_headless::{AdvanceFrameOutcome, HeadlessHost};
|
||||
use std::path::PathBuf;
|
||||
|
||||
struct Cartridge(PathBuf);
|
||||
impl Cartridge {
|
||||
fn new() -> Self {
|
||||
let unique =
|
||||
std::time::SystemTime::now().duration_since(std::time::UNIX_EPOCH).unwrap().as_nanos();
|
||||
let path = std::env::temp_dir()
|
||||
.join(format!("stress-console-music-{}-{unique}", std::process::id()));
|
||||
std::fs::create_dir_all(&path).unwrap();
|
||||
std::fs::write(path.join("program.pbx"), pbxgen_stress::build_program()).unwrap();
|
||||
std::fs::write(path.join("manifest.json"), pbxgen_stress::manifest_json()).unwrap();
|
||||
std::fs::write(path.join("assets.pa"), pbxgen_stress::build_assets_pack().unwrap())
|
||||
.unwrap();
|
||||
Self(path)
|
||||
}
|
||||
|
||||
fn boot(&self) -> HeadlessHost {
|
||||
let mut host = HeadlessHost::new();
|
||||
host.boot(self.0.to_string_lossy()).unwrap();
|
||||
assert!(matches!(
|
||||
host.advance_frame().unwrap(),
|
||||
AdvanceFrameOutcome::FrameCompleted { .. }
|
||||
));
|
||||
host.resume().unwrap();
|
||||
host
|
||||
}
|
||||
}
|
||||
impl Drop for Cartridge {
|
||||
fn drop(&mut self) {
|
||||
let _ = std::fs::remove_dir_all(&self.0);
|
||||
}
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn bank_preserves_transcription_and_mixed_samples() {
|
||||
let bytes = include_bytes!("../music/storm-eagle.mbnk");
|
||||
let decoded =
|
||||
decode_audio_bank(bytes, true).expect("packer bank must load in the real decoder");
|
||||
let metrics: serde_json::Value =
|
||||
serde_json::from_str(include_str!("../music/bank-metrics.json")).unwrap();
|
||||
assert_eq!(decoded.decoded_size() as u64, metrics["decoded_size"].as_u64().unwrap());
|
||||
let DecodedAudioBank::Music(bank) = decoded else { panic!("expected music") };
|
||||
assert_eq!(bank.samples.len(), 8);
|
||||
assert_eq!(bank.instruments.len(), 8);
|
||||
let manifest: serde_json::Value =
|
||||
serde_json::from_str(include_str!("../music/song.json")).unwrap();
|
||||
let lead: Vec<_> = manifest["events"]
|
||||
.as_array()
|
||||
.unwrap()
|
||||
.iter()
|
||||
.filter(|e| e["kind"] == 1 && e["track"] == 0)
|
||||
.collect();
|
||||
assert_eq!(lead.len(), 90);
|
||||
let first_pitches: Vec<_> = lead.iter().take(8).map(|e| e["c"].as_u64().unwrap()).collect();
|
||||
assert_eq!(first_pitches, [71, 70, 71, 73, 74, 73, 71, 78]);
|
||||
assert_eq!(lead[4]["tick"], 3840);
|
||||
assert_eq!(lead[5]["tick"], 4160);
|
||||
assert_eq!(lead[6]["tick"], 4480);
|
||||
assert_eq!(manifest["duration_ticks"], 69120);
|
||||
let mapping: serde_json::Value =
|
||||
serde_json::from_str(include_str!("../music/instrument-mapping.json")).unwrap();
|
||||
assert_eq!(mapping["voicings"].as_array().unwrap().len(), 20);
|
||||
assert_eq!(mapping["voicings"][4]["target_tones"], serde_json::json!([58, 61, 66]));
|
||||
let samples_at = 48 + u32::from_le_bytes(bytes[40..44].try_into().unwrap()) as usize;
|
||||
let codecs: Vec<_> = (0..8).map(|i| bytes[samples_at + i * 40]).collect();
|
||||
assert!(codecs.contains(&0) && codecs.contains(&1));
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn tracked_cartridge_is_the_exact_generator_output() {
|
||||
let root =
|
||||
PathBuf::from(env!("CARGO_MANIFEST_DIR")).join("../../../test-cartridges/stress-console");
|
||||
assert_eq!(std::fs::read(root.join("program.pbx")).unwrap(), pbxgen_stress::build_program());
|
||||
assert_eq!(std::fs::read(root.join("manifest.json")).unwrap(), pbxgen_stress::manifest_json());
|
||||
assert_eq!(
|
||||
std::fs::read(root.join("assets.pa")).unwrap(),
|
||||
pbxgen_stress::build_assets_pack().unwrap()
|
||||
);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn guest_preloads_music_and_renders_audio() {
|
||||
let cartridge = Cartridge::new();
|
||||
let mut host = cartridge.boot();
|
||||
let mut output = [0.0; 9600];
|
||||
host.render_audio(&mut output);
|
||||
assert!(output.iter().any(|x| x.abs() > 0.001));
|
||||
assert!(host.audio_diagnostics().maximum_voices > 0);
|
||||
assert_eq!(host.audio_diagnostics().frames, 4800);
|
||||
}
|
||||
|
||||
fn render_sequence(
|
||||
mut host: HeadlessHost,
|
||||
frames: usize,
|
||||
graphics_and_pause: bool,
|
||||
) -> (Vec<f32>, prometeu_drivers::engine::AudioDiagnostics, usize) {
|
||||
let mut output = vec![0.0; frames * 2];
|
||||
let mut graphics_frames = 0;
|
||||
for (index, buffer) in output.chunks_mut(1600).enumerate() {
|
||||
if graphics_and_pause {
|
||||
// Exercise the heavy workload at bounded checkpoints across both loops.
|
||||
// This is a sequencing regression test, not a 60 FPS performance run.
|
||||
if index < 6 || index % 120 == 0 || [60, 1543, 3086].contains(&index) {
|
||||
assert!(matches!(
|
||||
host.advance_frame().unwrap(),
|
||||
AdvanceFrameOutcome::FrameCompleted { .. }
|
||||
));
|
||||
graphics_frames += 1;
|
||||
host.resume().unwrap();
|
||||
}
|
||||
if index == 60 {
|
||||
let before = host.audio_diagnostics().frames;
|
||||
host.pause().unwrap();
|
||||
let mut silence = [1.0; 2048];
|
||||
host.render_audio(&mut silence);
|
||||
assert_eq!(silence, [0.0; 2048]);
|
||||
assert_eq!(host.audio_diagnostics().frames, before);
|
||||
host.resume().unwrap();
|
||||
}
|
||||
}
|
||||
host.render_audio(buffer);
|
||||
}
|
||||
let diagnostics = host.audio_diagnostics();
|
||||
assert_eq!(diagnostics.frames, frames as u64);
|
||||
(output, diagnostics, graphics_frames)
|
||||
}
|
||||
|
||||
fn write_wav(path: &std::path::Path, pcm: &[f32]) {
|
||||
use std::io::Write;
|
||||
let mut file = std::fs::File::create(path).unwrap();
|
||||
let byte_count = u32::try_from(pcm.len() * 2).unwrap();
|
||||
file.write_all(b"RIFF").unwrap();
|
||||
file.write_all(&(36 + byte_count).to_le_bytes()).unwrap();
|
||||
file.write_all(b"WAVEfmt \x10\0\0\0\x01\0\x02\0").unwrap();
|
||||
file.write_all(&48_000_u32.to_le_bytes()).unwrap();
|
||||
file.write_all(&192_000_u32.to_le_bytes()).unwrap();
|
||||
file.write_all(&4_u16.to_le_bytes()).unwrap();
|
||||
file.write_all(&16_u16.to_le_bytes()).unwrap();
|
||||
file.write_all(b"data").unwrap();
|
||||
file.write_all(&byte_count.to_le_bytes()).unwrap();
|
||||
let mut bytes = Vec::with_capacity(pcm.len() * 2);
|
||||
for value in pcm {
|
||||
bytes.extend_from_slice(&((value.clamp(-1.0, 1.0) * 32767.0).round() as i16).to_le_bytes());
|
||||
}
|
||||
file.write_all(&bytes).unwrap();
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn full_sequence_loops_and_frame_controls_preserve_audio() {
|
||||
let cartridge = Cartridge::new();
|
||||
let one_loop_numerator = 48_000_u64 * 72 * 357_143;
|
||||
let first_loop = one_loop_numerator.div_ceil(1_000_000) as usize;
|
||||
let frames = (one_loop_numerator * 2).div_ceil(1_000_000) as usize + 48_000;
|
||||
let (reference, diagnostics, _) = render_sequence(cartridge.boot(), frames, false);
|
||||
let (with_frames, _, graphics_frames) = render_sequence(cartridge.boot(), frames, true);
|
||||
assert!(graphics_frames >= 30);
|
||||
assert_eq!(
|
||||
reference, with_frames,
|
||||
"graphics and explicit pause/resume must not change a single PCM sample"
|
||||
);
|
||||
assert!((6..=12).contains(&diagnostics.maximum_voices));
|
||||
let peak = reference.iter().map(|x| x.abs()).fold(0.0_f32, f32::max);
|
||||
let energy: f64 = reference.iter().map(|x| f64::from(*x).powi(2)).sum();
|
||||
let rms = (energy / reference.len() as f64).sqrt();
|
||||
let clipped = reference.iter().filter(|x| x.abs() >= 1.0).count();
|
||||
let stereo_difference: f64 =
|
||||
reference.as_chunks::<2>().0.iter().map(|lr| f64::from(lr[0] - lr[1]).powi(2)).sum();
|
||||
// Loop onset should reproduce the opening. A subframe remainder and the shared
|
||||
// echo tail may differ, so compare relative signal energy rather than bit identity.
|
||||
let mut loop_error = 0.0;
|
||||
let mut opening_energy = 0.0;
|
||||
for i in 400..4000 {
|
||||
loop_error += f64::from(reference[i] - reference[first_loop * 2 + i]).powi(2);
|
||||
opening_energy += f64::from(reference[i]).powi(2);
|
||||
}
|
||||
let loop_error_ratio = loop_error / opening_energy;
|
||||
let report = serde_json::json!({
|
||||
"sample_rate": 48000, "channels": 2, "audio_frames": frames,
|
||||
"seconds": frames as f64 / 48000.0, "first_loop_frame": first_loop,
|
||||
"maximum_voices": diagnostics.maximum_voices, "peak": peak,
|
||||
"rms": rms, "clipped_samples": clipped,
|
||||
"loop_onset_relative_error": loop_error_ratio,
|
||||
"graphics_pause_pcm_identical": true,
|
||||
"interleaved_graphics_frames": graphics_frames,
|
||||
});
|
||||
println!("stress_music={report}");
|
||||
if let Some(path) = std::env::var_os("PROMETEU_STRESS_WAV") {
|
||||
write_wav(std::path::Path::new(&path), &reference);
|
||||
}
|
||||
assert!(reference.iter().all(|x| x.is_finite()));
|
||||
assert!(rms > 0.005 && stereo_difference > 0.01);
|
||||
assert_eq!(clipped, 0, "adjust arrangement gain rather than delivering clipped audio");
|
||||
assert!(
|
||||
loop_error_ratio < 0.04,
|
||||
"loop did not reproduce the musical opening: {loop_error_ratio}"
|
||||
);
|
||||
}
|
||||
@@ -0,0 +1,127 @@
|
||||
#![allow(dead_code)]
|
||||
use prometeu_bytecode::{load_limits::LoadBudget, Value};
|
||||
use prometeu_drivers::SpriteController;
|
||||
use prometeu_hal::{
|
||||
glyph::Glyph,
|
||||
sprite::Sprite,
|
||||
syscalls::{caps, Syscall},
|
||||
ComposerOpStatus, HostContext, HostReturn, NativeInterface,
|
||||
};
|
||||
use prometeu_vm::{LogicalFrameEndingReason as End, ValidatedProgramImage, VirtualMachine};
|
||||
|
||||
#[derive(Default)]
|
||||
pub struct Workload {
|
||||
pub sprites: SpriteController,
|
||||
pub submitted: usize,
|
||||
pub binds: usize,
|
||||
pub camera: usize,
|
||||
pub text: usize,
|
||||
pub logs: usize,
|
||||
pub plays: usize,
|
||||
pub errors: usize,
|
||||
pub reject_first_sprite: bool,
|
||||
pub sprite_hash: u64,
|
||||
}
|
||||
impl NativeInterface for Workload {
|
||||
fn syscall(
|
||||
&mut self,
|
||||
id: u32,
|
||||
args: &[Value],
|
||||
out: &mut HostReturn,
|
||||
_: &mut HostContext,
|
||||
) -> Result<(), prometeu_hal::vm_fault::VmFault> {
|
||||
let op = Syscall::from_u32(id).unwrap();
|
||||
let int = |i: usize| match args[i] {
|
||||
Value::Int32(x) => i64::from(x),
|
||||
Value::Int64(x) => x,
|
||||
_ => panic!("integer argument {i}"),
|
||||
};
|
||||
let boolean = |i: usize| match args[i] {
|
||||
Value::Boolean(b) => b,
|
||||
_ => panic!("bool argument {i}"),
|
||||
};
|
||||
let mut status = ComposerOpStatus::Ok as i64;
|
||||
match op {
|
||||
Syscall::ComposerBindScene => self.binds += 1,
|
||||
Syscall::ComposerSetCamera => self.camera += 1,
|
||||
Syscall::GfxDrawText => self.text += 1,
|
||||
Syscall::GfxFillRect => {}
|
||||
Syscall::LogWrite => {
|
||||
self.logs += 1;
|
||||
if int(0) == 3 {
|
||||
self.errors += 1;
|
||||
}
|
||||
}
|
||||
Syscall::MusicPlay => self.plays += 1,
|
||||
Syscall::MusicSetVolume | Syscall::AudioSetEffect => {}
|
||||
Syscall::ComposerEmitSprite => {
|
||||
self.submitted += 1;
|
||||
for i in 0..6 {
|
||||
self.sprite_hash =
|
||||
(self.sprite_hash ^ int(i) as u64).wrapping_mul(1099511628211);
|
||||
}
|
||||
let sprite = Sprite {
|
||||
glyph: Glyph { glyph_id: int(0) as u16, palette_id: int(1) as u8 },
|
||||
x: int(2) as i32,
|
||||
y: int(3) as i32,
|
||||
layer: int(4) as u8,
|
||||
bank_id: int(5) as u8,
|
||||
active: false,
|
||||
flip_x: boolean(6),
|
||||
flip_y: boolean(7),
|
||||
priority: int(8) as u8,
|
||||
};
|
||||
if !self.sprites.emit_sprite(sprite)
|
||||
|| (self.reject_first_sprite && self.submitted == 1)
|
||||
{
|
||||
status = ComposerOpStatus::SpriteOverflow as i64;
|
||||
}
|
||||
}
|
||||
_ => panic!("unexpected {op:?}"),
|
||||
}
|
||||
for _ in 0..op.results_count() {
|
||||
out.push_int(status);
|
||||
}
|
||||
Ok(())
|
||||
}
|
||||
}
|
||||
pub fn vm(preset: pbxgen_stress::Preset, seed: i64) -> VirtualMachine {
|
||||
let bytes = pbxgen_stress::build_program_with(preset, seed);
|
||||
let image =
|
||||
ValidatedProgramImage::load(&bytes, &mut LoadBudget::new(Default::default()), caps::ALL)
|
||||
.unwrap();
|
||||
VirtualMachine::from_image(image, Default::default())
|
||||
}
|
||||
pub fn frame(vm: &mut VirtualMachine, native: &mut Workload) -> u64 {
|
||||
native.sprites.begin_frame();
|
||||
vm.prepare_boot_call().unwrap();
|
||||
let mut cycles = 0;
|
||||
for _ in 0..100 {
|
||||
let r = vm.run_budget(250_000, native, &mut HostContext::new(None)).unwrap();
|
||||
cycles += r.cycles_used;
|
||||
match r.reason {
|
||||
End::EndOfRom => return cycles,
|
||||
End::BudgetExhausted => {}
|
||||
reason => panic!("{reason:?}"),
|
||||
}
|
||||
}
|
||||
panic!("unbounded frame")
|
||||
}
|
||||
pub fn particle_bits(vm: &VirtualMachine) -> Vec<u64> {
|
||||
use prometeu_vm::resource_diagnostics::StorageValue;
|
||||
vm.heap()
|
||||
.diagnostic_typed_storage()
|
||||
.iter()
|
||||
.filter(|o| o.type_id.0 == 4)
|
||||
.flat_map(|o| o.groups.iter())
|
||||
.flat_map(|g| g.iter())
|
||||
.map(|v| match v {
|
||||
StorageValue::FloatBits(x) => *x,
|
||||
StorageValue::Int32(x) => *x as u64,
|
||||
_ => panic!("particle type"),
|
||||
})
|
||||
.collect()
|
||||
}
|
||||
pub fn hash(values: &[u64]) -> u64 {
|
||||
values.iter().fold(14695981039346656037, |h, x| (h ^ x).wrapping_mul(1099511628211))
|
||||
}
|
||||
@@ -0,0 +1,198 @@
|
||||
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"
|
||||
);
|
||||
}
|
||||
}
|
||||
}
|
||||
Reference in New Issue
Block a user