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..16).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..16 { 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(16).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; 16 quiet voices and temporary file I/O"] fn physical_callback_duration_16_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..16 { 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), (16, 0)); } #[test] #[ignore = "release timing observation with temporary asset-read/save-write pressure"] fn callback_duration_16_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..16).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), (16, 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_some() && weak_empty.upgrade().is_some()); reclaimer.service(&audio.transport()); assert!(weak.upgrade().is_none() && weak_empty.upgrade().is_none()); }