Return compilation sections from benchmark detail endpoint

Author: Kobzol

site/src/api.rs

@@ -162,10 +162,21 @@ pub mod detail {
         deserializer.deserialize_str(CommaSeparatedVisitor(Default::default()))
     }
 
-    #[derive(Debug, PartialEq, Clone, Serialize)]
+    /// Counts how much <resource> (time/instructions) was spent in individual compilation sections
+    /// (frontend, backend, linking) during the compilation of a single test case.
+    #[derive(Default, Debug, Serialize)]
+    pub struct CompilationSections {
+        pub frontend: u64,
+        pub backend: u64,
+        pub linker: u64,
+    }
+
+    #[derive(Debug, Serialize)]
     pub struct Response {
         pub commits: Vec<(i64, String)>,
         pub graphs: Vec<Series>,
+        pub sections_before: Option<CompilationSections>,
+        pub sections_after: Option<CompilationSections>,
     }
 }
 

site/src/request_handlers/graph.rs

@@ -2,12 +2,14 @@ use collector::Bound;
 use std::collections::HashMap;
 use std::sync::Arc;
 
+use crate::api::detail::CompilationSections;
 use crate::api::graphs::GraphKind;
 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};
+use crate::self_profile::{download_and_analyze_self_profile, SelfProfileWithAnalysis};
 
 /// Returns data for a detailed information when comparing a single test result comparison
 /// for a compile-time benchmark.
@@ -23,12 +25,13 @@ pub async fn handle_compile_detail(
         request.end,
     ));
 
+    let scenario = request.scenario.parse()?;
     let interpolated_responses: Vec<_> = ctxt
         .statistic_series(
             CompileBenchmarkQuery::default()
-                .benchmark(Selector::One(request.benchmark))
+                .benchmark(Selector::One(request.benchmark.clone()))
                 .profile(Selector::One(request.profile.parse()?))
-                .scenario(Selector::One(request.scenario.parse()?))
+                .scenario(Selector::One(scenario))
                 .metric(Selector::One(request.stat.parse()?)),
             artifact_ids.clone(),
         )
@@ -37,6 +40,46 @@ pub async fn handle_compile_detail(
         .map(|sr| sr.interpolate().map(|series| series.collect::<Vec<_>>()))
         .collect();
 
+    async fn calculate_sections(
+        ctxt: &SiteCtxt,
+        aid: Option<&ArtifactId>,
+        benchmark: &str,
+        profile: &str,
+        scenario: Scenario,
+    ) -> Option<CompilationSections> {
+        match aid {
+            Some(aid) => download_and_analyze_self_profile(
+                ctxt,
+                aid.clone(),
+                benchmark,
+                profile,
+                scenario,
+                None,
+            )
+            .await
+            .ok()
+            .map(|profile| compute_sections(&profile)),
+            None => None,
+        }
+    }
+
+    let sections_before = calculate_sections(
+        &ctxt,
+        artifact_ids.get(0),
+        &request.benchmark,
+        &request.profile,
+        scenario,
+    )
+    .await;
+    let sections_after = calculate_sections(
+        &ctxt,
+        artifact_ids.get(1),
+        &request.benchmark,
+        &request.profile,
+        scenario,
+    )
+    .await;
+
     let mut graphs = Vec::new();
 
     let mut interpolated_responses = interpolated_responses.into_iter();
@@ -51,9 +94,26 @@ pub async fn handle_compile_detail(
     Ok(detail::Response {
         commits: artifact_ids_to_commits(artifact_ids),
         graphs,
+        sections_before,
+        sections_after,
     })
 }
 
+fn compute_sections(profile: &SelfProfileWithAnalysis) -> CompilationSections {
+    let mut sections = CompilationSections::default();
+    for query in &profile.profile.query_data {
+        let query_name = query.label.as_str().to_lowercase();
+        if query_name.contains("link") {
+            sections.linker += query.self_time;
+        } else if query_name.contains("llvm") {
+            sections.backend += query.self_time;
+        } else {
+            sections.frontend += query.self_time;
+        }
+    }
+    sections
+}
+
 pub async fn handle_graphs(
     request: graphs::Request,
     ctxt: Arc<SiteCtxt>,

site/src/self_profile.rs

@@ -172,7 +172,7 @@ pub(crate) async fn download_and_analyze_self_profile(
 ) -> ServerResult<SelfProfileWithAnalysis> {
     let conn = ctxt.conn().await;
     let aids_and_cids = conn
-        .list_self_profile(aid.clone(), benchmark, profile, &scenario.to_id())
+        .list_self_profile(aid.clone(), benchmark, profile, &scenario.to_string())
         .await;
 
     let Some((anum, cid)) = aids_and_cids.first() else {