use prometeu_drivers::{Audio, MemoryBanks}; use prometeu_hal::{AudioBridge, LoopMode, sample::Sample}; use prometeu_host_desktop_winit::audio::AudioCallback; use std::alloc::{GlobalAlloc, Layout, System}; use std::cell::Cell; use std::sync::Arc; thread_local! { static COUNTS: Cell> = const { Cell::new(None) }; } struct Counter; fn count(alloc: usize, free: usize) { let _ = COUNTS.try_with(|c| { if let Some((a, d)) = c.get() { c.set(Some((a + alloc, d + free))); } }); } unsafe impl GlobalAlloc for Counter { unsafe fn alloc(&self, l: Layout) -> *mut u8 { count(1, 0); unsafe { System.alloc(l) } } unsafe fn alloc_zeroed(&self, l: Layout) -> *mut u8 { count(1, 0); unsafe { System.alloc_zeroed(l) } } unsafe fn dealloc(&self, p: *mut u8, l: Layout) { count(0, 1); unsafe { System.dealloc(p, l) } } unsafe fn realloc(&self, p: *mut u8, l: Layout, n: usize) -> *mut u8 { count(1, 1); unsafe { System.realloc(p, l, n) } } } #[global_allocator] static ALLOCATOR: Counter = Counter; fn measured(f: impl FnOnce()) -> (usize, usize) { COUNTS.with(|c| c.set(Some((0, 0)))); f(); COUNTS.with(|c| c.replace(None).unwrap()) } fn play(audio: &mut Audio, voice: usize, looping: bool) -> std::sync::Weak { let sample = Arc::new(Sample::new(48000, vec![1000; 4])); let weak = Arc::downgrade(&sample); assert_eq!( audio.play_sample( sample, voice, 255, 0, 1.0, 0, if looping { LoopMode::On } else { LoopMode::Off } ), prometeu_hal::AudioOpStatus::Ok ); weak } fn render(callback: &mut AudioCallback, audio: &Audio, pcm: &mut [f32], label: &str) { let counts = measured(|| callback.render(&audio.transport(), pcm)); println!("{label}: {counts:?}"); assert_eq!(counts, (0, 0), "{label}"); } #[test] fn callback_owners_do_not_use_allocator() { let mut audio = Audio::new(Arc::new(MemoryBanks::new())); let (mut callback, mut reclaimer) = AudioCallback::new(); let mut pcm = [0.0; 32]; let weak = play(&mut audio, 0, false); audio.finish_frame(); render(&mut callback, &audio, &mut pcm, "natural_completion_and_batch"); assert!(weak.upgrade().is_some(), "owner must await service"); reclaimer.service(&audio.transport()); assert!(weak.upgrade().is_none()); for _ in 0..8 { play(&mut audio, 0, true); audio.stop(0); let replacement = play(&mut audio, 0, true); audio.finish_frame(); render(&mut callback, &audio, &mut pcm, "replacement_stop_fifo"); assert!(pcm.iter().step_by(2).all(|&v| v == 1000.0 / 32768.0)); reclaimer.service(&audio.transport()); audio.set_paused(true); render(&mut callback, &audio, &mut pcm, "pause"); assert!(pcm.iter().all(|&v| v == 0.0)); reclaimer.service(&audio.transport()); audio.reset(); render(&mut callback, &audio, &mut pcm, "epoch_reset"); assert!(replacement.upgrade().is_some()); reclaimer.service(&audio.transport()); assert!(replacement.upgrade().is_none()); } audio.stop(0); audio.finish_frame(); render(&mut callback, &audio, &mut pcm, "control_batch"); } #[test] fn stalled_service_bounds_retention_and_recovers_pending_delivery() { let mut audio = Audio::new(Arc::new(MemoryBanks::new())); let (mut callback, mut reclaimer) = AudioCallback::new(); let owners: Vec<_> = (0..8).map(|voice| play(&mut audio, voice, false)).collect(); audio.finish_frame(); // Keep all voices playing until both packets have been returned. render(&mut callback, &audio, &mut [], "start_16"); render(&mut callback, &audio, &mut [], "exhaust_pool"); let mut pcm = [0.0; 32]; render(&mut callback, &audio, &mut pcm, "finish_16_without_packet"); assert!(owners.iter().all(|owner| owner.upgrade().is_some())); let next = play(&mut audio, 0, true); audio.finish_frame(); for _ in 0..10 { render(&mut callback, &audio, &mut pcm, "starved_silent_pending"); assert!(!audio.ready()); assert!(pcm.iter().all(|&v| v == 0.0)); } reclaimer.service(&audio.transport()); render(&mut callback, &audio, &mut pcm, "recover"); assert!(audio.ready()); reclaimer.service(&audio.transport()); assert!(owners.iter().all(|owner| owner.upgrade().is_none())); assert!(next.upgrade().is_some()); drop(callback); // Teardown belongs to the service/main thread. drop(reclaimer); assert!(next.upgrade().is_none()); } #[test] fn full_frame_and_combined_lifecycle_fit_one_packet() { let mut audio = Audio::new(Arc::new(MemoryBanks::new())); let (mut callback, mut reclaimer) = AudioCallback::new(); let mut owners = Vec::new(); for voice in 0..8 { owners.push(play(&mut audio, voice, false)); } audio.finish_frame(); render(&mut callback, &audio, &mut [], "initial_16"); reclaimer.service(&audio.transport()); // The published frame, interrupted next-frame prefix and lifecycle each // admit 1024 commands. Every command replaces an owner on the same voice. for _ in 0..1024 { owners.push(play(&mut audio, 0, false)); } audio.finish_frame(); for _ in 0..1024 { owners.push(play(&mut audio, 0, false)); } audio.begin_lifecycle(); for _ in 0..1024 { owners.push(play(&mut audio, 0, false)); } audio.finish_lifecycle(true); let mut pcm = [0.0; 32]; render(&mut callback, &audio, &mut pcm, "3072_commands_plus_completion"); reclaimer.service(&audio.transport()); assert!(owners.iter().skip(8).all(|owner| owner.upgrade().is_none())); audio.reset(); render(&mut callback, &audio, &mut pcm, "reset_remaining_voices"); reclaimer.service(&audio.transport()); assert!(owners.iter().all(|owner| owner.upgrade().is_none())); } /// Physical observations, deliberately excluded from ordinary CI. The pressure /// fixture reads the checked-in asset pack and writes a temporary host save; /// it does not certify asset decoding or guest memcard scheduling. #[test] #[ignore = "requires physical audio output; 8 quiet voices and temporary file I/O"] fn physical_callback_duration_8_sfx_voices_with_io_pressure() { use cpal::traits::{DeviceTrait, HostTrait, StreamTrait}; use prometeu_host_desktop_winit::fs_backend::HostDirBackend; use prometeu_system::fs::FsBackend; use ringbuf::{ HeapRb, traits::{Consumer, Producer, Split}, }; use std::sync::atomic::{AtomicBool, AtomicUsize, Ordering}; use std::time::{Duration, Instant}; let device = cpal::default_host().default_output_device().expect("physical output"); let device_name = device.name().unwrap(); let mut audio = Audio::new(Arc::new(MemoryBanks::new())); let (mut callback, mut reclaimer) = AudioCallback::new(); let mut owners = vec![]; for voice in 0..8 { let sample = Arc::new(Sample::new(48000, vec![32; 4800])); owners.push(Arc::downgrade(&sample)); audio.play_sample(sample, voice, 8, 127, 1.0, 0, LoopMode::On); } audio.finish_frame(); let config = cpal::StreamConfig { channels: 2, sample_rate: cpal::SampleRate(48000), buffer_size: cpal::BufferSize::Fixed(256), }; let transport = audio.transport(); let (mut timings, mut observations) = HeapRb::<(u64, usize)>::new(4096).split(); let allocator_calls = Arc::new(AtomicUsize::new(0)); let failed = Arc::new(AtomicBool::new(false)); let counter = allocator_calls.clone(); let error = failed.clone(); let stream = device .build_output_stream( &config, move |data: &mut [f32], _: &cpal::OutputCallbackInfo| { let start = Instant::now(); let (alloc, free) = measured(|| callback.render(&transport, data)); counter.fetch_add(alloc + free, Ordering::Relaxed); let _ = timings.try_push((start.elapsed().as_nanos() as u64, data.len() / 2)); }, move |_| { error.store(true, Ordering::Relaxed); }, None, ) .unwrap(); let root = std::env::temp_dir().join(format!("prometeu-audio-qualification-{}", std::process::id())); std::fs::create_dir_all(&root).unwrap(); let mut filesystem = HostDirBackend::new(root.clone()); let asset = std::path::Path::new(env!("CARGO_MANIFEST_DIR")) .join("../../../test-cartridges/stress-console/assets.pa"); let save = vec![0x5a; 1024 * 1024]; stream.play().unwrap(); let deadline = Instant::now() + Duration::from_secs(2); let mut io_cycles = 0; while Instant::now() < deadline { let payload = std::fs::read(&asset).unwrap(); assert!(!payload.is_empty()); filesystem.write_file("/user/audio-pressure.bin", &save).unwrap(); reclaimer.service(&audio.transport()); io_cycles += 1; std::thread::sleep(Duration::from_millis(2)); } stream.pause().unwrap(); let live_before = owners.iter().filter(|owner| owner.upgrade().is_some()).count(); drop(stream); reclaimer.service(&audio.transport()); let live_after = owners.iter().filter(|owner| owner.upgrade().is_some()).count(); let mut samples = vec![]; let mut frames = vec![]; while let Some((time, count)) = observations.try_pop() { samples.push(time); frames.push(count); } filesystem.delete("/user/audio-pressure.bin").unwrap(); std::fs::remove_dir(root.join("user")).unwrap(); std::fs::remove_dir(root).unwrap(); samples.sort_unstable(); assert!(!samples.is_empty(), "physical stream delivered no callbacks"); println!( "device={device_name:?}, callbacks={}, io_cycles={io_cycles}, frames_min={}, frames_max={}, p50_ns={}, p95_ns={}, p99_ns={}, max_ns={}, allocator_calls={}, owners_before={live_before}, owners_after={live_after}", samples.len(), frames.iter().min().unwrap(), frames.iter().max().unwrap(), samples[samples.len() / 2], samples[samples.len() * 95 / 100], samples[samples.len() * 99 / 100], samples.last().unwrap(), allocator_calls.load(Ordering::Relaxed) ); assert!(!failed.load(Ordering::Relaxed)); assert_eq!(allocator_calls.load(Ordering::Relaxed), 0); assert_eq!((live_before, live_after), (8, 0)); } #[test] #[ignore = "release timing observation with temporary asset-read/save-write pressure"] fn callback_duration_8_sfx_voices_with_io_pressure() { use prometeu_host_desktop_winit::fs_backend::HostDirBackend; use prometeu_system::fs::FsBackend; use std::time::Instant; let mut audio = Audio::new(Arc::new(MemoryBanks::new())); let (mut callback, mut reclaimer) = AudioCallback::new(); let owners: Vec<_> = (0..8).map(|voice| play(&mut audio, voice, true)).collect(); audio.finish_frame(); let mut pcm = [0.0; 512]; // 256 stereo frames: nominal 5.333 ms at 48 kHz. callback.render(&audio.transport(), &mut pcm); reclaimer.service(&audio.transport()); let root = std::env::temp_dir().join(format!("prometeu-audio-timing-{}", std::process::id())); std::fs::create_dir_all(&root).unwrap(); let mut filesystem = HostDirBackend::new(root.clone()); let asset = std::path::Path::new(env!("CARGO_MANIFEST_DIR")) .join("../../../test-cartridges/stress-console/assets.pa"); let save = vec![0x5a; 1024 * 1024]; let mut samples = Vec::with_capacity(1000); let mut counts = (0, 0); for _ in 0..1000 { assert!(!std::fs::read(&asset).unwrap().is_empty()); filesystem.write_file("/user/audio-pressure.bin", &save).unwrap(); let start = Instant::now(); let measured = measured(|| callback.render(&audio.transport(), &mut pcm)); samples.push(start.elapsed().as_nanos()); counts.0 += measured.0; counts.1 += measured.1; reclaimer.service(&audio.transport()); } samples.sort_unstable(); let before = owners.iter().filter(|owner| owner.upgrade().is_some()).count(); drop(callback); drop(reclaimer); let after = owners.iter().filter(|owner| owner.upgrade().is_some()).count(); filesystem.delete("/user/audio-pressure.bin").unwrap(); std::fs::remove_dir(root.join("user")).unwrap(); std::fs::remove_dir(root).unwrap(); println!( "synthetic callbacks=1000, frames=256, nominal_period_ns=5333333, io_cycles=1000, p50_ns={}, p95_ns={}, p99_ns={}, max_ns={}, alloc_free={counts:?}, owners_before={before}, owners_after={after}", samples[500], samples[950], samples[990], samples[999] ); assert_eq!(counts, (0, 0)); assert_eq!((before, after), (8, 0)); } #[test] fn unloaded_banks_empty_samples_and_controls_reclaim_on_service() { use prometeu_drivers::SoundBankPoolInstaller; use prometeu_hal::sound_bank::SoundBank; let banks = Arc::new(MemoryBanks::new()); let sample = Arc::new(Sample::new(48000, vec![1000; 16])); let weak = Arc::downgrade(&sample); banks.install_sound_bank(0, Arc::new(SoundBank::new(vec![sample]))); let mut audio = Audio::new(banks.clone()); let (mut callback, mut reclaimer) = AudioCallback::new(); audio.play(0, 0, 0, 255, 0, 1.0, 0, LoopMode::On); audio.finish_frame(); banks.clear_sound_banks(); let mut pcm = [0.0; 16]; render(&mut callback, &audio, &mut pcm, "unloaded_bank"); assert!(weak.upgrade().is_some()); reclaimer.service(&audio.transport()); audio.set_volume(0, 127); audio.set_pan(0, 255); audio.set_pitch(0, 0.5); audio.stop(0); let empty = Arc::new(Sample::new(48000, vec![])); let weak_empty = Arc::downgrade(&empty); audio.play_sample(empty, 1, 255, 0, 1.0, 0, LoopMode::Off); audio.finish_frame(); render(&mut callback, &audio, &mut pcm, "controls_stop_empty"); assert!(pcm.iter().all(|&sample| sample == 0.0)); assert!(weak.upgrade().is_none() && weak_empty.upgrade().is_some()); reclaimer.service(&audio.transport()); assert!(weak.upgrade().is_none() && weak_empty.upgrade().is_none()); } fn music_fixture() -> Arc { use prometeu_hal::music_bank::{Instrument, MusicBank, MusicEvent}; let sample = Arc::new(Sample::new(48000, vec![1000, -1500]).with_channels(2).unwrap().with_loop(0, 1)); let mut events: Vec<_> = (0..12) .map(|id| MusicEvent { kind: 1, a: id, c: 60, d: 255, ..Default::default() }) .collect(); // Every frame replaces a voice while envelopes and modulation keep running. for tick in 1..500 { events.push(MusicEvent { tick, kind: 1, a: 12 + tick, c: 60 + (tick % 12) as i32, d: 180, ..Default::default() }); } Arc::new( MusicBank::compile( "rt".into(), vec![sample], vec![Instrument { looping: true, attack_us: 100, release_us: 1000, vibrato_millihz: 6000, vibrato_cents: 20, tremolo_millihz: 4000, tremolo_depth: 1000, send: 32768, ..Default::default() }], events, 960, 20_000, 1000, None, 1, ) .unwrap(), ) } #[test] fn thirty_two_stereo_voices_sequences_dsp_and_bank_retirement_never_call_allocator() { use prometeu_drivers::SoundBankPoolInstaller; use prometeu_hal::audio_bridge::AudioControl; let banks = Arc::new(MemoryBanks::new()); let mut audio = Audio::new(banks.clone()); banks.install_music_bank(0, music_fixture()); audio.music_play(0, 0, true); audio.music_play(1, 0, true); for voice in 0..8 { let sample = Arc::new(Sample::new(48000, vec![500, -500]).with_channels(2).unwrap().with_loop(0, 1)); audio.play_sample(sample, voice, 255, 128, 1.0, 0, LoopMode::On); } for group in 0..3 { audio.control(AudioControl::Effect { group, cutoff_hz: 6000, delay_frames: 48, feedback: 0.5, wet: 0.3, dry: 0.7, }); } audio.finish_frame(); let (mut callback, mut reclaimer) = AudioCallback::new(); let mut pcm = [0.0; 512]; render(&mut callback, &audio, &mut pcm, "32_stereo_sequencers_adsr_modulation_dsp"); assert_eq!(callback.diagnostics().maximum_voices, 32); reclaimer.service(&audio.transport()); for _ in 0..20 { banks.install_music_bank(0, music_fixture()); audio.music_play(0, 0, true); audio.music_play(1, 0, true); audio.control(AudioControl::Crossfade { source: 0, target: 1, frames: 48, smooth: true }); audio.finish_frame(); render(&mut callback, &audio, &mut pcm, "32_bank_replacement_and_crossfade"); reclaimer.service(&audio.transport()); } // Exhaust both packets, then invalidate banks and keep processing safely. render(&mut callback, &audio, &mut pcm, "pool_first"); render(&mut callback, &audio, &mut pcm, "pool_second"); banks.unload_audio_bank(true, 0); for _ in 0..10 { render(&mut callback, &audio, &mut pcm, "music_invalidated_without_packet"); } reclaimer.service(&audio.transport()); render(&mut callback, &audio, &mut pcm, "retire_after_starvation"); reclaimer.service(&audio.transport()); } #[test] #[ignore = "physical 48 kHz output; emits a quiet tone for two seconds"] fn physical_32_stereo_voices_with_dsp_and_bank_replacement() { use cpal::traits::{DeviceTrait, HostTrait, StreamTrait}; use prometeu_drivers::SoundBankPoolInstaller; use prometeu_hal::{ audio_bridge::AudioControl, music_bank::{Instrument, MusicBank, MusicEvent}, }; use ringbuf::{ HeapRb, traits::{Consumer, Producer, Split}, }; use std::{ sync::atomic::{AtomicUsize, Ordering}, time::{Duration, Instant}, }; let device = cpal::default_host().default_output_device().expect("physical output device"); let name = device.name().unwrap(); let sample = Arc::new( Sample::new( 48000, (0..256) .flat_map(|i| { let v = ((i as f64 * std::f64::consts::TAU / 256.0).sin() * 512.0) as i16; [v, v] }) .collect(), ) .with_channels(2) .unwrap() .with_loop(0, 256), ); let make_bank = || { Arc::new( MusicBank::compile( "physical".into(), vec![sample.clone()], vec![Instrument { looping: true, send: 32768, ..Default::default() }], (0..12) .map(|n| MusicEvent { kind: 1, a: n, c: 60 + n as i32, d: 255, ..Default::default() }) .collect(), 960, 500000, 3840, None, 1, ) .unwrap(), ) }; let banks = Arc::new(MemoryBanks::new()); banks.install_music_bank(0, make_bank()); banks.install_music_bank(1, make_bank()); let mut audio = Audio::new(banks.clone()); audio.music_play(0, 0, true); audio.music_play(1, 1, true); for group in 0..2 { audio.control(AudioControl::MusicVolume { group, gain: 8 }); } for voice in 0..8 { audio.play_sample(sample.clone(), voice, 8, 128, 1.0, 0, LoopMode::On); audio.control(AudioControl::SfxSend { voice, gain: 100 }); } 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 callback, mut reclaimer) = AudioCallback::new(); let transport = audio.transport(); let (mut writer, mut reader) = HeapRb::<(u64, usize, usize)>::new(4096).split(); let failures = Arc::new(AtomicUsize::new(0)); let allocator = Arc::new(AtomicUsize::new(0)); let failure = failures.clone(); let allocations = allocator.clone(); let config = cpal::StreamConfig { channels: 2, sample_rate: cpal::SampleRate(48000), buffer_size: cpal::BufferSize::Fixed(256), }; let stream = device .build_output_stream( &config, move |data: &mut [f32], _: &cpal::OutputCallbackInfo| { let start = Instant::now(); let (a, d) = measured(|| callback.render(&transport, data)); allocations.fetch_add(a + d, Ordering::Relaxed); let _ = writer.try_push(( start.elapsed().as_nanos() as u64, data.len() / 2, callback.diagnostics().maximum_voices, )); }, move |_| { failure.fetch_add(1, Ordering::Relaxed); }, None, ) .unwrap(); let temporary = std::env::temp_dir().join(format!("prometeu-audio-32-pressure-{}", std::process::id())); let pressure = vec![0x5a; 512 * 1024]; let fixture = include_bytes!(concat!( env!("CARGO_MANIFEST_DIR"), "/../../../test-fixtures/audio/mixed-music.mbnk" )); stream.play().unwrap(); let end = Instant::now() + Duration::from_secs(2); let mut replacements = 0; while Instant::now() < end { std::fs::write(&temporary, &pressure).unwrap(); let decoded = prometeu_drivers::bank_format::decode_audio_bank(fixture, true).unwrap(); std::hint::black_box(decoded); reclaimer.service(&audio.transport()); if audio.ready() { banks.install_music_bank(0, make_bank()); audio.music_play(0, 0, true); audio.control(AudioControl::MusicVolume { group: 0, gain: 8 }); audio.finish_frame(); replacements += 1; } std::thread::sleep(Duration::from_millis(2)); } stream.pause().unwrap(); drop(stream); reclaimer.service(&audio.transport()); std::fs::remove_file(temporary).unwrap(); let mut timings = Vec::new(); let mut overruns = 0; let mut maximum_voices = 0; while let Some((n, frames, voices)) = reader.try_pop() { maximum_voices = maximum_voices.max(voices); timings.push(n); if n as u128 > frames as u128 * 1_000_000_000 / 48000 { overruns += 1; } } timings.sort_unstable(); assert!(!timings.is_empty()); let n = timings.len(); println!( "physical_32_stereo device={name:?} maximum_voices={maximum_voices} callbacks={n} replacements={replacements} p50_ns={} p95_ns={} p99_ns={} max_ns={} budget_overruns={overruns} device_errors={} allocator_calls={} maximum_retired_pcm_bytes={}", timings[n / 2], timings[n * 95 / 100], timings[n * 99 / 100], timings[n - 1], failures.load(Ordering::Relaxed), allocator.load(Ordering::Relaxed), reclaimer.maximum_retired_pcm_bytes ); assert_eq!(maximum_voices, 32); assert_eq!(failures.load(Ordering::Relaxed), 0); assert_eq!(allocator.load(Ordering::Relaxed), 0); }