feat(go-runner): remove intermediate walltime result allocations

Author: not-matthias

go-runner/src/lib.rs

@@ -1,4 +1,8 @@
-use crate::{builder::BenchmarkPackage, prelude::*};
+use crate::{
+    builder::BenchmarkPackage,
+    prelude::*,
+    results::{raw_result::RawResult, walltime_results::WalltimeBenchmark},
+};
 use std::{collections::HashMap, path::Path};
 
 pub mod builder;
@@ -74,16 +78,13 @@ pub fn run_benchmarks<P: AsRef<Path>>(
 
 // TODO: This should be merged with codspeed-rust/codspeed/walltime_results.rs
 pub fn collect_walltime_results(profile_dir: &Path) -> anyhow::Result<()> {
-    let raw_results = results::raw_result::RawResult::parse_folder(profile_dir)?;
-    info!("Parsed {} raw results", raw_results.len());
+    let mut benchmarks_by_pid: HashMap<u32, Vec<WalltimeBenchmark>> = HashMap::new();
 
-    let mut benchmarks_by_pid: HashMap<u32, Vec<results::walltime_results::WalltimeBenchmark>> =
-        HashMap::new();
-    for raw in raw_results {
+    for (pid, walltime_result) in RawResult::parse_folder(profile_dir)?.into_iter() {
         benchmarks_by_pid
-            .entry(raw.pid)
+            .entry(pid)
             .or_default()
-            .push(raw.into_walltime_benchmark());
+            .push(walltime_result);
     }
 
     for (pid, walltime_benchmarks) in benchmarks_by_pid {

go-runner/src/results/raw_result.rs

@@ -1,6 +1,5 @@
-use std::path::Path;
-
 use serde::{Deserialize, Serialize};
+use std::path::Path;
 
 use crate::results::walltime_results::WalltimeBenchmark;
 
@@ -15,41 +14,29 @@ pub struct RawResult {
 }
 
 impl RawResult {
-    pub fn parse(content: &str) -> anyhow::Result<Self> {
-        serde_json::from_str(content)
-            .map_err(|e| anyhow::anyhow!("Failed to parse raw result: {}", e))
-    }
-
-    pub fn parse_folder<P: AsRef<Path>>(folder: P) -> anyhow::Result<Vec<Self>> {
+    pub fn parse_folder<P: AsRef<Path>>(
+        folder: P,
+    ) -> anyhow::Result<Vec<(u32, WalltimeBenchmark)>> {
         let glob_pattern = folder.as_ref().join("raw_results").join("*.json");
-        Ok(glob::glob(&glob_pattern.to_string_lossy())?
+        let result = glob::glob(&glob_pattern.to_string_lossy())?
             .filter_map(Result::ok)
             .filter_map(|path| {
-                let content = std::fs::read_to_string(&path).ok()?;
-                Self::parse(&content).ok()
+                let file = std::fs::File::open(&path).ok()?;
+                let reader = std::io::BufReader::new(file);
+                let json: Self = serde_json::from_reader(reader).ok()?;
+                Some((
+                    json.pid,
+                    WalltimeBenchmark::from_runtime_data(
+                        json.name,
+                        json.uri,
+                        &json.codspeed_iters_per_round,
+                        &json.codspeed_time_per_round_ns,
+                        None,
+                    ),
+                ))
             })
-            .collect())
-    }
-
-    pub fn into_walltime_benchmark(self) -> WalltimeBenchmark {
-        let times_per_round_ns = self
-            .codspeed_time_per_round_ns
-            .iter()
-            .map(|t| *t as u128)
-            .collect::<Vec<_>>();
-        let iters_per_round = self
-            .codspeed_iters_per_round
-            .iter()
-            .map(|i| *i as u128)
             .collect();
-
-        WalltimeBenchmark::from_runtime_data(
-            self.name,
-            self.uri,
-            iters_per_round,
-            times_per_round_ns,
-            None,
-        )
+        Ok(result)
     }
 }
 

go-runner/src/results/walltime_results.rs

@@ -54,15 +54,18 @@ impl WalltimeBenchmark {
     pub fn from_runtime_data(
         name: String,
         uri: String,
-        iters_per_round: Vec<u128>,
-        times_per_round_ns: Vec<u128>,
+        iters_per_round: &[u64],
+        times_per_round_ns: &[u64],
         max_time_ns: Option<u128>,
     ) -> Self {
-        let total_time = times_per_round_ns.iter().sum::<u128>() as f64 / 1_000_000_000.0;
+        let total_time =
+            times_per_round_ns.iter().map(|&t| t as u128).sum::<u128>() as f64 / 1_000_000_000.0;
         let time_per_iteration_per_round_ns: Vec<_> = times_per_round_ns
-            .into_iter()
-            .zip(&iters_per_round)
-            .map(|(time_per_round, iter_per_round)| time_per_round / iter_per_round)
+            .iter()
+            .zip(iters_per_round)
+            .map(|(time_per_round, iter_per_round)| {
+                *time_per_round as u128 / *iter_per_round as u128
+            })
             .map(|t| t as f64)
             .collect::<Vec<f64>>();
 
@@ -103,8 +106,8 @@ impl WalltimeBenchmark {
         let max_ns = data.max();
 
         // TODO(COD-1056): We currently only support single iteration count per round
-        let iter_per_round =
-            (iters_per_round.iter().sum::<u128>() / iters_per_round.len() as u128) as u64;
+        let iter_per_round = (iters_per_round.iter().map(|&t| t as u128).sum::<u128>()
+            / iters_per_round.len() as u128) as u64;
         let warmup_iters = 0; // FIXME: add warmup detection
 
         let stats = BenchmarkStats {
@@ -178,8 +181,8 @@ mod tests {
         let benchmark = WalltimeBenchmark::from_runtime_data(
             NAME.to_string(),
             URI.to_string(),
-            vec![1],
-            vec![42],
+            &[1],
+            &[42],
             None,
         );
         assert_eq!(benchmark.stats.stdev_ns, 0.);
@@ -191,13 +194,13 @@ mod tests {
     #[test]
     fn test_parse_bench_with_variable_iterations() {
         let iters_per_round = vec![1, 2, 3, 4, 5, 6];
-        let total_rounds = iters_per_round.iter().sum::<u128>() as f64;
+        let total_rounds = iters_per_round.iter().sum::<u64>() as f64;
 
         let benchmark = WalltimeBenchmark::from_runtime_data(
             NAME.to_string(),
             URI.to_string(),
-            iters_per_round,
-            vec![42, 42 * 2, 42 * 3, 42 * 4, 42 * 5, 42 * 6],
+            &iters_per_round,
+            &[42, 42 * 2, 42 * 3, 42 * 4, 42 * 5, 42 * 6],
             None,
         );