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