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, 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};
@@ -183,6 +184,17 @@ pub trait Connection: Send + Sync {
     /// Add an item to the `benchmark_requests`, if the `benchmark_request`
     /// exists it will be ignored
     async fn insert_benchmark_request(&self, benchmark_request: &BenchmarkRequest);
+
+    /// 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]
@@ -302,6 +314,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;
 
@@ -424,4 +439,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,12 +1,13 @@
 use crate::pool::{Connection, ConnectionManager, ManagedConnection, Transaction};
+use crate::selector::CompileTestCase;
 use crate::{
     ArtifactCollection, ArtifactId, ArtifactIdNumber, Benchmark, BenchmarkRequest, 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;
@@ -382,6 +383,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> {
@@ -563,7 +565,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,
         }
@@ -1413,6 +1424,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 {

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, BenchmarkRequest, 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;
@@ -1256,6 +1257,33 @@ impl Connection for SqliteConnection {
     async fn insert_benchmark_request(&self, _benchmark_request: &BenchmarkRequest) {
         panic!("Queueing for SQLite has not been implemented, if you are wanting to test the queueing functionality please use postgres. Presuming you have docker installed, at the root of the repo you can run `make start-postgres` to spin up a postgres database.");
     }
+
+    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 {