Files
prometeu-runtime/crates/host/prometeu-host-desktop-winit/tests/audio_callback_allocations.rs
T

348 lines
14 KiB
Rust

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<Option<(usize, usize)>> = 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<Sample> {
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());
}