Add compare compile benchmark detail endpoint

Author: Kobzol

site/src/api.rs

@@ -110,6 +110,62 @@ pub mod graphs {
     }
 }
 
+pub mod detail {
+    use crate::api::graphs::{GraphKind, Series};
+    use collector::Bound;
+    use serde::de::{DeserializeOwned, Error};
+    use serde::{Deserialize, Deserializer, Serialize};
+    use std::fmt::Formatter;
+    use std::marker::PhantomData;
+
+    #[derive(Debug, PartialEq, Clone, Serialize, Deserialize)]
+    pub struct Request {
+        pub start: Bound,
+        pub end: Bound,
+        pub stat: String,
+        pub benchmark: String,
+        pub scenario: String,
+        pub profile: String,
+        #[serde(deserialize_with = "vec_from_comma_separated")]
+        pub kinds: Vec<GraphKind>,
+    }
+
+    // Deserializes a comma separated list of GraphKind values
+    fn vec_from_comma_separated<'de, T: DeserializeOwned, D>(
+        deserializer: D,
+    ) -> Result<Vec<T>, D::Error>
+    where
+        D: Deserializer<'de>,
+    {
+        struct CommaSeparatedVisitor<T>(PhantomData<T>);
+
+        impl<'de, T: DeserializeOwned> serde::de::Visitor<'de> for CommaSeparatedVisitor<T> {
+            type Value = Vec<T>;
+
+            fn expecting(&self, formatter: &mut Formatter) -> std::fmt::Result {
+                formatter.write_str("comma separated list of GraphKind values")
+            }
+
+            fn visit_str<E>(self, v: &str) -> Result<Self::Value, E>
+            where
+                E: Error,
+            {
+                v.split(',')
+                    .map(|v| T::deserialize(serde::de::value::StrDeserializer::new(v)))
+                    .collect::<Result<Vec<T>, _>>()
+            }
+        }
+
+        deserializer.deserialize_str(CommaSeparatedVisitor(Default::default()))
+    }
+
+    #[derive(Debug, PartialEq, Clone, Serialize)]
+    pub struct Response {
+        pub commits: Vec<(i64, String)>,
+        pub graphs: Vec<Series>,
+    }
+}
+
 pub mod bootstrap {
     use collector::Bound;
     use hashbrown::HashMap;

site/src/request_handlers.rs

@@ -9,7 +9,7 @@ mod status_page;
 pub use bootstrap::handle_bootstrap;
 pub use dashboard::handle_dashboard;
 pub use github::handle_github;
-pub use graph::handle_graphs;
+pub use graph::{handle_compile_detail, handle_graphs};
 pub use next_artifact::handle_next_artifact;
 pub use self_profile::{
     handle_self_profile, handle_self_profile_processed_download, handle_self_profile_raw,

site/src/request_handlers/graph.rs

@@ -3,12 +3,57 @@ use std::collections::HashMap;
 use std::sync::Arc;
 
 use crate::api::graphs::GraphKind;
-use crate::api::{graphs, ServerResult};
+use crate::api::{detail, graphs, ServerResult};
 use crate::db::{self, ArtifactId, Profile, Scenario};
 use crate::interpolate::IsInterpolated;
 use crate::load::SiteCtxt;
 use crate::selector::{CompileBenchmarkQuery, CompileTestCase, Selector, SeriesResponse};
 
+/// Returns data for a detailed information when comparing a single test result comparison
+/// for a compile-time benchmark.
+pub async fn handle_compile_detail(
+    request: detail::Request,
+    ctxt: Arc<SiteCtxt>,
+) -> ServerResult<detail::Response> {
+    log::info!("handle_compile_detail({:?})", request);
+
+    let artifact_ids = Arc::new(master_artifact_ids_for_range(
+        &ctxt,
+        request.start,
+        request.end,
+    ));
+
+    let interpolated_responses: Vec<_> = ctxt
+        .statistic_series(
+            CompileBenchmarkQuery::default()
+                .benchmark(Selector::One(request.benchmark))
+                .profile(Selector::One(request.profile.parse()?))
+                .scenario(Selector::One(request.scenario.parse()?))
+                .metric(Selector::One(request.stat.parse()?)),
+            artifact_ids.clone(),
+        )
+        .await?
+        .into_iter()
+        .map(|sr| sr.interpolate().map(|series| series.collect::<Vec<_>>()))
+        .collect();
+
+    let mut graphs = Vec::new();
+
+    let mut interpolated_responses = interpolated_responses.into_iter();
+    if let Some(response) = interpolated_responses.next() {
+        let series = response.series.into_iter().collect::<Vec<_>>();
+        for kind in request.kinds {
+            graphs.push(graph_series(series.clone().into_iter(), kind));
+        }
+    }
+    assert!(interpolated_responses.next().is_none());
+
+    Ok(detail::Response {
+        commits: artifact_ids_to_commits(artifact_ids),
+        graphs,
+    })
+}
+
 pub async fn handle_graphs(
     request: graphs::Request,
     ctxt: Arc<SiteCtxt>,
@@ -33,7 +78,7 @@ pub async fn handle_graphs(
         }
     }
 
-    let resp = create_graphs(request, &ctxt).await?;
+    let resp = Arc::new(create_graphs(request, &ctxt).await?);
 
     if is_default_query {
         ctxt.landing_page.store(Arc::new(Some(resp.clone())));
@@ -45,7 +90,7 @@ pub async fn handle_graphs(
 async fn create_graphs(
     request: graphs::Request,
     ctxt: &SiteCtxt,
-) -> ServerResult<Arc<graphs::Response>> {
+) -> ServerResult<graphs::Response> {
     let artifact_ids = Arc::new(master_artifact_ids_for_range(
         ctxt,
         request.start,
@@ -98,17 +143,21 @@ async fn create_graphs(
             .insert(scenario, graph_series);
     }
 
-    Ok(Arc::new(graphs::Response {
-        commits: Arc::try_unwrap(artifact_ids)
-            .unwrap()
-            .into_iter()
-            .map(|c| match c {
-                ArtifactId::Commit(c) => (c.date.0.timestamp(), c.sha),
-                ArtifactId::Tag(_) => unreachable!(),
-            })
-            .collect(),
+    Ok(graphs::Response {
+        commits: artifact_ids_to_commits(artifact_ids),
         benchmarks,
-    }))
+    })
+}
+
+fn artifact_ids_to_commits(artifact_ids: Arc<Vec<ArtifactId>>) -> Vec<(i64, String)> {
+    Arc::try_unwrap(artifact_ids)
+        .unwrap()
+        .into_iter()
+        .map(|c| match c {
+            ArtifactId::Commit(c) => (c.date.0.timestamp(), c.sha),
+            ArtifactId::Tag(_) => unreachable!(),
+        })
+        .collect()
 }
 
 /// Returns master commit artifact IDs for the given range.

site/src/server.rs

@@ -375,6 +375,14 @@ async fn serve_req(server: Server, req: Request) -> Result<Response, ServerError
                 crate::comparison::handle_triage(input, &ctxt).await,
             ));
         }
+        "/perf/compare-compile-detail" => {
+            let query = check!(parse_query_string(req.uri()));
+            return server
+                .handle_fallible_get_async(&req, &compression, |c| {
+                    request_handlers::handle_compile_detail(query, c)
+                })
+                .await;
+        }
         "/perf/graphs" => {
             let query = check!(parse_query_string(req.uri()));
             return server