Make backend names in JSON reports match burnbench CLI

- add `config_name`  to `Backend` trait
- add `backend_config_name` to  `Benchmark` trait
- fix documentation for JSON reports to use correct unit of time

backend-comparison/benches/binary.rs

@@ -14,6 +14,10 @@ impl<B: Backend, const D: usize> Benchmark for BinaryBenchmark<B, D> {
  "binary".into()
  }
 
+ fn backend_config_name(&self) -> Option<String> {
+ B::config_name(&self.device)
+ }
+
  fn shapes(&self) -> Vec<Vec<usize>> {
  vec![self.shape.dims.into()]
  }

backend-comparison/benches/custom_gelu.rs

@@ -32,6 +32,10 @@ impl<B: Backend, const D: usize> Benchmark for CustomGeluBenchmark<B, D> {
  }
  }
 
+ fn backend_config_name(&self) -> Option<String> {
+ B::config_name(&self.device)
+ }
+
  fn options(&self) -> Option<String> {
  Some(format!("{:?}", self.kind))
  }

backend-comparison/benches/data.rs

@@ -16,6 +16,10 @@ impl<B: Backend, const D: usize> Benchmark for ToDataBenchmark<B, D> {
  "to_data".into()
  }
 
+ fn backend_config_name(&self) -> Option<String> {
+ B::config_name(&self.device)
+ }
+
  fn shapes(&self) -> Vec<Vec<usize>> {
  vec![self.shape.dims.into()]
  }
@@ -46,6 +50,10 @@ impl<B: Backend, const D: usize> Benchmark for FromDataBenchmark<B, D> {
  "from_data".into()
  }
 
+ fn backend_config_name(&self) -> Option<String> {
+ B::config_name(&self.device)
+ }
+
  fn shapes(&self) -> Vec<Vec<usize>> {
  vec![self.shape.dims.into()]
  }

backend-comparison/benches/matmul.rs

@@ -17,6 +17,10 @@ impl<B: Backend, const D: usize> Benchmark for MatmulBenchmark<B, D> {
  "matmul".into()
  }
 
+ fn backend_config_name(&self) -> Option<String> {
+ B::config_name(&self.device)
+ }
+
  fn shapes(&self) -> Vec<Vec<usize>> {
  vec![self.shape_lhs.dims.into(), self.shape_rhs.dims.into()]
  }

backend-comparison/benches/max_pool2d.rs

@@ -18,6 +18,10 @@ impl<B: Backend> Benchmark for MaxPool2dBenchmark<B> {
  "max_pool2d".into()
  }
 
+ fn backend_config_name(&self) -> Option<String> {
+ B::config_name(&self.device)
+ }
+
  fn shapes(&self) -> Vec<Vec<usize>> {
  vec![self.shape.dims.into()]
  }

backend-comparison/benches/unary.rs

@@ -16,6 +16,10 @@ impl<B: Backend, const D: usize> Benchmark for UnaryBenchmark<B, D> {
  "unary".into()
  }
 
+ fn backend_config_name(&self) -> Option<String> {
+ B::config_name(&self.device)
+ }
+
  fn shapes(&self) -> Vec<Vec<usize>> {
  vec![self.shape.dims.into()]
  }

backend-comparison/src/persistence/base.rs

