204 lines
6.7 KiB
Rust
204 lines
6.7 KiB
Rust
// SDD-120 §5 — JSON post-processor binary.
|
|
//
|
|
// Reads criterion's per-bench `target/criterion/<group>/<bench>/estimates.json`
|
|
// outputs, plus the `capture_alloc_count.sidecar` value written by
|
|
// `realtime_capture.rs`, and projects them into the SRS-217 schema:
|
|
// {
|
|
// "host": "x86_64-unknown-linux-gnu",
|
|
// "toolchain": "<rustc -V>",
|
|
// "git_sha": "<HEAD>",
|
|
// "timestamp": "<RFC3339 UTC>",
|
|
// "metrics": [
|
|
// { "metric": "<name>", "value": <f64>, "unit": "<u>",
|
|
// "tolerance_pct": <f64>, ... },
|
|
// ...
|
|
// ]
|
|
// }
|
|
//
|
|
// Writes the document to `./current.json`.
|
|
//
|
|
// Run as: `cargo run --bin emit_baseline -p chanora_audio`.
|
|
|
|
use std::env;
|
|
use std::fs;
|
|
use std::path::{Path, PathBuf};
|
|
use std::process::Command;
|
|
use std::time::{SystemTime, UNIX_EPOCH};
|
|
|
|
use serde_json::{json, Value};
|
|
|
|
/// Per-metric SRS-219 tolerance entries. Zero-tolerance metrics
|
|
/// per SRS-219 clause a use 0.0 here; the comparator collapses
|
|
/// them to 🔴/🟢 only.
|
|
fn metric_table() -> Vec<(&'static str, &'static str, f64)> {
|
|
// (metric_name, unit, tolerance_pct)
|
|
vec![
|
|
("capture_alloc_count", "blocks", 0.0),
|
|
("capture_callback_wall_clock", "ns", 0.10),
|
|
("opus_encode_latency", "ns", 0.10),
|
|
("opus_decode_latency", "ns", 0.10),
|
|
("resampler_44100_to_48000", "samples_per_sec", 0.10),
|
|
("resampler_16000_to_48000", "samples_per_sec", 0.10),
|
|
("resampler_48000_passthrough", "samples_per_sec", 0.10),
|
|
]
|
|
}
|
|
|
|
fn target_dir() -> PathBuf {
|
|
env::var("CARGO_TARGET_DIR")
|
|
.map(PathBuf::from)
|
|
.unwrap_or_else(|_| PathBuf::from("target"))
|
|
}
|
|
|
|
/// Read criterion `estimates.json` for a given bench function
|
|
/// name (criterion writes one per non-grouped bench under
|
|
/// `target/criterion/<bench>/new/estimates.json`).
|
|
fn read_estimate_ns(name: &str) -> Option<f64> {
|
|
let path = target_dir()
|
|
.join("criterion")
|
|
.join(name)
|
|
.join("new")
|
|
.join("estimates.json");
|
|
let text = fs::read_to_string(&path).ok()?;
|
|
let v: Value = serde_json::from_str(&text).ok()?;
|
|
// criterion estimates.json has `mean.point_estimate` (in ns).
|
|
v.get("mean")
|
|
.and_then(|m| m.get("point_estimate"))
|
|
.and_then(|p| p.as_f64())
|
|
}
|
|
|
|
/// Read criterion `estimates.json` for a sub-bench inside a group
|
|
/// (criterion writes group sub-benches under
|
|
/// `target/criterion/<group>/<sub>/new/estimates.json`).
|
|
fn read_estimate_group_ns(group: &str, sub: &str) -> Option<f64> {
|
|
let path = target_dir()
|
|
.join("criterion")
|
|
.join(group)
|
|
.join(sub)
|
|
.join("new")
|
|
.join("estimates.json");
|
|
let text = fs::read_to_string(&path).ok()?;
|
|
let v: Value = serde_json::from_str(&text).ok()?;
|
|
v.get("mean")
|
|
.and_then(|m| m.get("point_estimate"))
|
|
.and_then(|p| p.as_f64())
|
|
}
|
|
|
|
/// Resampler reports throughput; convert ns-per-iter to samples
|
|
/// per second using the per-iter input length (1s @ rate).
|
|
fn ns_to_throughput(ns_per_iter: f64, samples_per_iter: f64) -> f64 {
|
|
if ns_per_iter <= 0.0 {
|
|
return 0.0;
|
|
}
|
|
samples_per_iter * 1_000_000_000.0 / ns_per_iter
|
|
}
|
|
|
|
fn read_alloc_sidecar() -> Option<f64> {
|
|
let path = target_dir()
|
|
.join("criterion")
|
|
.join("capture_alloc_count.sidecar");
|
|
let s = fs::read_to_string(&path).ok()?;
|
|
s.trim().parse::<f64>().ok()
|
|
}
|
|
|
|
fn rustc_version() -> String {
|
|
Command::new("rustc")
|
|
.arg("-V")
|
|
.output()
|
|
.ok()
|
|
.and_then(|o| {
|
|
if o.status.success() {
|
|
Some(String::from_utf8_lossy(&o.stdout).trim().to_string())
|
|
} else {
|
|
None
|
|
}
|
|
})
|
|
.unwrap_or_else(|| "unknown".to_string())
|
|
}
|
|
|
|
fn git_sha() -> String {
|
|
Command::new("git")
|
|
.args(["rev-parse", "HEAD"])
|
|
.output()
|
|
.ok()
|
|
.and_then(|o| {
|
|
if o.status.success() {
|
|
Some(String::from_utf8_lossy(&o.stdout).trim().to_string())
|
|
} else {
|
|
None
|
|
}
|
|
})
|
|
.unwrap_or_else(|| "unknown".to_string())
|
|
}
|
|
|
|
fn rfc3339_now() -> String {
|
|
let secs = SystemTime::now()
|
|
.duration_since(UNIX_EPOCH)
|
|
.map(|d| d.as_secs())
|
|
.unwrap_or(0);
|
|
// Minimal RFC3339-style UTC encoder; avoids pulling chrono.
|
|
// Algorithm: civil-from-days (Howard Hinnant).
|
|
let z = secs / 86_400;
|
|
let day_secs = secs % 86_400;
|
|
let hh = day_secs / 3600;
|
|
let mm = (day_secs % 3600) / 60;
|
|
let ss = day_secs % 60;
|
|
let z_shift = z as i64 + 719_468;
|
|
let era = z_shift.div_euclid(146_097);
|
|
let doe = z_shift.rem_euclid(146_097) as u64;
|
|
let yoe = (doe - doe / 1460 + doe / 36_524 - doe / 146_096) / 365;
|
|
let y = yoe as i64 + era * 400;
|
|
let doy = doe - (365 * yoe + yoe / 4 - yoe / 100);
|
|
let mp = (5 * doy + 2) / 153;
|
|
let d = doy - (153 * mp + 2) / 5 + 1;
|
|
let m = if mp < 10 { mp + 3 } else { mp - 9 };
|
|
let year = if m <= 2 { y + 1 } else { y };
|
|
format!(
|
|
"{:04}-{:02}-{:02}T{:02}:{:02}:{:02}Z",
|
|
year, m, d, hh, mm, ss
|
|
)
|
|
}
|
|
|
|
fn main() {
|
|
let mut metrics: Vec<Value> = Vec::new();
|
|
for (name, unit, tol) in metric_table() {
|
|
let value = match name {
|
|
"capture_alloc_count" => read_alloc_sidecar(),
|
|
"capture_callback_wall_clock" => read_estimate_ns(name),
|
|
"opus_encode_latency" => read_estimate_ns(name),
|
|
"opus_decode_latency" => read_estimate_ns(name),
|
|
"resampler_44100_to_48000" => {
|
|
read_estimate_group_ns("resampler_throughput", "44100_to_48000")
|
|
.map(|ns| ns_to_throughput(ns, 44_100.0))
|
|
}
|
|
"resampler_16000_to_48000" => {
|
|
read_estimate_group_ns("resampler_throughput", "16000_to_48000")
|
|
.map(|ns| ns_to_throughput(ns, 16_000.0))
|
|
}
|
|
"resampler_48000_passthrough" => {
|
|
read_estimate_group_ns("resampler_throughput", "48000_passthrough")
|
|
.map(|ns| ns_to_throughput(ns, 48_000.0))
|
|
}
|
|
_ => None,
|
|
};
|
|
let v = value.unwrap_or(f64::NAN);
|
|
metrics.push(json!({
|
|
"metric": name,
|
|
"value": if v.is_finite() { Value::from(v) } else { Value::Null },
|
|
"unit": unit,
|
|
"tolerance_pct": tol,
|
|
}));
|
|
}
|
|
|
|
let doc = json!({
|
|
"host": "x86_64-unknown-linux-gnu",
|
|
"toolchain": rustc_version(),
|
|
"git_sha": git_sha(),
|
|
"timestamp": rfc3339_now(),
|
|
"metrics": metrics,
|
|
});
|
|
|
|
let out_path = Path::new("current.json");
|
|
fs::write(out_path, serde_json::to_string_pretty(&doc).unwrap()).expect("write current.json");
|
|
eprintln!("emit_baseline: wrote {}", out_path.display());
|
|
}
|