Split runtime.rs

Author: Kobzol

collector/src/runtime/benchmark.rs

@@ -0,0 +1,99 @@
+use benchlib::benchmark::passes_filter;
+use cargo_metadata::Message;
+use core::option::Option;
+use core::option::Option::Some;
+use core::result::Result::Ok;
+use std::path::{Path, PathBuf};
+use std::process::Command;
+
+#[derive(Debug)]
+pub struct BenchmarkBinary {
+    pub path: PathBuf,
+    pub benchmark_names: Vec<String>,
+}
+
+impl BenchmarkBinary {
+    pub fn name(&self) -> &str {
+        self.path.file_name().unwrap().to_str().unwrap()
+    }
+}
+
+#[derive(Debug)]
+pub struct BenchmarkDatabase {
+    pub binaries: Vec<BenchmarkBinary>,
+}
+
+impl BenchmarkDatabase {
+    pub fn total_benchmark_count(&self) -> u64 {
+        self.benchmark_names().count() as u64
+    }
+    pub fn filtered_benchmark_count(&self, filter: &BenchmarkFilter) -> u64 {
+        self.benchmark_names()
+            .filter(|benchmark| {
+                passes_filter(
+                    &benchmark,
+                    filter.exclude.as_deref(),
+                    filter.include.as_deref(),
+                )
+            })
+            .count() as u64
+    }
+
+    fn benchmark_names(&self) -> impl Iterator<Item = &str> {
+        self.binaries
+            .iter()
+            .flat_map(|binary| binary.benchmark_names.iter().map(|n| n.as_ref()))
+    }
+}
+
+pub struct BenchmarkFilter {
+    pub exclude: Option<String>,
+    pub include: Option<String>,
+}
+
+impl BenchmarkFilter {
+    pub fn new(exclude: Option<String>, include: Option<String>) -> BenchmarkFilter {
+        Self { exclude, include }
+    }
+}
+
+/// Parse Cargo JSON output and find all compiled binaries.
+/// Then execute each benchmark with the `list-benchmarks` command to find out its benchmark names.
+pub fn discover_benchmarks(cargo_stdout: &[u8]) -> anyhow::Result<BenchmarkDatabase> {
+    let mut binaries = vec![];
+
+    for message in Message::parse_stream(cargo_stdout) {
+        let message = message?;
+        match message {
+            Message::CompilerArtifact(artifact) => {
+                if let Some(ref executable) = artifact.executable {
+                    if artifact.target.kind.iter().any(|k| k == "bin") {
+                        let path = executable.as_std_path().to_path_buf();
+                        let benchmarks = gather_benchmarks(&path).map_err(|err| {
+                            anyhow::anyhow!(
+                                "Cannot gather benchmarks from `{}`: {err:?}",
+                                path.display()
+                            )
+                        })?;
+                        binaries.push(BenchmarkBinary {
+                            path,
+                            benchmark_names: benchmarks,
+                        });
+                    }
+                }
+            }
+            _ => {}
+        }
+    }
+
+    log::debug!("Found binaries: {:?}", binaries);
+
+    Ok(BenchmarkDatabase { binaries })
+}
+
+/// Uses the `list-benchmarks` command from `benchlib` to find the benchmark names from the given
+/// benchmark binary.
+fn gather_benchmarks(binary: &Path) -> anyhow::Result<Vec<String>> {
+    let output = Command::new(binary).arg("list-benchmarks").output()?;
+    Ok(serde_json::from_slice(&output.stdout)?)
+}

collector/src/runtime.rs renamed to collector/src/runtime/mod.rs

@@ -1,62 +1,13 @@
+mod benchmark;
+
 use crate::benchmark::profile::Profile;
 use crate::toolchain::{get_local_toolchain, LocalToolchain};
-use benchlib::benchmark::passes_filter;
 use benchlib::comm::messages::BenchmarkMessage;
-use cargo_metadata::Message;
 use std::io::{BufRead, BufReader};
 use std::path::{Path, PathBuf};
 use std::process::{Command, Stdio};
 