@@ -28,6 +28,7 @@ pub struct BenchmarkRecord {
 /// [
 /// {
 /// "backend": "backend name",
+/// "backendConfigName": "backend config name as appers in burnbench flag",
 /// "device": "device name",
 /// "gitHash": "hash",
 /// "max": "duration in microseconds",
@@ -68,7 +69,7 @@ pub fn save<B: Backend>(
 
  let records: Vec<BenchmarkRecord> = benches
  .into_iter()
- .map(|bench| BenchmarkRecord {
+ .map(|bench: BenchmarkResult| BenchmarkRecord {
  backend: B::name().to_string(),
  device: format!("{:?}", device),
  system_info: BenchmarkSystemInfo::new(),
@@ -157,6 +158,7 @@ impl Serialize for BenchmarkRecord {
  self,
  ("backend", &self.backend),
  ("device", &self.device),
+ ("backendConfigName", &self.results.backend_config_name),
  ("gitHash", &self.results.git_hash),
  ("max", &self.results.computed.max.as_micros()),
  ("mean", &self.results.computed.mean.as_micros()),
@@ -190,6 +192,7 @@ impl<'de> Visitor<'de> for BenchmarkRecordVisitor {
  match key.as_str() {
  "backend" => br.backend = map.next_value::<String>()?,
  "device" => br.device = map.next_value::<String>()?,
+ "backendConfigName" => br.results.backend_config_name = Some(map.next_value::<String>()?),
  "gitHash" => br.results.git_hash = map.next_value::<String>()?,
  "name" => br.results.name = map.next_value::<String>()?,
  "max" => {
@@ -282,6 +285,7 @@ mod tests {
  let sample_result = r#"{
  "backend": "candle",
  "device": "Cuda(0)",
+ "backendConfigName": "candle-cuda",
  "gitHash": "02d37011ab4dc773286e5983c09cde61f95ba4b5",
  "name": "unary",
  "max": 8858,
@@ -345,6 +349,7 @@ mod tests {
  let record = serde_json::from_str::<BenchmarkRecord>(sample_result).unwrap();
  assert!(record.backend == "candle");
  assert!(record.device == "Cuda(0)");
+ assert!(record.results.backend_config_name == "candle-cuda");
  assert!(record.results.git_hash == "02d37011ab4dc773286e5983c09cde61f95ba4b5");
  assert!(record.results.name == "unary");
  assert!(record.results.computed.max.as_micros() == 8858);

crates/burn-autodiff/src/backend.rs

@@ -39,6 +39,13 @@ impl<B: Backend, C: CheckpointStrategy> Backend for Autodiff<B, C> {
  format!("autodiff<{}>", B::name())
  }
 
+ fn config_name(device: &Self::Device) -> Option<String> {
+ match B::config_name(device) {
+ Some(name) => Some(format!("{}-autodiff", name)),
+ None => None,
+ }
+ }
+
  fn seed(seed: u64) {
  B::seed(seed)
  }

crates/burn-candle/src/backend.rs

@@ -87,6 +87,13 @@ impl<F: FloatCandleElement, I: IntCandleElement> Backend for Candle<F, I> {
  "candle".to_string()
  }
 
+ fn config_name(device: &Self::Device) -> Option<String> {
+ match device {
+ CandleDevice::Cpu => Some(String::from("candle-cpu")),
+ CandleDevice::Cuda(_) | CandleDevice::Metal(_) => Some(String::from("candle-gpu")),
+ }
+ }
+
  fn seed(seed: u64) {
  // TODO submit an issue at Candle
  panic!("Manual seed not supported by Candle. ")

crates/burn-common/src/benchmark.rs

@@ -131,6 +131,10 @@ pub trait Benchmark {
  /// Name of the benchmark, should be short and it should match the name
  /// defined in the crate Cargo.toml
  fn name(&self) -> String;
+
+ /// Name of the backend as appears in burnbench CLI
+ fn backend_config_name(&self) -> Option<String>;
+
  /// The options passed to the benchmark.
  fn options(&self) -> Option<String> {
  None
@@ -185,6 +189,8 @@ pub struct BenchmarkResult {
  pub git_hash: String,
  /// Name of the benchmark
  pub name: String,
+ /// Name of the backend as appears in burnbench CLI
+ pub backend_config_name: Option<String>,
  /// Options passed to the benchmark
  pub options: Option<String>,
  /// Shape dimensions
@@ -230,6 +236,7 @@ where
  computed: BenchmarkComputations::new(&durations),
  git_hash,
  name: benchmark.name(),
+ backend_config_name: benchmark.backend_config_name(),
  options: benchmark.options(),
  shapes: benchmark.shapes(),
  timestamp,

crates/burn-compute/src/tune/tune_benchmark.rs

@@ -34,6 +34,10 @@ impl<S: ComputeServer, C: ComputeChannel<S>> Benchmark for TuneBenchmark<S, C> {
  "autotune".to_string()
  }
 
+ fn backend_config_name(&self) -> Option<String> {
+ None
+ }
+
  fn sync(&self) {
  self.client.sync();
  }

crates/burn-fusion/src/backend.rs

@@ -38,6 +38,13 @@ impl<B: FusionBackend> Backend for Fusion<B> {
  format!("fusion<{}>", B::name())
  }
 
+ fn config_name(device: &Self::Device) -> Option<String> {
+ match B::config_name(device) {
+ Some(name) => Some(format!("{}-fusion", name)),
+ None => None,
+ }
+ }
+
  fn seed(seed: u64) {
  B::seed(seed);
  }

crates/burn-jit/src/backend.rs

@@ -26,6 +26,11 @@ impl<R: Runtime> Backend for JitBackend<R> {
  format!("jit<{}>", R::name())
  }
 
+ fn config_name(_device: &Self::Device) -> Option<String> {
+ // There is currently only one implementation where name returns "wgpu"
+ Some(format!("{}-jit", R::name()))
+ }
+
  fn seed(seed: u64) {
  let rng = StdRng::seed_from_u64(seed);
  let mut seed = SEED.lock().unwrap();

crates/burn-ndarray/src/backend.rs

@@ -21,6 +21,18 @@ impl Default for NdArrayDevice {
  }
 }
 
+fn config_name() -> String {
+ if cfg!(feature = "blas-netlib") {
+ String::from("ndarray-blas-netlib")
+ } else if cfg!(feature = "blas-openblas") {
+ String::from("ndarray-blas-openblas")
+ } else if cfg!(feature = "blas-openblas-system") {
+ String::from("ndarray-blas-openblas-system")
+ } else {
+ String::from("ndarray")
+ }
+}
+
 /// Tensor backend that uses the [ndarray](ndarray) crate for executing tensor operations.
 ///
 /// This backend is compatible with CPUs and can be compiled for almost any platform, including
@@ -50,6 +62,10 @@ impl<E: FloatNdArrayElement> Backend for NdArray<E> {
  String::from("ndarray")
  }
 
+ fn config_name(_: &Self::Device) -> Option<String> {
+ Some(config_name())
+ }
+
  fn seed(seed: u64) {
  let rng = StdRng::seed_from_u64(seed);
  let mut seed = SEED.lock().unwrap();

crates/burn-tch/src/backend.rs

@@ -101,6 +101,15 @@ impl<E: TchElement> Backend for LibTorch<E> {
  "tch".to_string()
  }
 
+ fn config_name(device: &Self::Device) -> Option<String> {
+ match device {
+ LibTorchDevice::Cpu => Some(String::from("tch-cpu")),
+ LibTorchDevice::Cuda(_) | LibTorchDevice::Mps | LibTorchDevice::Vulkan => {
+ Some(String::from("tch-gpu"))
+ }
+ }
+ }
+
  fn sync(device: &Self::Device) {
  if let LibTorchDevice::Cuda(index) = device {
  tch::Cuda::synchronize(*index as i64);

crates/burn-tensor/src/tensor/backend/base.rs

@@ -92,6 +92,9 @@ pub trait Backend:
  /// Name of the backend.
  fn name() -> String;
 
+ /// Name of the backend configuration (i.e. as used in burnbench CLI).
+ fn config_name(device: &Self::Device) -> Option<String>;
+
  /// Seed the backend.
  fn seed(seed: u64);