feat(y-octo): import y-octo monorepo (#11750)

packages/common/y-octo/utils/bin/bench_result_render.rs

@@ -0,0 +1,134 @@
+use std::{
+  collections::HashMap,
+  io::{self, BufRead},
+};
+
+fn process_duration(duration: &str) -> Option<(f64, f64)> {
+  let dur_split: Vec<String> = duration.split('±').map(String::from).collect();
+  if dur_split.len() != 2 {
+    return None;
+  }
+  let units = dur_split[1]
+    .chars()
+    .skip_while(|c| c.is_ascii_digit())
+    .collect::<String>();
+  let dur_secs = dur_split[0].parse::<f64>().ok()?;
+  let error_secs = dur_split[1]
+    .chars()
+    .take_while(|c| c.is_ascii_digit())
+    .collect::<String>()
+    .parse::<f64>()
+    .ok()?;
+  Some((
+    convert_dur_to_seconds(dur_secs, &units),
+    convert_dur_to_seconds(error_secs, &units),
+  ))
+}
+
+fn convert_dur_to_seconds(dur: f64, units: &str) -> f64 {
+  let factors: HashMap<_, _> = [
+    ("s", 1.0),
+    ("ms", 1.0 / 1000.0),
+    ("µs", 1.0 / 1_000_000.0),
+    ("ns", 1.0 / 1_000_000_000.0),
+  ]
+  .iter()
+  .cloned()
+  .collect();
+  dur * factors.get(units).unwrap_or(&1.0)
+}
+
+fn is_significant(changes_dur: f64, changes_err: f64, base_dur: f64, base_err: f64) -> bool {
+  if changes_dur < base_dur {
+    changes_dur + changes_err < base_dur || base_dur - base_err > changes_dur
+  } else {
+    changes_dur - changes_err > base_dur || base_dur + base_err < changes_dur
+  }
+}
+
+fn convert_to_markdown() -> impl Iterator<Item = String> {
+  #[cfg(feature = "bench")]
+  let re = regex::Regex::new(r"\s{2,}").unwrap();
+  io::stdin()
+    .lock()
+    .lines()
+    .skip(2)
+    .flat_map(move |row| {
+      if let Ok(_row) = row {
+        let columns = {
+          #[cfg(feature = "bench")]
+          {
+            re.split(&_row).collect::<Vec<_>>()
+          }
+          #[cfg(not(feature = "bench"))]
+          Vec::<&str>::new()
+        };
+        let name = columns.first()?;
+        let base_duration = columns.get(2)?;
+        let changes_duration = columns.get(5)?;
+        Some((
+          name.to_string(),
+          base_duration.to_string(),
+          changes_duration.to_string(),
+        ))
+      } else {
+        None
+      }
+    })
+    .flat_map(|(name, base_duration, changes_duration)| {
+      let mut difference = "N/A".to_string();
+      let base_undefined = base_duration == "?";
+      let changes_undefined = changes_duration == "?";
+
+      if !base_undefined && !changes_undefined {
+        let (base_dur_secs, base_err_secs) = process_duration(&base_duration)?;
+        let (changes_dur_secs, changes_err_secs) = process_duration(&changes_duration)?;
+
+        let diff = -(1.0 - changes_dur_secs / base_dur_secs) * 100.0;
+        difference = format!("{:+.2}%", diff);
+
+        if is_significant(
+          changes_dur_secs,
+          changes_err_secs,
+          base_dur_secs,
+          base_err_secs,
+        ) {
+          difference = format!("**{}**", difference);
+        }
+      }
+
+      Some(format!(
+        "| {} | {} | {} | {} |",
+        name.replace('|', "\\|"),
+        if base_undefined {
+          "N/A"
+        } else {
+          &base_duration
+        },
+        if changes_undefined {
+          "N/A"
+        } else {
+          &changes_duration
+        },
+        difference
+      ))
+    })
+}
+
+fn main() {
+  let platform = std::env::args().nth(1).expect("Missing platform argument");
+
+  let headers = vec![
+    format!("## Benchmark for {}", platform),
+    "<details>".to_string(),
+    "  <summary>Click to view benchmark</summary>".to_string(),
+    "".to_string(),
+    "| Test | Base | PR | % |".to_string(),
+    "| --- | --- | --- | --- |".to_string(),
+  ];
+
+  for line in headers.into_iter().chain(convert_to_markdown()) {
+    println!("{}", line);
+  }
+  println!("</details>");
+}