//! Repeatable CPU/memory observations, not a handheld or physical-device guarantee. use prometeu_drivers::{ Audio, MemoryBanks, SoundBankPoolInstaller, bank_format::{decode_audio_bank, encode_ima_wav4}, engine::{AudioMixer, Packet}, }; use prometeu_hal::{ AudioBridge, LoopMode, audio_bridge::AudioControl, music_bank::{Instrument, MusicBank, MusicEvent}, sample::Sample, sound_bank::SoundBank, }; use serde_json::{Value, json}; use std::{ alloc::{GlobalAlloc, Layout, System}, sync::{ Arc, atomic::{AtomicUsize, Ordering}, }, time::Instant, }; struct Counter; static LIVE: AtomicUsize = AtomicUsize::new(0); static PEAK: AtomicUsize = AtomicUsize::new(0); unsafe impl GlobalAlloc for Counter { unsafe fn alloc(&self, l: Layout) -> *mut u8 { let p = unsafe { System.alloc(l) }; if !p.is_null() { let n = LIVE.fetch_add(l.size(), Ordering::Relaxed) + l.size(); PEAK.fetch_max(n, Ordering::Relaxed); } p } unsafe fn dealloc(&self, p: *mut u8, l: Layout) { LIVE.fetch_sub(l.size(), Ordering::Relaxed); unsafe { System.dealloc(p, l) } } } #[global_allocator] static ALLOCATOR: Counter = Counter; fn stats(values: &mut [u64]) -> Value { values.sort_unstable(); let n = values.len(); json!({"p50_ns":values[n/2],"p95_ns":values[n*95/100],"p99_ns":values[n*99/100],"max_ns":values[n-1]}) } fn music(channels: u8) -> Arc { let pcm = (0..4096) .flat_map(|i| { std::iter::repeat_n(((i as f64 * 0.05).sin() * 800.0) as i16, channels as usize) }) .collect(); let sample = Arc::new(Sample::new(48000, pcm).with_channels(channels).unwrap().with_loop(0, 4096)); let events = (0..12) .map(|id| MusicEvent { kind: 1, a: id, c: 60 + id as i32, d: 180, ..Default::default() }) .collect(); Arc::new( MusicBank::compile( "measure".into(), vec![sample], vec![Instrument { looping: true, attack_us: 1000, decay_us: 10_000, sustain: 50000, release_us: 10_000, send: 20000, vibrato_cents: 10, vibrato_millihz: 5000, tremolo_depth: 1000, tremolo_millihz: 3000, ..Default::default() }], events, 960, 500000, 3840, None, 1, ) .unwrap(), ) } fn scenario(channels: u8, dsp: bool, replacement: bool) -> Value { let banks = Arc::new(MemoryBanks::new()); let mut audio = Audio::new(banks.clone()); banks.install_music_bank(0, music(channels)); banks.install_music_bank(1, music(channels)); audio.music_play(0, 0, true); audio.music_play(1, 1, true); let sample = Arc::new( Sample::new(48000, vec![500; 4096 * channels as usize]) .with_channels(channels) .unwrap() .with_loop(0, 4096), ); for voice in 0..8 { audio.play_sample(sample.clone(), voice, 255, 128, 1.0, 0, LoopMode::On); audio.control(AudioControl::SfxSend { voice, gain: 100 }); } if dsp { for group in 0..3 { audio.control(AudioControl::Effect { group, cutoff_hz: 6000, delay_frames: 4800, feedback: 0.5, wet: 0.3, dry: 0.7, }); } } audio.finish_frame(); let mut mixer = AudioMixer::new(); let mut packet = Packet::new(); mixer.apply_delivery_into(audio.transport().try_take().unwrap(), &mut packet); packet.recycle(&audio.transport()); let mut pcm = [0.0; 512]; let mut timings = Vec::with_capacity(1000); let mut overruns = 0; let mut max_retired = 0; let baseline = LIVE.load(Ordering::Relaxed); PEAK.store(baseline, Ordering::Relaxed); for iteration in 0..1000 { if replacement && iteration % 10 == 0 { banks.install_music_bank(0, music(channels)); audio.music_play(0, 0, true); audio.control(AudioControl::MusicFade { group: 1, gain: 180, frames: 2400, smooth: true, }); audio.finish_frame(); } let start = Instant::now(); mixer.retire_inactive(&mut packet); if let Some(delivery) = audio.transport().try_take() { mixer.apply_delivery_into(delivery, &mut packet); } mixer.mix(&mut pcm); mixer.retire_inactive(&mut packet); let elapsed = start.elapsed().as_nanos() as u64; if elapsed > 5_333_333 { overruns += 1; } timings.push(elapsed); max_retired = max_retired.max(packet.retained_pcm_bytes()); packet.recycle(&audio.transport()); std::hint::black_box(&pcm); } json!({"channels_per_voice":channels,"dsp":dsp,"replacement_every_10_buffers":replacement,"buffers":1000,"frames_per_buffer":256,"nominal_buffer_ns":5_333_333,"observed_budget_overruns":overruns,"timing":stats(&mut timings),"maximum_active_voices":mixer.diagnostics.maximum_voices,"engine_prepared_bytes":mixer.prepared_bytes(),"maximum_retired_pcm_bytes":max_retired,"baseline_allocated_bytes":baseline,"peak_allocated_bytes":PEAK.load(Ordering::Relaxed)}) } fn codec_and_memory() -> Value { let pcm: Vec = (0..480_000) .flat_map(|i| { [((i as f64 * 0.04).sin() * 12000.0) as i16, ((i as f64 * 0.06).cos() * 9000.0) as i16] }) .collect(); let start = Instant::now(); let compressed = encode_ima_wav4(&pcm, 2, 512).unwrap(); let encode_ns = start.elapsed().as_nanos(); let mut bytes = vec![0u8; 88]; bytes[..4].copy_from_slice(b"SBNK"); bytes[4] = 1; bytes[48] = 1; bytes[49] = 2; bytes[80] = 255; bytes[81] = 128; for (at, n) in [ (8, 1u32), (20, 960), (24, 500000), (32, u32::MAX), (52, 48000), (56, 480000), (68, 88), (72, compressed.len() as u32), (84, 65536), ] { bytes[at..at + 4].copy_from_slice(&n.to_le_bytes()); } bytes[76..78].copy_from_slice(&512u16.to_le_bytes()); bytes[78..80].copy_from_slice(&505u16.to_le_bytes()); bytes.extend(&compressed); let mut decode = Vec::with_capacity(20); let baseline = LIVE.load(Ordering::Relaxed); PEAK.store(baseline, Ordering::Relaxed); for _ in 0..20 { let start = Instant::now(); let bank = decode_audio_bank(&bytes, false).unwrap(); decode.push(start.elapsed().as_nanos() as u64); std::hint::black_box(bank); } let decode_peak = PEAK.load(Ordering::Relaxed); let banks = MemoryBanks::new(); for slot in 0..16 { banks.install_sound_bank( slot, Arc::new(SoundBank::new(vec![Arc::new(Sample::new(48000, vec![0; 1_048_576]))])), ); } let large_music = || { let sample = Arc::new(Sample::new(48000, vec![0; 1_048_576]).with_loop(0, 1_048_576)); Arc::new( MusicBank::compile( "large".into(), vec![sample], vec![Instrument { looping: true, ..Default::default() }], vec![MusicEvent { kind: 1, a: 1, c: 60, d: 255, ..Default::default() }], 960, 500000, 3840, None, 1, ) .unwrap(), ) }; for slot in 0..16 { banks.install_music_bank(slot, large_music()); } let snapshot = banks.audio_memory(); let mut mixer = AudioMixer::new(); let mut packet = Packet::new(); use prometeu_drivers::SoundBankPoolAccess; mixer.apply_delivery_into( prometeu_drivers::AudioDelivery { epoch: 0, paused: false, frame: Some(vec![prometeu_drivers::AudioCommand::MusicPlay { group: 0, bank: banks.music_bank_slot(0).unwrap(), looping: true, }]), lifecycle: None, }, &mut packet, ); packet.recycle(&prometeu_drivers::AudioTransport::default()); mixer.mix(&mut [0.0; 2]); let before = LIVE.load(Ordering::Relaxed); PEAK.store(before, Ordering::Relaxed); banks.install_music_bank(0, large_music()); mixer.retire_inactive(&mut packet); let retired = packet.retained_pcm_bytes(); let replacement_peak = PEAK.load(Ordering::Relaxed); packet.recycle(&prometeu_drivers::AudioTransport::default()); let after = LIVE.load(Ordering::Relaxed); json!({"source_frames":480000,"channels":2,"pcm_bytes":pcm.len()*2,"cartridge_sample_bytes":compressed.len(),"compression_ratio":compressed.len()as f64/(pcm.len()*2)as f64,"encode_ns":encode_ns,"decode_timing":stats(&mut decode),"decode_baseline_allocated_bytes":baseline,"decode_peak_allocated_bytes":decode_peak,"large_bank_count":snapshot.banks.len(),"large_banks_unique_pcm_bytes":snapshot.unique_pcm_bytes,"replacement_baseline_allocated_bytes":before,"replacement_peak_allocated_bytes":replacement_peak,"replacement_after_reclamation_bytes":after,"retained_replaced_pcm_bytes":retired,"resident_accounted_metadata_bytes":snapshot.metadata_bytes,"resident_total_accounted_bytes":snapshot.total_accounted_bytes}) } fn main() { println!("{}",serde_json::to_string_pretty(&json!({"arch":std::env::consts::ARCH,"os":std::env::consts::OS,"observations":[scenario(1,false,false),scenario(2,false,false),scenario(2,true,false),scenario(2,true,true)],"codecs_and_memory":codec_and_memory()})).unwrap()); }