Add self-contained SoundBanks and MusicBanks with per-sample PCM16 and IMA ADPCM storage, materialized to resident PCM16. Integrate instrument envelopes, automation, shared DSP and host lifecycle controls while preserving staged real-time execution.
257 lines
9.6 KiB
Rust
257 lines
9.6 KiB
Rust
//! 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<MusicBank> {
|
|
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<i16> = (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());
|
|
}
|