// Copyright (C) 2026 Yusuke Oda // SPDX-License-Identifier: AGPL-3.0-only mod compressor_f32; mod compressor_f64; use std::hint::black_box; use std::time::{Duration, Instant}; // Research-only x86_64 thread-local FP mode. SSE2 is available on x86_64; // preserve every unrelated control bit and restore the complete saved MXCSR. struct FloatMode(u32); impl FloatMode { #[allow(deprecated)] fn new(flush: bool) -> Self { unsafe { let previous = std::arch::x86_64::_mm_getcsr(); let mask = (1 << 15) | (1 << 6); std::arch::x86_64::_mm_setcsr(if flush { previous | mask } else { previous & !mask }); Self(previous) } } #[allow(deprecated)] fn current() -> u32 { unsafe { std::arch::x86_64::_mm_getcsr() } } } impl Drop for FloatMode { #[allow(deprecated)] fn drop(&mut self) { unsafe { std::arch::x86_64::_mm_setcsr(self.0) } } } fn fingerprint(bytes: &[u8]) -> String { let mut hash = 0xcbf29ce484222325_u64; for &byte in bytes { hash ^= byte as u64; hash = hash.wrapping_mul(0x100000001b3); } format!("{hash:016x}") } macro_rules! implementation { ($module:ident, $core:ident, $float:ty, $precision:literal) => { mod $module { use super::*; use $core::{Compressor, CompressorMethod as M, StereoLink as L}; fn diagnostic(p: &Compressor) -> String { // Disable DAZ/FTZ only while inspecting the stored values: a cast // or floating comparison under DAZ could hide an existing subnormal. let _diagnostic_mode = FloatMode::new(false); let (values, subnormal) = p.diagnostic_state(); let classes: Vec<_> = values.iter().zip(subnormal).map(|(&v, sub)| { if sub { "subnormal" } else if v == 0.0 { "zero" } else { "normal" } }).collect(); let bits: Vec<_> = values.iter().map(|x| format!("{:016x}", x.to_bits())).collect(); let state_hash = fingerprint(format!("{p:?}").as_bytes()); format!("{{\"values\":{values:?},\"subnormal\":{subnormal:?},\"classes\":{classes:?},\"f64_value_bits\":{bits:?},\"state_fingerprint\":\"{state_hash}\"}}") } #[inline(never)] fn process_interval(p: &mut Compressor, input: &[[$float; 2]], output: &mut [[$float; 2]], block: usize) { for (x, y) in input.chunks(block).zip(output.chunks_mut(block)) { black_box(&mut *p).process_samples(black_box(x), black_box(&mut *y)); black_box(y); } black_box(p); } pub fn bench(case: &str, method: &str, flush: bool, rate: usize, block: usize, seconds: usize, burn_ms: u64) -> String { assert_eq!((rate, block, seconds), (48000, 256, 4)); let prior = FloatMode::current(); let mode = FloatMode::new(flush); let control = FloatMode::current() & !0x3f; let selected = match method { "peaklog" => M::PeakLog, "rmsiir" => M::RmsIir, "gainlinear" => M::PeakLinearGain, _ => panic!("method") }; let mut prepared = Compressor::new(selected, if method == "rmsiir" { L::MaximumAfterDetector } else { L::Maximum }, rate as $float, 10.0); let ones = vec![[1.0 as $float; 2]; rate]; let zeros = vec![[0.0 as $float; 2]; rate * seconds]; let mut output = vec![[0.0 as $float; 2]; rate * seconds]; process_interval(&mut prepared, &ones, &mut output[..rate], block); for _ in 0..120 { process_interval(&mut prepared, &zeros[..rate], &mut output[..rate], block); } let initial = diagnostic(&prepared); let parameters = prepared.effective_parameters(); let state_bytes = prepared.state_bytes(); let burn_start = Instant::now(); let mut cycles = 0; while burn_start.elapsed() < Duration::from_millis(burn_ms) || cycles == 0 { let mut p = prepared.clone(); process_interval(&mut p, &zeros, &mut output, block); black_box(p); cycles += 1; } let burn_ns = burn_start.elapsed().as_nanos(); // The clone, verification and all allocation are outside the clock. let mut p = prepared.clone(); assert_eq!(diagnostic(&p), initial); let start = Instant::now(); process_interval(&mut p, &zeros, &mut output, block); let elapsed = start.elapsed().as_nanos(); let final_state = diagnostic(&p); assert_eq!(diagnostic(&prepared), initial); let frames = zeros.len(); let mut bytes = Vec::with_capacity(output.len() * 2 * size_of::<$float>()); for &value in output.iter().flatten() { assert_eq!(value.to_bits() << 1, 0); bytes.extend(value.to_bits().to_le_bytes()); } let checksum = fingerprint(&bytes); drop(mode); let restored = FloatMode::current() == prior; assert!(restored); format!("{{\"case_id\":\"{case}\",\"frames\":{frames},\"channels\":2,\"elapsed_ns\":{elapsed},\"ns_per_frame\":{},\"burn_in_ns\":{burn_ns},\"burn_in_cycles\":{cycles},\"checksum\":\"{checksum}\",\"peak\":0.0,\"rms\":0.0,\"state_bytes\":{state_bytes},\"latency_samples\":0,\"precision\":\"{}\",\"method\":\"{method}\",\"flush\":{flush},\"mxcsr_control\":{control},\"mxcsr_restored\":{restored},\"dc_prepare_frames\":{rate},\"silent_prepare_frames\":{},\"prepared_state\":{initial},\"final_state\":{final_state},\"effective_parameters\":{parameters:?}}}", elapsed as f64 / frames as f64, $precision, 120 * rate) } }}; } implementation!(c64, compressor_f64, f64, "f64"); implementation!(c32, compressor_f32, f32, "f32"); fn main() { let args: Vec<_> = std::env::args().collect(); assert_eq!(args.len(), 7); assert_eq!(args[1], "bench"); let parts: Vec<_> = args[2].split('-').collect(); assert_eq!(parts.len(), 3); let flush = match parts[2] { "flush" => true, "gradual" => false, _ => panic!("mode") }; let rate = args[3].parse().unwrap(); let block = args[4].parse().unwrap(); let seconds = args[5].parse().unwrap(); let burn = args[6].parse().unwrap(); let result = match parts[1] { "f64" => c64::bench(&args[2], parts[0], flush, rate, block, seconds, burn), "f32" => c32::bench(&args[2], parts[0], flush, rate, block, seconds, burn), _ => panic!("precision"), }; println!("{result}"); }