Return compilation sections from benchmark detail endpoint

Author: Kobzol

site/src/api.rs

@@ -159,10 +159,27 @@ pub mod detail {
         deserializer.deserialize_str(CommaSeparatedVisitor(Default::default()))
     }
 
-    #[derive(Debug, PartialEq, Clone, Serialize)]
+    #[derive(Default, Debug, Serialize)]
+    pub struct CompilationSection {
+        pub name: String,
+        // It is unspecified if this is duration, fraction or something else. It should only be
+        // evaluated against the total sum of values.
+        pub value: u64,
+    }
+
+    /// Counts how much <resource> (time/instructions) was spent in individual compilation sections
+    /// (e.g. frontend, backend, linking) during the compilation of a single test case.
+    #[derive(Default, Debug, Serialize)]
+    pub struct CompilationSections {
+        pub sections: Vec<CompilationSection>,
+    }
+
+    #[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::{CompilationSection, 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,51 @@ 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,
+        }
+    }
+
+    // Doc queries are not split into the classic frontend/backend/linker parts.
+    let (sections_before, sections_after) = if request.profile != "doc" {
+        tokio::join!(
+            calculate_sections(
+                &ctxt,
+                artifact_ids.get(0),
+                &request.benchmark,
+                &request.profile,
+                scenario,
+            ),
+            calculate_sections(
+                &ctxt,
+                artifact_ids.get(1),
+                &request.benchmark,
+                &request.profile,
+                scenario,
+            )
+        )
+    } else {
+        (None, None)
+    };
+
     let mut graphs = Vec::new();
 
     let mut interpolated_responses = interpolated_responses.into_iter();
@@ -51,9 +99,64 @@ pub async fn handle_compile_detail(
     Ok(detail::Response {
         commits: artifact_ids_to_commits(artifact_ids),
         graphs,
+        sections_before,
+        sections_after,
     })
 }
 
+/// Heuristically tries to determine which queries belong to individual high-level
+/// "compilation sections" (parsing, analysis, codegen, linker etc.).
+fn compute_sections(profile: &SelfProfileWithAnalysis) -> CompilationSections {
+    let mut parsing = 0;
+    let mut metadata = 0;
+    let mut analysis = 0;
+    let mut codegen = 0;
+    let mut linker = 0;
+
+    for query in &profile.profile.query_data {
+        let query_name = query.label.as_str().to_lowercase();
+        if query_name == "parse_crate" {
+            parsing += query.time;
+        } else if query_name == "resolver_for_lowering" {
+            metadata += query.time;
+        } else if query_name == "analysis" {
+            analysis += query.time;
+        } else if query_name == "link_crate" {
+            // The link query overlaps codegen, so we want to take the duration of the `link_crate`
+            // query instead.
+            linker += query.time;
+        } else if query_name == "codegen_crate" || query_name == "LLVM_passes" {
+            // The codegen is divided between rustc part and codegen backend part.
+            // FIXME: these two queries can overlap, this should be calculated by a better analysis
+            codegen += query.time;
+        }
+    }
+    CompilationSections {
+        sections: vec![
+            CompilationSection {
+                name: "Parsing".to_string(),
+                value: parsing,
+            },
+            CompilationSection {
+                name: "Metadata".to_string(),
+                value: metadata,
+            },
+            CompilationSection {
+                name: "Analysis".to_string(),
+                value: analysis,
+            },
+            CompilationSection {
+                name: "Codegen".to_string(),
+                value: codegen,
+            },
+            CompilationSection {
+                name: "Linker".to_string(),
+                value: linker,
+            },
+        ],
+    }
+}
+
 pub async fn handle_graphs(
     request: graphs::Request,
     ctxt: Arc<SiteCtxt>,