-#[derive(Debug)]
-struct BenchmarkBinary {
-    path: PathBuf,
-    benchmark_names: Vec<String>,
-}
-
-impl BenchmarkBinary {
-    fn name(&self) -> &str {
-        self.path.file_name().unwrap().to_str().unwrap()
-    }
-}
-
-#[derive(Debug)]
-struct BenchmarkDatabase {
-    binaries: Vec<BenchmarkBinary>,
-}
-
-impl BenchmarkDatabase {
-    fn benchmark_names(&self) -> impl Iterator<Item = &str> {
-        self.binaries
-            .iter()
-            .flat_map(|binary| binary.benchmark_names.iter().map(|n| n.as_ref()))
-    }
-
-    fn total_benchmark_count(&self) -> u64 {
-        self.benchmark_names().count() as u64
-    }
-    fn filtered_benchmark_count(&self, filter: &BenchmarkFilter) -> u64 {
-        self.benchmark_names()
-            .filter(|benchmark| {
-                passes_filter(
-                    &benchmark,
-                    filter.exclude.as_deref(),
-                    filter.include.as_deref(),
-                )
-            })
-            .count() as u64
-    }
-}
-
-pub struct BenchmarkFilter {
-    exclude: Option<String>,
-    include: Option<String>,
-}
-
-impl BenchmarkFilter {
-    pub fn new(exclude: Option<String>, include: Option<String>) -> BenchmarkFilter {
-        Self { exclude, include }
-    }
-}
+pub use benchmark::BenchmarkFilter;
 
 /// Perform a series of runtime benchmarks using the provided `rustc` compiler.
 /// The runtime benchmarks are looked up in `benchmark_dir`, which is expected to be a path
@@ -70,7 +21,7 @@ pub fn bench_runtime(
 ) -> anyhow::Result<()> {
     let toolchain = get_local_toolchain(&[Profile::Opt], rustc, None, None, id, "")?;
     let output = compile_runtime_benchmarks(&toolchain, &benchmark_dir)?;
-    let benchmark_db = discover_benchmarks(&output)?;
+    let benchmark_db = benchmark::discover_benchmarks(&output)?;
 
     let total_benchmark_count = benchmark_db.total_benchmark_count();
     let filtered = benchmark_db.filtered_benchmark_count(&filter);
@@ -162,44 +113,3 @@ fn compile_runtime_benchmarks(toolchain: &LocalToolchain, dir: &Path) -> anyhow:
         return Ok(result.stdout);
     }
 }
-
-/// Parse Cargo JSON output and find all compiled binaries.
-/// Then execute each benchmark with the `list-benchmarks` command to find out its benchmark names.
-fn discover_benchmarks(cargo_stdout: &[u8]) -> anyhow::Result<BenchmarkDatabase> {
-    let mut binaries = vec![];
-
-    for message in Message::parse_stream(cargo_stdout) {
-        let message = message?;
-        match message {
-            Message::CompilerArtifact(artifact) => {
-                if let Some(ref executable) = artifact.executable {
-                    if artifact.target.kind.iter().any(|k| k == "bin") {
-                        let path = executable.as_std_path().to_path_buf();
-                        let benchmarks = gather_benchmarks(&path).map_err(|err| {
-                            anyhow::anyhow!(
-                                "Cannot gather benchmarks from `{}`: {err:?}",
-                                path.display()
-                            )
-                        })?;
-                        binaries.push(BenchmarkBinary {
-                            path,
-                            benchmark_names: benchmarks,
-                        });
-                    }
-                }
-            }
-            _ => {}
-        }
-    }
-
-    log::debug!("Found binaries: {:?}", binaries);
-
-    Ok(BenchmarkDatabase { binaries })
-}
-
-/// Uses the `list-benchmarks` command from `benchlib` to find the benchmark names from the given
-/// benchmark binary.
-fn gather_benchmarks(binary: &Path) -> anyhow::Result<Vec<String>> {
-    let output = Command::new(binary).arg("list-benchmarks").output()?;
-    Ok(serde_json::from_slice(&output.stdout)?)
-}