use std::{
env,
fs,
path::{
Component,
Path,
PathBuf,
},
};
use burn::prelude::Backend;
use crate::errors::{
BunsenError,
BunsenErrorKind,
BunsenResult,
ParseError,
ResultContext,
sys_at,
};
pub fn cargo_target_dir() -> Option<PathBuf> {
if let Some(dir) = env::var_os("CARGO_TARGET_DIR") {
return Some(PathBuf::from(dir));
}
env::current_exe().ok().and_then(|exe| target_dir_of(&exe))
}
fn target_dir_of(exe: &Path) -> Option<PathBuf> {
let mut dir = exe.parent()?;
if dir.file_name()? == "deps" {
dir = dir.parent()?;
}
Some(dir.parent()?.to_path_buf())
}
pub fn backend_label<B: Backend>(device: &B::Device) -> String {
path_label(&B::name(device))
}
fn path_label(name: &str) -> String {
name.split(|c: char| !(c.is_ascii_alphanumeric() || ".-".contains(c)))
.filter(|part| !part.is_empty())
.collect::<Vec<_>>()
.join("_")
}
#[derive(Debug, Clone, PartialEq, Eq)]
pub struct ReportsOptions {
root: PathBuf,
mode: BaselineMode,
}
impl ReportsOptions {
pub fn new(root: impl Into<PathBuf>) -> Self {
Self {
root: root.into(),
mode: BaselineMode::default(),
}
}
pub fn with_mode(
self,
mode: BaselineMode,
) -> Self {
Self { mode, ..self }
}
pub fn root(&self) -> &Path {
&self.root
}
pub fn mode(&self) -> BaselineMode {
self.mode
}
pub fn report_path(
&self,
backend: &str,
name: &str,
) -> BunsenResult<PathBuf> {
let rel = Path::new(name);
if name.is_empty() || !rel.components().all(|c| matches!(c, Component::Normal(_))) {
return Err(BunsenError::illegal(format!(
"report name {name:?} must be a relative path without `..`"
)));
}
Ok(self.root.join(backend).join(rel))
}
}
#[derive(Debug, Clone, Copy, PartialEq, Eq, Default)]
pub enum BaselineMode {
#[default]
Auto,
Record,
Verify,
}
impl BaselineMode {
pub fn from_env(var: &str) -> BunsenResult<Self> {
match env::var(var) {
Err(_) => Ok(Self::Auto),
Ok(value) => {
Self::parse(&value).with_context(|| format!("reading environment variable {var}"))
}
}
}
pub fn parse(value: &str) -> BunsenResult<Self> {
match value.to_ascii_lowercase().as_str() {
"" | "auto" => Ok(Self::Auto),
"record" => Ok(Self::Record),
"verify" => Ok(Self::Verify),
_ => Err(BunsenError::from_cause(
BunsenErrorKind::Policy,
ParseError::new("baseline mode")
.input(value)
.because("expected auto, record, or verify"),
)),
}
}
}
#[derive(Debug, Clone, Default, PartialEq)]
pub struct SeriesReport {
columns: Vec<(String, Vec<f64>)>,
}
impl SeriesReport {
pub fn new() -> Self {
Self::default()
}
#[track_caller]
pub fn column(
mut self,
name: &str,
values: Vec<f64>,
) -> Self {
assert!(
!name.is_empty() && !name.contains(','),
"column name {name:?} must be non-empty, without ','"
);
if let Some((first, v)) = self.columns.first() {
assert_eq!(
values.len(),
v.len(),
"column {name:?} has {} values; {first:?} has {}",
values.len(),
v.len()
);
}
self.columns.push((name.to_string(), values));
self
}
pub fn get(
&self,
name: &str,
) -> Option<&[f64]> {
self.columns
.iter()
.find(|(n, _)| n == name)
.map(|(_, v)| v.as_slice())
}
pub fn to_csv(&self) -> String {
let mut out = String::from("step");
for (name, _) in &self.columns {
out.push(',');
out.push_str(name);
}
out.push('\n');
let rows = self.columns.first().map_or(0, |(_, v)| v.len());
for i in 0..rows {
out.push_str(&i.to_string());
for (_, v) in &self.columns {
out.push(',');
out.push_str(&v[i].to_string());
}
out.push('\n');
}
out
}
pub fn from_csv(text: &str) -> BunsenResult<Self> {
let invalid = |e: ParseError| BunsenError::from_cause(BunsenErrorKind::InvalidResource, e);
let mut lines = text.lines();
let header = lines
.next()
.ok_or_else(|| invalid(ParseError::new("series CSV").because("empty text")))?;
let mut names = header.split(',');
if names.next() != Some("step") {
return Err(invalid(
ParseError::new("series CSV header")
.input(header)
.because("must start with \"step\""),
));
}
let mut columns: Vec<(String, Vec<f64>)> =
names.map(|n| (n.to_string(), Vec::new())).collect();
for (row, line) in lines.enumerate() {
let cells: Vec<&str> = line.split(',').collect();
if cells.len() != columns.len() + 1 || cells[0] != row.to_string() {
return Err(invalid(
ParseError::new("series CSV row")
.at(format!("row {row}"))
.input(line)
.because(format!(
"expected {} cells, starting with step {row}",
columns.len() + 1
)),
));
}
for ((_, col), cell) in columns.iter_mut().zip(&cells[1..]) {
col.push(cell.parse().map_err(|e| {
invalid(
ParseError::new("series CSV value")
.at(format!("row {row}"))
.input(cell)
.with_source(e),
)
})?);
}
}
Ok(Self { columns })
}
pub fn write(
&self,
path: &Path,
) -> BunsenResult<()> {
if let Some(parent) = path.parent() {
fs::create_dir_all(parent).map_err(sys_at("create directory", parent))?;
}
fs::write(path, self.to_csv()).map_err(sys_at("write", path))
}
pub fn write_report<B: Backend>(
&self,
options: &ReportsOptions,
device: &B::Device,
name: &str,
) -> BunsenResult<PathBuf> {
let path = options.report_path(&backend_label::<B>(device), &format!("{name}.csv"))?;
self.write(&path)?;
Ok(path)
}
pub fn read(path: &Path) -> BunsenResult<Self> {
let text = fs::read_to_string(path).map_err(sys_at("read", path))?;
Self::from_csv(&text).with_context(|| format!("reading {}", path.display()))
}
}
#[cfg(test)]
mod tests {
use super::*;
use crate::{
errors::testing::{
ErrorMatcher,
predicate,
},
support::testing::{
CpuBackend,
backend_device,
},
};
#[test]
fn test_target_dir_of() {
let exe = Path::new("/w/target/debug/deps/foo-1234");
assert_eq!(target_dir_of(exe), Some(PathBuf::from("/w/target")));
let exe = Path::new("/w/target/release/foo");
assert_eq!(target_dir_of(exe), Some(PathBuf::from("/w/target")));
}
#[test]
fn test_report_path_rejects_escapes() {
let options = ReportsOptions::new("r");
assert_eq!(
options.report_path("flex", "a/b.cbor").unwrap(),
Path::new("r").join("flex").join("a/b.cbor")
);
for name in ["", "../x", "/abs"] {
ErrorMatcher::kind(BunsenErrorKind::Illegal)
.message_contains("must be a relative path without `..`")
.assert_err(&options.report_path("flex", name));
}
}
#[test]
fn test_backend_label() {
assert_eq!(path_label("cubecl<wgpu<spirv>>"), "cubecl_wgpu_spirv");
assert_eq!(path_label("fusion<cubecl<cuda>>"), "fusion_cubecl_cuda");
assert_eq!(path_label("ndarray"), "ndarray");
let label = backend_label::<CpuBackend>(&backend_device::<CpuBackend>());
assert!(!label.is_empty());
assert!(
label
.chars()
.all(|c| c.is_ascii_alphanumeric() || "._-".contains(c)),
"{label}"
);
}
#[test]
fn test_baseline_mode_parse() {
assert_eq!(BaselineMode::parse("").unwrap(), BaselineMode::Auto);
assert_eq!(BaselineMode::parse("Record").unwrap(), BaselineMode::Record);
assert_eq!(BaselineMode::parse("verify").unwrap(), BaselineMode::Verify);
ErrorMatcher::kind(BunsenErrorKind::Policy)
.message_eq("cannot parse baseline mode \"replay\": expected auto, record, or verify")
.has_cause::<ParseError>()
.assert_err(&BaselineMode::parse("replay"));
}
#[test]
fn test_reports_options() {
let options = ReportsOptions::new("r");
assert_eq!(options.root(), Path::new("r"));
assert_eq!(options.mode(), BaselineMode::Auto);
let options = options.with_mode(BaselineMode::Verify);
assert_eq!(options.root(), Path::new("r"));
assert_eq!(options.mode(), BaselineMode::Verify);
}
#[test]
fn test_series_report_round_trip() {
let report = SeriesReport::new()
.column("energy", vec![1.0, 1.0 + 1e-15, 0.1 + 0.2])
.column("error", vec![0.0, -2.5e-300, f64::MAX]);
let csv = report.to_csv();
assert!(csv.starts_with("step,energy,error\n0,1,0\n"), "{csv}");
assert_eq!(SeriesReport::from_csv(&csv).unwrap(), report);
let dir = tempfile::tempdir().unwrap();
let path = dir.path().join("series").join("report.csv");
report.write(&path).unwrap();
assert_eq!(SeriesReport::read(&path).unwrap(), report);
let options = ReportsOptions::new(dir.path());
let device = backend_device::<CpuBackend>();
let path = report
.write_report::<CpuBackend>(&options, &device, "g/s")
.unwrap();
assert_eq!(
path,
options
.report_path(&backend_label::<CpuBackend>(&device), "g/s.csv")
.unwrap()
);
assert_eq!(SeriesReport::read(&path).unwrap(), report);
assert_eq!(report.get("error").unwrap()[1], -2.5e-300);
let bad_csv = |at: Option<&str>| {
let m = ErrorMatcher::kind(BunsenErrorKind::InvalidResource);
let at = at.map(str::to_string);
m.cause(predicate(
"a series CSV parse error",
move |c: &ParseError| c.what.starts_with("series CSV") && c.at == at,
))
};
bad_csv(None).assert_err(&SeriesReport::from_csv(""));
bad_csv(None).assert_err(&SeriesReport::from_csv("x,y\n"));
bad_csv(Some("row 0")).assert_err(&SeriesReport::from_csv("step,y\n0,abc\n"));
bad_csv(Some("row 0")).assert_err(&SeriesReport::from_csv("step,y\n1,2\n"));
fs::write(&path, "step,y\n0,abc\n").unwrap();
bad_csv(Some("row 0"))
.frame_contains("reading ")
.assert_err(&SeriesReport::read(&path));
ErrorMatcher::kind(BunsenErrorKind::Lookup)
.assert_err(&SeriesReport::read(&dir.path().join("absent.csv")));
}
#[test]
#[should_panic = "column \"b\" has 1 values; \"a\" has 2"]
fn test_series_report_rejects_ragged_columns() {
let _ = SeriesReport::new()
.column("a", vec![1.0, 2.0])
.column("b", vec![1.0]);
}
}