Add function for finding computed test cases for an artifact

Author: Kobzol

database/src/pool.rs

@@ -1,10 +1,11 @@
+use crate::selector::CompileTestCase;
 use crate::{
     ArtifactCollection, ArtifactId, ArtifactIdNumber, BenchmarkRequest, BenchmarkRequestIndex,
     BenchmarkRequestStatus, CodegenBackend, CompileBenchmark, Target,
 };
 use crate::{CollectionId, Index, Profile, QueuedCommit, Scenario, Step};
 use chrono::{DateTime, Utc};
-use hashbrown::HashMap;
+use hashbrown::{HashMap, HashSet};
 use std::sync::{Arc, Mutex};
 use std::time::Duration;
 use tokio::sync::{OwnedSemaphorePermit, Semaphore};
@@ -220,6 +221,17 @@ pub trait Connection: Send + Sync {
         profile: &Profile,
         benchmark_set: u32,
     ) -> anyhow::Result<()>;
+
+    /// Returns a set of compile-time benchmark test cases that were already computed for the
+    /// given artifact.
+    /// Note that for efficiency reasons, the function only checks if we have at least a single
+    /// result for a given test case. It does not check if *all* test results from all test
+    /// iterations were finished.
+    /// Therefore, the result is an over-approximation.
+    async fn get_compile_test_cases_with_measurements(
+        &self,
+        artifact_row_id: &ArtifactIdNumber,
+    ) -> anyhow::Result<HashSet<CompileTestCase>>;
 }
 
 #[async_trait::async_trait]
@@ -339,6 +351,9 @@ impl Pool {
 
 #[cfg(test)]
 mod tests {
+    use super::*;
+    use crate::metric::Metric;
+    use crate::{tests::run_db_test, Commit, CommitType, Date};
     use chrono::Utc;
     use std::str::FromStr;
 
@@ -625,4 +640,64 @@ mod tests {
         })
         .await;
     }
+
+    #[tokio::test]
+    async fn get_compile_test_cases_with_data() {
+        run_db_test(|ctx| async {
+            let db = ctx.db_client().connection().await;
+
+            let collection = db.collection_id("test").await;
+            let artifact = db
+                .artifact_id(&ArtifactId::Commit(create_commit(
+                    "abcdef",
+                    Utc::now(),
+                    CommitType::Try,
+                )))
+                .await;
+            db.record_compile_benchmark("benchmark", None, "primary".to_string())
+                .await;
+
+            db.record_statistic(
+                collection,
+                artifact,
+                "benchmark",
+                Profile::Check,
+                Scenario::IncrementalFresh,
+                CodegenBackend::Llvm,
+                Target::X86_64UnknownLinuxGnu,
+                Metric::CacheMisses.as_str(),
+                1.0,
+            )
+            .await;
+
+            assert_eq!(
+                db.get_compile_test_cases_with_measurements(&artifact)
+                    .await
+                    .unwrap(),
+                HashSet::from([CompileTestCase {
+                    benchmark: "benchmark".into(),
+                    profile: Profile::Check,
+                    scenario: Scenario::IncrementalFresh,
+                    backend: CodegenBackend::Llvm,
+                    target: Target::X86_64UnknownLinuxGnu,
+                }])
+            );
+
+            let artifact2 = db
+                .artifact_id(&ArtifactId::Commit(create_commit(
+                    "abcdef2",
+                    Utc::now(),
+                    CommitType::Try,
+                )))
+                .await;
+            assert!(db
+                .get_compile_test_cases_with_measurements(&artifact2)
+                .await
+                .unwrap()
+                .is_empty());
+
+            Ok(ctx)
+        })
+        .await;
+    }
 }

database/src/pool/postgres.rs

@@ -1,4 +1,5 @@
 use crate::pool::{Connection, ConnectionManager, ManagedConnection, Transaction};
