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.
102 lines
6.0 KiB
Rust
102 lines
6.0 KiB
Rust
//! Reproducible fixture measurement; times include diagnostics and do not qualify a handheld.
|
|
#[path = "../tests/support/mod.rs"]
|
|
mod support;
|
|
use pbxgen_stress::{Preset, DEFAULT_SEED};
|
|
use prometeu_host_headless::{AdvanceFrameOutcome, HeadlessHost};
|
|
use std::{
|
|
io::Write,
|
|
path::{Path, PathBuf},
|
|
time::Instant,
|
|
};
|
|
fn distribution(mut ms: Vec<f64>) -> serde_json::Value {
|
|
ms.sort_by(f64::total_cmp);
|
|
let n = ms.len();
|
|
serde_json::json!({"count":n,"mean_ms":ms.iter().sum::<f64>()/n as f64,"p50_ms":ms[(n*50).div_ceil(100)-1],"p95_ms":ms[(n*95).div_ceil(100)-1],"max_ms":ms[n-1]})
|
|
}
|
|
fn ppm(path: &Path, pixels: &[u32]) {
|
|
let mut f = std::io::BufWriter::new(std::fs::File::create(path).unwrap());
|
|
write!(f, "P6\n640 360\n255\n").unwrap();
|
|
for &p in pixels {
|
|
let (r, g, b, _) = prometeu_hal::color::Color::unpack_to_native(p);
|
|
f.write_all(&[r, g, b]).unwrap();
|
|
}
|
|
}
|
|
fn main() {
|
|
let frames: usize = std::env::args().nth(1).unwrap_or("120".into()).parse().expect("frames");
|
|
assert!((1..=10000).contains(&frames));
|
|
let output =
|
|
PathBuf::from(std::env::args().nth(2).unwrap_or("/tmp/prometeu-demo-measure".into()));
|
|
std::fs::create_dir_all(&output).unwrap();
|
|
let mut reports = vec![];
|
|
for preset in [Preset::Light, Preset::Normal, Preset::Heavy] {
|
|
let started = Instant::now();
|
|
let mut vm = support::vm(preset, DEFAULT_SEED);
|
|
let vm_load_ms = started.elapsed().as_secs_f64() * 1000.0;
|
|
let mut native = support::Workload::default();
|
|
let started = Instant::now();
|
|
let init_cycles = support::frame(&mut vm, &mut native);
|
|
let init_vm_ms = started.elapsed().as_secs_f64() * 1000.0;
|
|
let mut vm_times = Vec::new();
|
|
let mut cycles = 0;
|
|
for _ in 0..frames {
|
|
let started = Instant::now();
|
|
cycles += support::frame(&mut vm, &mut native);
|
|
vm_times.push(started.elapsed().as_secs_f64() * 1000.0);
|
|
}
|
|
let resources = vm.resource_snapshot();
|
|
let state_hash = support::hash(&support::particle_bits(&vm));
|
|
let cart = output.join(format!("{}-cartridge", preset.name()));
|
|
pbxgen_stress::generate_with(preset, DEFAULT_SEED, Some(cart.clone())).unwrap();
|
|
let mut host = HeadlessHost::new();
|
|
let started = Instant::now();
|
|
host.boot(cart.to_string_lossy()).unwrap();
|
|
let boot_ms = started.elapsed().as_secs_f64() * 1000.0;
|
|
let started = Instant::now();
|
|
assert!(matches!(
|
|
host.advance_frame().unwrap(),
|
|
AdvanceFrameOutcome::FrameCompleted { .. }
|
|
));
|
|
let host_first_frame_ms = started.elapsed().as_secs_f64() * 1000.0;
|
|
host.resume().unwrap();
|
|
let mut pcm = [0.0; 1600];
|
|
host.render_audio(&mut pcm);
|
|
let mut host_times = vec![];
|
|
let mut audio_times = vec![];
|
|
let mut previous_tick = host.get_state().tick_index;
|
|
let mut slices = vec![];
|
|
for _ in 0..frames {
|
|
let started = Instant::now();
|
|
assert!(matches!(
|
|
host.advance_frame().unwrap(),
|
|
AdvanceFrameOutcome::FrameCompleted { .. }
|
|
));
|
|
host.resume().unwrap();
|
|
let audio_started = Instant::now();
|
|
host.render_audio(&mut pcm);
|
|
audio_times.push(audio_started.elapsed().as_secs_f64() * 1000.0);
|
|
host_times.push(started.elapsed().as_secs_f64() * 1000.0);
|
|
let tick = host.get_state().tick_index;
|
|
slices.push(tick - previous_tick);
|
|
previous_tick = tick;
|
|
}
|
|
let capture = host.capture_frame().unwrap();
|
|
let file = output.join(format!("{}.ppm", preset.name()));
|
|
ppm(&file, &capture.frame.pixels);
|
|
let audio = host.audio_diagnostics();
|
|
reports.push(serde_json::json!({"preset":preset.name(),"particles":preset.particles(),"substeps":preset.substeps(),"steady_frames":frames,"seed":DEFAULT_SEED,
|
|
"vm_load_ms":vm_load_ms,"vm_first_frame_ms":init_vm_ms,"host_boot_ms":boot_ms,"host_first_frame_ms":host_first_frame_ms,
|
|
"vm_only_with_bounded_native":distribution(vm_times),"headless_graphics_and_800_audio_frames":distribution(host_times),"audio_800_frames_only":distribution(audio_times),
|
|
"mean_host_ticks_per_logical_frame":slices.iter().sum::<u64>() as f64 / frames as f64,"max_host_ticks_per_logical_frame":slices.iter().max(),
|
|
"first_virtual_cycles":init_cycles,"mean_steady_virtual_cycles":cycles as f64/frames as f64,
|
|
"sprites_submitted_per_frame":preset.particles()+128,"sprites_accepted_last_frame":native.sprites.sprite_count(),"sprite_overflow":native.sprites.dropped_sprites(),"guest_composer_errors":native.errors,
|
|
"live_guest_objects":resources.live_objects,"vm_budget_used":resources.budget.used,"vm_budget_peaks":resources.budget.peaks,"vm_budget_limits":resources.budget.limits,
|
|
"state_hash":format!("{state_hash:016x}"),"music_play_commands":native.plays,"observed_maximum_voices":audio.maximum_voices,"audio_frames":audio.frames,
|
|
"capture":file,"frame_hash":format!("{:016x}",support::hash(&capture.frame.pixels.iter().map(|&p|u64::from(p)).collect::<Vec<_>>()))}));
|
|
}
|
|
let report = serde_json::json!({"profile":if cfg!(debug_assertions){"debug"}else{"release"},"arch":std::env::consts::ARCH,"os":std::env::consts::OS,"resource_diagnostics":true,"particle_travel_scale":pbxgen_stress::PARTICLE_TRAVEL_SCALE,
|
|
"notes":["Native-only timing uses real VM and SpriteController, with other host calls counted.","Headless timing includes real software composition and 800 stereo audio frames per logical frame.","No physical callback, VSync, GPU presentation, power or handheld measurement.","VM quota arrays are ordered by RuntimeResource; they are not process RSS."],"presets":reports});
|
|
std::fs::write(output.join("report.json"), serde_json::to_vec_pretty(&report).unwrap())
|
|
.unwrap();
|
|
println!("{}", serde_json::to_string_pretty(&report).unwrap());
|
|
}
|