Files
prometeu-runtime/crates/tools/pbxgen-stress/tests/support/mod.rs
T
bquarkz c2bf8d055c 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.
2026-11-20 22:15:47 +00:00

128 lines
4.3 KiB
Rust

#![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))
}