+use crate::selector::CompileTestCase;
 use crate::{
     ArtifactCollection, ArtifactId, ArtifactIdNumber, Benchmark, BenchmarkJobStatus,
     BenchmarkRequest, BenchmarkRequestIndex, BenchmarkRequestStatus, BenchmarkRequestType,
@@ -442,6 +443,7 @@ pub struct CachedStatements {
     record_artifact_size: Statement,
     get_artifact_size: Statement,
     load_benchmark_request_index: Statement,
+    get_compile_test_cases_with_measurements: Statement,
 }
 
 pub struct PostgresTransaction<'a> {
@@ -629,6 +631,15 @@ impl PostgresConnection {
                     FROM benchmark_request
                     WHERE tag IS NOT NULL
                 ").await.unwrap(),
+                get_compile_test_cases_with_measurements: conn.prepare("
+                    SELECT DISTINCT crate, profile, scenario, backend, target
+                    FROM pstat_series
+                    WHERE id IN (
+                        SELECT DISTINCT series
+                        FROM pstat
+                        WHERE aid = $1
+                    )
+                ").await.unwrap(),
             }),
             conn,
         }
@@ -1680,6 +1691,30 @@ where
             .context("failed to insert benchmark_job")?;
         Ok(())
     }
+
+    async fn get_compile_test_cases_with_measurements(
+        &self,
+        artifact_row_id: &ArtifactIdNumber,
+    ) -> anyhow::Result<HashSet<CompileTestCase>> {
+        let rows = self
+            .conn()
+            .query(
+                &self.statements().get_compile_test_cases_with_measurements,
+                &[&(artifact_row_id.0 as i32)],
+            )
+            .await
+            .context("cannot query compile-time test cases with measurements")?;
+        Ok(rows
+            .into_iter()
+            .map(|row| CompileTestCase {
+                benchmark: Benchmark::from(row.get::<_, &str>(0)),
+                profile: Profile::from_str(row.get::<_, &str>(1)).unwrap(),
+                scenario: row.get::<_, &str>(2).parse().unwrap(),
+                backend: CodegenBackend::from_str(row.get::<_, &str>(3)).unwrap(),
+                target: Target::from_str(row.get::<_, &str>(4)).unwrap(),
+            })
+            .collect())
+    }
 }
 
 fn parse_artifact_id(ty: &str, sha: &str, date: Option<DateTime<Utc>>) -> ArtifactId {

database/src/pool/sqlite.rs

@@ -1,12 +1,13 @@
 use crate::pool::{Connection, ConnectionManager, ManagedConnection, Transaction};
+use crate::selector::CompileTestCase;
 use crate::{
     ArtifactCollection, ArtifactId, Benchmark, BenchmarkRequest, BenchmarkRequestIndex,
     BenchmarkRequestStatus, CodegenBackend, CollectionId, Commit, CommitType, CompileBenchmark,
     Date, Profile, Target,
 };
 use crate::{ArtifactIdNumber, Index, QueuedCommit};
 use chrono::{DateTime, TimeZone, Utc};
-use hashbrown::HashMap;
+use hashbrown::{HashMap, HashSet};
 use rusqlite::params;
 use rusqlite::OptionalExtension;
 use std::path::PathBuf;
@@ -1307,6 +1308,33 @@ impl Connection for SqliteConnection {
     ) -> anyhow::Result<()> {
         no_queue_implementation_abort!()
     }
+
+    async fn get_compile_test_cases_with_measurements(
+        &self,
+        artifact_row_id: &ArtifactIdNumber,
+    ) -> anyhow::Result<HashSet<CompileTestCase>> {
+        Ok(self
+            .raw_ref()
+            .prepare_cached(
+                "SELECT DISTINCT crate, profile, scenario, backend, target
+                FROM pstat_series
+                WHERE id IN (
+                    SELECT DISTINCT series
+                    FROM pstat
+                    WHERE aid = ?
+                );",
+            )?
+            .query_map(params![artifact_row_id.0], |row| {
+                Ok(CompileTestCase {
+                    benchmark: Benchmark::from(row.get::<_, String>(0)?.as_str()),
+                    profile: row.get::<_, String>(1)?.parse().unwrap(),
+                    scenario: row.get::<_, String>(2)?.parse().unwrap(),
+                    backend: row.get::<_, String>(3)?.parse().unwrap(),
+                    target: row.get::<_, String>(4)?.parse().unwrap(),
+                })
+            })?
+            .collect::<Result<_, _>>()?)
+    }
 }
 
 fn parse_artifact_id(ty: &str, sha: &str, date: Option<i64>) -> ArtifactId {