Simplify compile time benchmark querying

Author: Kobzol

site/src/comparison.rs

@@ -6,20 +6,22 @@ use crate::api;
 use crate::db::{ArtifactId, Benchmark, Lookup, Profile, Scenario};
 use crate::github;
 use crate::load::SiteCtxt;
-use crate::selector::{self, Tag};
+use crate::selector::{self};
 
 use collector::benchmark::category::Category;
 use collector::Bound;
 use serde::{Deserialize, Serialize};
 
 use database::CommitType;
+use serde::de::IntoDeserializer;
 use std::cmp;
 use std::collections::{HashMap, HashSet};
 use std::error::Error;
 use std::fmt::Write;
 use std::hash::Hash;
 use std::iter;
 use std::ops::Deref;
+use std::str::FromStr;
 use std::sync::Arc;
 
 type BoxedError = Box<dyn Error + Send + Sync>;
@@ -259,6 +261,15 @@ pub enum Metric {
     DocFilesCount,
 }
 
+impl FromStr for Metric {
+    type Err = String;
+
+    fn from_str(s: &str) -> Result<Self, Self::Err> {
+        Metric::deserialize(s.into_deserializer())
+            .map_err(|e: serde::de::value::Error| format!("Unknown metric `{s}`: {e:?}"))
+    }
+}
+
 impl Metric {
     pub fn as_str(&self) -> &str {
         match self {
@@ -787,15 +798,11 @@ async fn compare_given_commits(
     let aids = Arc::new(vec![a.clone(), b.clone()]);
 
     // get all crates, cache, and profile combinations for the given metric
-    let query = selector::Query::new()
-        .set::<String>(Tag::Benchmark, selector::Selector::All)
-        .set::<String>(Tag::Scenario, selector::Selector::All)
-        .set::<String>(Tag::Profile, selector::Selector::All)
-        .set(Tag::Metric, selector::Selector::One(metric.as_str()));
+    let query = selector::CompileBenchmarkQuery::all_for_metric(metric);
 
     // `responses` contains series iterators. The first element in the iterator is the data
     // for `a` and the second is the data for `b`
-    let mut responses = ctxt.statistic_series(query.clone(), aids).await?;
+    let mut responses = ctxt.compile_statistic_series(query, aids).await?;
 
     let conn = ctxt.conn().await;
     let statistics_for_a = statistics_from_series(&mut responses);
@@ -1072,14 +1079,10 @@ impl HistoricalDataMap {
         }
 
         // get all crates, cache, and profile combinations for the given metric
-        let query = selector::Query::new()
-            .set::<String>(Tag::Benchmark, selector::Selector::All)
-            .set::<String>(Tag::Scenario, selector::Selector::All)
-            .set::<String>(Tag::Profile, selector::Selector::All)
-            .set(Tag::Metric, selector::Selector::One(metric.as_str()));
+        let query = selector::CompileBenchmarkQuery::all_for_metric(metric);
 
         let mut previous_commit_series = ctxt
-            .statistic_series(query, previous_commits.clone())
+            .compile_statistic_series(query, previous_commits.clone())
             .await?;
 
         for _ in previous_commits.iter() {

site/src/request_handlers/dashboard.rs

@@ -6,6 +6,7 @@ use std::path::Path;
 use std::sync::Arc;
 
 use crate::api::{dashboard, ServerResult};
+use crate::comparison::Metric;
 use crate::db::{self, ArtifactId, Profile, Scenario};
 use crate::load::SiteCtxt;
 use crate::selector;
@@ -83,12 +84,9 @@ pub async fn handle_dashboard(ctxt: Arc<SiteCtxt>) -> ServerResult<dashboard::Re
         static ref STABLE_BENCHMARKS: Vec<String> = get_stable_benchmarks();
     }
 
-    let query = selector::Query::new()
-        .set(
-            selector::Tag::Benchmark,
-            selector::Selector::Subset(STABLE_BENCHMARKS.clone()),
-        )
-        .set(selector::Tag::Metric, selector::Selector::One("wall-time"));
+    let query = selector::CompileBenchmarkQuery::new()
+        .benchmark(selector::Selector::Subset(STABLE_BENCHMARKS.clone()))
+        .metric(selector::Selector::One(Metric::WallTime));
 
     let summary_scenarios = ctxt.summary_scenarios();
     let by_profile = ByProfile::new::<String, _, _>(|profile| {
@@ -100,11 +98,11 @@ pub async fn handle_dashboard(ctxt: Arc<SiteCtxt>) -> ServerResult<dashboard::Re
             let mut cases = dashboard::Cases::default();
             for scenario in summary_scenarios.iter() {
                 let responses = ctxt
-                    .statistic_series(
+                    .compile_statistic_series(
                         query
                             .clone()
-                            .set(selector::Tag::Profile, selector::Selector::One(profile))
-                            .set(selector::Tag::Scenario, selector::Selector::One(scenario)),
+                            .profile(selector::Selector::One(profile))
+                            .scenario(selector::Selector::One(*scenario)),
                         aids.clone(),
                     )
                     .await?;

site/src/request_handlers/graph.rs

@@ -7,7 +7,7 @@ use crate::api::{graph, graphs, ServerResult};
 use crate::db::{self, ArtifactId, Benchmark, Profile, Scenario};
 use crate::interpolate::IsInterpolated;
 use crate::load::SiteCtxt;
-use crate::selector::{Query, Selector, SeriesResponse, Tag};
+use crate::selector::{CompileBenchmarkQuery, Selector, SeriesResponse};
 
 pub async fn handle_graph(
     request: graph::Request,
@@ -57,12 +57,12 @@ async fn create_graph(
 ) -> ServerResult<graph::Response> {
     let artifact_ids = artifact_ids_for_range(&ctxt, request.start, request.end);
     let mut series_iterator = ctxt
-        .statistic_series(
-            Query::new()
-                .set::<String>(Tag::Benchmark, Selector::One(request.benchmark))
-                .set::<String>(Tag::Profile, Selector::One(request.profile))
-                .set::<String>(Tag::Scenario, Selector::One(request.scenario))
-                .set::<String>(Tag::Metric, Selector::One(request.metric)),
+        .compile_statistic_series(
+            CompileBenchmarkQuery::new()
+                .benchmark(Selector::One(request.benchmark))
+                .profile(Selector::One(request.profile.parse()?))
+                .scenario(Selector::One(request.scenario.parse()?))
+                .metric(Selector::One(request.metric.parse()?)),
             Arc::new(artifact_ids),
         )
         .await?
@@ -95,16 +95,17 @@ async fn create_graphs(
     };
 
     let benchmark_selector = create_selector(&request.benchmark);
-    let profile_selector = create_selector(&request.profile);
-    let scenario_selector = create_selector(&request.scenario);
+    let profile_selector = create_selector(&request.profile).try_map(|v| v.parse::<Profile>())?;
+    let scenario_selector =
+        create_selector(&request.scenario).try_map(|v| v.parse::<Scenario>())?;
 
     let interpolated_responses: Vec<_> = ctxt
-        .statistic_series(
-            Query::new()
-                .set::<String>(Tag::Benchmark, benchmark_selector)
-                .set::<String>(Tag::Profile, profile_selector)
-                .set::<String>(Tag::Scenario, scenario_selector)
-                .set::<String>(Tag::Metric, Selector::One(request.stat)),
+        .compile_statistic_series(
+            CompileBenchmarkQuery::new()
+                .benchmark(benchmark_selector)
+                .profile(profile_selector)
+                .scenario(scenario_selector)
+                .metric(Selector::One(request.stat.parse()?)),
             artifact_ids.clone(),
         )
         .await?

site/src/request_handlers/self_profile.rs

@@ -10,9 +10,10 @@ use hyper::StatusCode;
 
 use crate::api::self_profile::{ArtifactSize, ArtifactSizeDelta};
 use crate::api::{self_profile, self_profile_processed, self_profile_raw, ServerResult};
+use crate::comparison::Metric;
 use crate::db::ArtifactId;
 use crate::load::SiteCtxt;
-use crate::selector::{self, Tag};
+use crate::selector::{self};
 use crate::self_profile::{
     extract_profiling_data, fetch_raw_self_profile_data, get_self_profile_raw_data,
 };
@@ -582,17 +583,11 @@ pub async fn handle_self_profile(
         .ok()
         .ok_or("sort_idx needs to be i32".to_string())?;
 
-    let query = selector::Query::new()
-        .set(Tag::Benchmark, selector::Selector::One(bench_name))
-        .set(Tag::Profile, selector::Selector::One(profile))
-        .set(
-            Tag::Scenario,
-            selector::Selector::One(body.scenario.clone()),
-        )
-        .set(
-            Tag::Metric,
-            selector::Selector::One("cpu-clock".to_string()),
-        );
+    let query = selector::CompileBenchmarkQuery::new()
+        .benchmark(selector::Selector::One(bench_name.to_string()))
+        .profile(selector::Selector::One(profile.parse().unwrap()))
+        .scenario(selector::Selector::One(scenario))
+        .metric(selector::Selector::One(Metric::CpuClock));
 
     // Helper for finding an `ArtifactId` based on a commit sha
     let find_aid = |commit: &str| {
@@ -607,7 +602,9 @@ pub async fn handle_self_profile(
     }
     let commits = Arc::new(commits);
 
-    let mut cpu_responses = ctxt.statistic_series(query, commits.clone()).await?;
+    let mut cpu_responses = ctxt
+        .compile_statistic_series(query, commits.clone())
+        .await?;
     assert_eq!(cpu_responses.len(), 1, "all selectors are exact");
     let mut cpu_response = cpu_responses.remove(0).series;