perf(audio): reclaim callback owners through bounded return packets
This commit is contained in:
@@ -0,0 +1,347 @@
|
||||
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());
|
||||
}
|
||||
Reference in New Issue
Block a user