|
|
pub(crate) mod data; |
|
|
|
|
|
use std::{ |
|
|
collections::{BTreeMap, hash_map::Entry}, |
|
|
fs::File, |
|
|
hash::BuildHasherDefault, |
|
|
path::{Path, PathBuf}, |
|
|
time::{Duration, UNIX_EPOCH}, |
|
|
}; |
|
|
|
|
|
use anyhow::{Context, anyhow}; |
|
|
use chrono::{DateTime, Utc}; |
|
|
use indexmap::IndexSet; |
|
|
use rustc_hash::{FxHashMap, FxHasher}; |
|
|
use walkdir::WalkDir; |
|
|
|
|
|
use self::data::Benchmark; |
|
|
use crate::summarize_bench::data::{BaseBenchmarks, CStats}; |
|
|
|
|
|
type FxIndexSet<T> = IndexSet<T, BuildHasherDefault<FxHasher>>; |
|
|
|
|
|
#[derive(Debug)] |
|
|
struct BenchDataFile { |
|
|
path: PathBuf, |
|
|
sha: String, |
|
|
timestamp: u64, |
|
|
system: String, |
|
|
} |
|
|
|
|
|
impl<'a> TryFrom<&'a Path> for BenchDataFile { |
|
|
type Error = &'static str; |
|
|
|
|
|
fn try_from(path: &'a Path) -> Result<Self, Self::Error> { |
|
|
let key_dir = path.parent().ok_or("invalid structure")?; |
|
|
let sha_dir = key_dir.parent().ok_or("invalid structure")?; |
|
|
let system_dir = sha_dir.parent().ok_or("invalid structure")?; |
|
|
let (timestamp, sha) = sha_dir |
|
|
.file_name() |
|
|
.ok_or("invalid filename")? |
|
|
.to_str() |
|
|
.ok_or("invalid chars in file name")? |
|
|
.split_once('-') |
|
|
.ok_or("missing dash in timestamp-sha directory")?; |
|
|
Ok(Self { |
|
|
path: path.to_path_buf(), |
|
|
sha: sha.to_string(), |
|
|
timestamp: timestamp.parse().map_err(|_| "unable to parse timestamp")?, |
|
|
system: system_dir |
|
|
.file_name() |
|
|
.ok_or("invalid filename")? |
|
|
.to_str() |
|
|
.ok_or("invalid chars in file name")? |
|
|
.to_string(), |
|
|
}) |
|
|
} |
|
|
} |
|
|
|
|
|
pub fn process_all(path: PathBuf) { |
|
|
let mut map = FxHashMap::default(); |
|
|
for entry in WalkDir::new(&path) |
|
|
.into_iter() |
|
|
.filter_map(Result::ok) |
|
|
.filter(|e| { |
|
|
e.file_type().is_file() |
|
|
&& e.file_name().to_str().map(|n| n.ends_with("raw.json")) == Some(true) |
|
|
}) |
|
|
{ |
|
|
let data_file_result: Result<BenchDataFile, _> = entry.path().try_into(); |
|
|
if let Ok(data_file) = data_file_result { |
|
|
let inner_map: &mut FxHashMap<_, _> = map.entry(data_file.system.clone()).or_default(); |
|
|
let items: &mut Vec<BenchDataFile> = |
|
|
inner_map.entry(data_file.sha.clone()).or_default(); |
|
|
items.push(data_file); |
|
|
} |
|
|
} |
|
|
for (system, inner_map) in map { |
|
|
let mut latest: FxHashMap<String, (u64, String, Benchmark)> = FxHashMap::default(); |
|
|
for (sha, data_files) in inner_map { |
|
|
let min_ts = data_files.iter().map(|d| d.timestamp).min().unwrap(); |
|
|
let max_ts = data_files.iter().map(|d| d.timestamp).max().unwrap(); |
|
|
let mut items = data_files |
|
|
.iter() |
|
|
.map(|data_file| { |
|
|
let file = File::open(&data_file.path).unwrap(); |
|
|
let reader = std::io::BufReader::new(file); |
|
|
let data: BaseBenchmarks = serde_json::from_reader(reader) |
|
|
.with_context(|| anyhow!("unable to read {}", data_file.path.display())) |
|
|
.unwrap(); |
|
|
data |
|
|
}) |
|
|
.collect::<Vec<_>>(); |
|
|
let mut by_name = FxHashMap::default(); |
|
|
for (i, data) in items.iter().enumerate() { |
|
|
for (name, bench) in data.benchmarks.iter() { |
|
|
let list: &mut Vec<_> = by_name.entry(name).or_default(); |
|
|
list.push((i, bench)); |
|
|
} |
|
|
} |
|
|
let mut normalization_state = items.iter().map(|_| (0.0, 0)).collect::<Vec<_>>(); |
|
|
for list in by_name.values().filter(|l| l.len() > 1) { |
|
|
let avg = list |
|
|
.iter() |
|
|
.map(|(_, b)| b.estimates.mean.point_estimate) |
|
|
.sum::<f64>() |
|
|
/ list.len() as f64; |
|
|
for (i, b) in list { |
|
|
let correction = avg / b.estimates.mean.point_estimate; |
|
|
let (sum, count) = &mut normalization_state[*i]; |
|
|
*sum += correction; |
|
|
*count += 1; |
|
|
} |
|
|
} |
|
|
for (i, benches) in items.iter_mut().enumerate() { |
|
|
let (sum, count) = normalization_state[i]; |
|
|
if count <= 1 { |
|
|
continue; |
|
|
} |
|
|
let correction = sum / count as f64; |
|
|
for bench in benches.benchmarks.values_mut() { |
|
|
fn correct(s: &mut CStats, f: f64) { |
|
|
s.point_estimate *= f; |
|
|
s.standard_error *= f; |
|
|
s.confidence_interval.lower_bound *= f; |
|
|
s.confidence_interval.upper_bound *= f; |
|
|
} |
|
|
correct(&mut bench.estimates.mean, correction); |
|
|
correct(&mut bench.estimates.median, correction); |
|
|
correct(&mut bench.estimates.median_abs_dev, correction); |
|
|
if let Some(slope) = bench.estimates.slope.as_mut() { |
|
|
correct(slope, correction); |
|
|
} |
|
|
correct(&mut bench.estimates.std_dev, correction); |
|
|
} |
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
} |
|
|
let baseline = &sha[..7]; |
|
|
let mut latest_for_sha = BaseBenchmarks { |
|
|
name: baseline.to_string(), |
|
|
benchmarks: BTreeMap::new(), |
|
|
}; |
|
|
let all_benchmark_keys = items |
|
|
.iter() |
|
|
.flat_map(|b| b.benchmarks.keys()) |
|
|
.collect::<FxIndexSet<_>>(); |
|
|
for key in all_benchmark_keys { |
|
|
let (ts, bench) = items |
|
|
.iter() |
|
|
.enumerate() |
|
|
.map(|(i, b)| (data_files[i].timestamp, b)) |
|
|
.filter_map(|(ts, benches)| benches.benchmarks.get(key).map(|b| (ts, b))) |
|
|
.max_by_key(|(ts, _)| *ts) |
|
|
.unwrap(); |
|
|
let ts = UNIX_EPOCH + Duration::from_secs(ts); |
|
|
let ts = DateTime::<Utc>::from(ts); |
|
|
let ts = ts.format("%Y-%m-%d %H:%M"); |
|
|
let key_ts = format!("{key} ({ts})"); |
|
|
let key_ts_sha = format!("{key} ({ts}, {})", &sha[..7]); |
|
|
match latest.entry(key.to_string()) { |
|
|
Entry::Occupied(mut e) => { |
|
|
if e.get().0 < min_ts { |
|
|
e.insert((min_ts, key_ts_sha, bench.clone())); |
|
|
} |
|
|
} |
|
|
Entry::Vacant(e) => { |
|
|
e.insert((min_ts, key_ts_sha, bench.clone())); |
|
|
} |
|
|
} |
|
|
latest_for_sha.benchmarks.insert(key_ts, bench.clone()); |
|
|
} |
|
|
let latest_for_sha_path = data_files |
|
|
.first() |
|
|
.unwrap() |
|
|
.path |
|
|
.parent() |
|
|
.unwrap() |
|
|
.parent() |
|
|
.unwrap() |
|
|
.parent() |
|
|
.unwrap() |
|
|
.join(format!("{min_ts}-{max_ts}-{sha}.json")); |
|
|
let file = File::create(&latest_for_sha_path).unwrap(); |
|
|
let writer = std::io::BufWriter::new(file); |
|
|
serde_json::to_writer_pretty(writer, &latest_for_sha).unwrap(); |
|
|
println!("{}", latest_for_sha_path.display()); |
|
|
} |
|
|
|
|
|
let latest_for_system = BaseBenchmarks { |
|
|
name: "latest".to_string(), |
|
|
benchmarks: latest |
|
|
.into_values() |
|
|
.map(|(_, key, bench)| (key, bench)) |
|
|
.collect(), |
|
|
}; |
|
|
let latest_path = path.join(format!("{system}.json")); |
|
|
let file = File::create(&latest_path).unwrap(); |
|
|
let writer = std::io::BufWriter::new(file); |
|
|
serde_json::to_writer_pretty(writer, &latest_for_system).unwrap(); |
|
|
println!("{}", latest_path.display()); |
|
|
} |
|
|
} |
|
|
|
