Add runtime benchmark site query

Author: Kobzol

database/src/lib.rs

@@ -411,6 +411,8 @@ pub struct Index {
     /// Id lookup of compile stat description ids
     /// For legacy reasons called `pstat_series` in the database, and so the name is kept here.
     pstat_series: Indexed<(Benchmark, Profile, Scenario, Metric)>,
+    /// Id lookup of runtime stat description ids
+    runtime_pstat_series: Indexed<(Benchmark, Metric)>,
 }
 
 /// An index lookup
@@ -627,6 +629,15 @@ impl Index {
             .map(|(test_case, &row_id)| (test_case, row_id))
     }
 
+    pub fn runtime_statistic_descriptions(
+        &self,
+    ) -> impl Iterator<Item = (&(Benchmark, Metric), StatisticalDescriptionId)> + '_ {
+        self.runtime_pstat_series
+            .map
+            .iter()
+            .map(|(test_case, &row_id)| (test_case, row_id))
+    }
+
     pub fn artifact_id_for_commit(&self, commit: &str) -> Option<ArtifactId> {
         self.commits()
             .into_iter()

database/src/pool/postgres.rs

@@ -556,6 +556,25 @@ where
                     )
                 })
                 .collect(),
+            runtime_pstat_series: self
+                .conn()
+                .query(
+                    "select id, benchmark, metric from runtime_pstat_series;",
+                    &[],
+                )
+                .await
+                .unwrap()
+                .into_iter()
+                .map(|row| {
+                    (
+                        row.get::<_, i32>(0) as u32,
+                        (
+                            row.get::<_, String>(1).as_str().into(),
+                            row.get::<_, String>(2).as_str().into(),
+                        ),
+                    )
+                })
+                .collect(),
         }
     }
     async fn get_compile_benchmarks(&self) -> Vec<CompileBenchmark> {

database/src/pool/sqlite.rs

@@ -475,28 +475,46 @@ impl Connection for SqliteConnection {
             .unwrap()
             .map(|r| r.unwrap())
             .collect();
+        let pstat_series = self
+            .raw()
+            .prepare("select id, crate, profile, cache, statistic from pstat_series;")
+            .unwrap()
+            .query_map(params![], |row| {
+                Ok((
+                    row.get::<_, i32>(0)? as u32,
+                    (
+                        Benchmark::from(row.get::<_, String>(1)?.as_str()),
+                        Profile::from_str(row.get::<_, String>(2)?.as_str()).unwrap(),
+                        row.get::<_, String>(3)?.as_str().parse().unwrap(),
+                        row.get::<_, String>(4)?.as_str().into(),
+                    ),
+                ))
+            })
+            .unwrap()
+            .map(|r| r.unwrap())
+            .collect();
+        let runtime_pstat_series = self
+            .raw()
+            .prepare("select id, benchmark, metric from runtime_pstat_series;")
+            .unwrap()
+            .query_map(params![], |row| {
+                Ok((
+                    row.get::<_, i32>(0)? as u32,
+                    (
+                        row.get::<_, String>(1)?.as_str().into(),
+                        row.get::<_, String>(2)?.as_str().into(),
+                    ),
+                ))
+            })
+            .unwrap()
+            .map(|r| r.unwrap())
+            .collect();
         Index {
             commits,
             artifacts,
             errors,
-            pstat_series: self
-                .raw()
-                .prepare("select id, crate, profile, cache, statistic from pstat_series;")
-                .unwrap()
-                .query_map(params![], |row| {
-                    Ok((
-                        row.get::<_, i32>(0)? as u32,
-                        (
-                            Benchmark::from(row.get::<_, String>(1)?.as_str()),
-                            Profile::from_str(row.get::<_, String>(2)?.as_str()).unwrap(),
-                            row.get::<_, String>(3)?.as_str().parse().unwrap(),
-                            row.get::<_, String>(4)?.as_str().into(),
-                        ),
-                    ))
-                })
-                .unwrap()
-                .map(|r| r.unwrap())
-                .collect(),
+            pstat_series,
+            runtime_pstat_series,
         }
     }
 

site/src/selector.rs

@@ -189,6 +189,7 @@ pub trait BenchmarkQuery: Debug {
     ) -> Vec<(Self::TestCase, database::Metric, u32)>;
 }
 
+// Compile benchmarks querying
 #[derive(Clone, Hash, Eq, PartialEq, Debug)]
 pub struct CompileBenchmarkQuery {
     benchmark: Selector<String>,
@@ -278,6 +279,63 @@ pub struct CompileTestCase {
 
 impl TestCase for CompileTestCase {}
 
+// Runtime benchmarks querying
+#[derive(Clone, Hash, Eq, PartialEq, Debug)]
+pub struct RuntimeBenchmarkQuery {
+    benchmark: Selector<String>,
+    metric: Selector<database::Metric>,
+}
+
+impl RuntimeBenchmarkQuery {
+    pub fn benchmark(mut self, selector: Selector<String>) -> Self {
+        self.benchmark = selector;
+        self
+    }
+
+    pub fn metric(mut self, selector: Selector<Metric>) -> Self {
+        self.metric = selector.map(|v| v.as_str().into());
+        self
+    }
+
+    pub fn all_for_metric(metric: Metric) -> Self {
+        Self {
+            benchmark: Selector::All,
+            metric: Selector::One(metric.as_str().into()),
+        }
+    }
+}
+
+impl Default for RuntimeBenchmarkQuery {
+    fn default() -> Self {
+        Self {
+            benchmark: Selector::All,
+            metric: Selector::All,
+        }
+    }
+}
+
+impl BenchmarkQuery for RuntimeBenchmarkQuery {
+    type TestCase = RuntimeTestCase;
+
+    fn get_statistic_descriptions(
+        &self,
+        index: &Index,
+    ) -> Vec<(Self::TestCase, database::Metric, u32)> {
+        index
+            .runtime_statistic_descriptions()
+            .filter(|(&(b, m), _)| self.benchmark.matches(b) && self.metric.matches(m))
+            .map(|(&(benchmark, metric), sid)| (RuntimeTestCase { benchmark }, metric, sid))
+            .collect()
+    }
+}
+
+#[derive(Debug, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
+pub struct RuntimeTestCase {
+    pub benchmark: Benchmark,
+}
+
+impl TestCase for RuntimeTestCase {}
+
 impl SiteCtxt {
     pub async fn statistic_series<Q: BenchmarkQuery>(
         &self,