Add function for finding computed test cases for an artifact

Author: Kobzol

database/src/pool.rs

@@ -1,9 +1,10 @@
+use crate::selector::CompileTestCase;
 use crate::{
     ArtifactCollection, ArtifactId, ArtifactIdNumber, 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};
@@ -178,6 +179,17 @@ pub trait Connection: Send + Sync {
 
     /// Removes all data associated with the given artifact.
     async fn purge_artifact(&self, aid: &ArtifactId);
+
+    /// 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]
@@ -297,11 +309,11 @@ impl Pool {
 
 #[cfg(test)]
 mod tests {
-    use chrono::Utc;
-    use std::str::FromStr;
-
     use super::*;
+    use crate::metric::Metric;
     use crate::{tests::run_db_test, Commit, CommitType, Date};
+    use chrono::Utc;
+    use std::str::FromStr;
 
     /// Create a Commit
     fn create_commit(commit_sha: &str, time: chrono::DateTime<Utc>, r#type: CommitType) -> Commit {
@@ -370,4 +382,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,11 +1,12 @@
 use crate::pool::{Connection, ConnectionManager, ManagedConnection, Transaction};
+use crate::selector::CompileTestCase;
 use crate::{
     ArtifactCollection, ArtifactId, ArtifactIdNumber, Benchmark, CodegenBackend, CollectionId,
     Commit, CommitType, CompileBenchmark, Date, Index, Profile, QueuedCommit, Scenario, Target,
 };
 use anyhow::Context as _;
 use chrono::{DateTime, TimeZone, Utc};
-use hashbrown::HashMap;
+use hashbrown::{HashMap, HashSet};
 use native_tls::{Certificate, TlsConnector};
 use postgres_native_tls::MakeTlsConnector;
 use std::str::FromStr;
@@ -366,6 +367,7 @@ pub struct CachedStatements {
     get_runtime_pstat: Statement,
     record_artifact_size: Statement,
     get_artifact_size: Statement,
+    get_compile_test_cases_with_measurements: Statement,
 }
 
 pub struct PostgresTransaction<'a> {
@@ -547,7 +549,16 @@ impl PostgresConnection {
                 get_artifact_size: conn.prepare("
                     select component, size from artifact_size
                     where aid = $1
-                ").await.unwrap()
+                ").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,
         }
@@ -1365,6 +1376,30 @@ where
             .await
             .unwrap();
     }
+
+    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 {
@@ -1397,4 +1432,7 @@ mod tests {
         let certs = make_certificates().await;
         assert!(!certs.is_empty());
     }
+
+    #[tokio::test]
+    async fn foo() {}
 }

database/src/pool/sqlite.rs

@@ -1,11 +1,12 @@
 use crate::pool::{Connection, ConnectionManager, ManagedConnection, Transaction};
+use crate::selector::CompileTestCase;
 use crate::{
     ArtifactCollection, ArtifactId, Benchmark, 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;
@@ -1252,6 +1253,33 @@ impl Connection for SqliteConnection {
             )
             .unwrap();
     }
+
+    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 {