Store already computed compile test cases

Author: Kobzol

Cargo.lock

@@ -11,6 +11,7 @@ anyhow = { workspace = true }
 chrono = { workspace = true, features = ["serde"] }
 clap = { workspace = true, features = ["derive"] }
 env_logger = { workspace = true }
+hashbrown = { workspace = true }
 log = { workspace = true }
 reqwest = { workspace = true, features = ["blocking", "json"] }
 serde = { workspace = true, features = ["derive"] }

collector/Cargo.toml

@@ -1819,7 +1819,7 @@ async fn bench_compile(
             tx.conn(),
             benchmark_name,
             &shared.artifact_id,
-            collector.artifact_row_id,
+            collector,
             config.is_self_profile,
         );
         let result = measure(&mut processor).await;

collector/src/bin/collector.rs

@@ -10,6 +10,7 @@ use crate::compile::execute::{
 };
 use crate::toolchain::Toolchain;
 use crate::utils::git::get_rustc_perf_commit;
+use crate::CollectorCtx;
 use anyhow::Context;
 use database::CollectionId;
 use futures::stream::FuturesUnordered;
@@ -42,7 +43,7 @@ pub struct BenchProcessor<'a> {
     benchmark: &'a BenchmarkName,
     conn: &'a mut dyn database::Connection,
     artifact: &'a database::ArtifactId,
-    artifact_row_id: database::ArtifactIdNumber,
+    collector_ctx: &'a CollectorCtx,
     is_first_collection: bool,
     is_self_profile: bool,
     tries: u8,
@@ -54,7 +55,7 @@ impl<'a> BenchProcessor<'a> {
         conn: &'a mut dyn database::Connection,
         benchmark: &'a BenchmarkName,
         artifact: &'a database::ArtifactId,
-        artifact_row_id: database::ArtifactIdNumber,
+        collector_ctx: &'a CollectorCtx,
         is_self_profile: bool,
     ) -> Self {
         // Check we have `perf` or (`xperf.exe` and `tracelog.exe`)  available.
@@ -78,7 +79,7 @@ impl<'a> BenchProcessor<'a> {
             conn,
             benchmark,
             artifact,
-            artifact_row_id,
+            collector_ctx,
             is_first_collection: true,
             is_self_profile,
             tries: 0,
@@ -108,7 +109,7 @@ impl<'a> BenchProcessor<'a> {
         for (stat, value) in stats.iter() {
             buf.push(self.conn.record_statistic(
                 collection,
-                self.artifact_row_id,
+                self.collector_ctx.artifact_row_id,
                 self.benchmark.0.as_str(),
                 profile,
                 scenario,
@@ -123,7 +124,13 @@ impl<'a> BenchProcessor<'a> {
     }
 
     pub async fn measure_rustc(&mut self, toolchain: &Toolchain) -> anyhow::Result<()> {
-        rustc::measure(self.conn, toolchain, self.artifact, self.artifact_row_id).await
+        rustc::measure(
+            self.conn,
+            toolchain,
+            self.artifact,
+            self.collector_ctx.artifact_row_id,
+        )
+        .await
     }
 }
 
@@ -252,7 +259,7 @@ impl Processor for BenchProcessor<'_> {
                     .map(|profile| {
                         self.conn.record_raw_self_profile(
                             profile.collection,
-                            self.artifact_row_id,
+                            self.collector_ctx.artifact_row_id,
                             self.benchmark.0.as_str(),
                             profile.profile,
                             profile.scenario,
@@ -270,7 +277,7 @@ impl Processor for BenchProcessor<'_> {
 
                     // FIXME: Record codegen backend in the self profile name
                     let prefix = PathBuf::from("self-profile")
-                        .join(self.artifact_row_id.0.to_string())
+                        .join(self.collector_ctx.artifact_row_id.0.to_string())
                         .join(self.benchmark.0.as_str())
                         .join(profile.profile.to_string())
                         .join(profile.scenario.to_id());

collector/src/compile/execute/bencher.rs

@@ -17,7 +17,9 @@ pub mod utils;
 
 use crate::compile::benchmark::{Benchmark, BenchmarkName};
 use crate::runtime::{BenchmarkGroup, BenchmarkSuite};
+use database::selector::CompileTestCase;
 use database::{ArtifactId, ArtifactIdNumber, Connection};
+use hashbrown::HashSet;
 use process::Stdio;
 use std::time::{Duration, Instant};
 
@@ -330,13 +332,24 @@ impl CollectorStepBuilder {
             tx.commit().await.unwrap();
             artifact_row_id
         };
-        CollectorCtx { artifact_row_id }
+        // Find out which tests cases were already computed
+        let measured_compile_test_cases = conn
+            .get_compile_test_cases_with_measurements(&artifact_row_id)
+            .await
+            .expect("cannot fetch measured compile test cases from DB");
+
+        CollectorCtx {
+            artifact_row_id,
+            measured_compile_test_cases,
+        }
     }
 }
 
 /// Represents an in-progress run for a given artifact.
 pub struct CollectorCtx {
     pub artifact_row_id: ArtifactIdNumber,
+    /// Which tests cases were already computed **before** this collection began?
+    pub measured_compile_test_cases: HashSet<CompileTestCase>,
 }
 
 impl CollectorCtx {