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, Clone, 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

@@ -1,13 +1,16 @@
-use collector::Bound;
 use std::collections::HashMap;
 use std::sync::Arc;
 
+use collector::Bound;
+
+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;
 
 /// Returns data for a detailed information when comparing a single test result comparison
 /// for a compile-time benchmark.
@@ -23,12 +26,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 +41,53 @@ 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| CompilationSections {
+                sections: profile.compilation_sections,
+            }),
+            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,6 +102,8 @@ pub async fn handle_compile_detail(
     Ok(detail::Response {
         commits: artifact_ids_to_commits(artifact_ids),
         graphs,
+        sections_before,
+        sections_after,
     })
 }
 

site/src/self_profile.rs

@@ -1,9 +1,11 @@
 //! This module handles self-profile "rich" APIs (e.g., chrome profiler JSON)
 //! generation from the raw artifacts on demand.
 
+use crate::api::detail::CompilationSection;
 use crate::api::self_profile::ArtifactSize;
 use crate::api::{self_profile, ServerResult};
 use crate::load::SiteCtxt;
+use analyzeme::ProfilingData;
 use anyhow::Context;
 use bytes::Buf;
 use database::ArtifactId;
@@ -197,6 +199,7 @@ impl SelfProfileCache {
 pub struct SelfProfileWithAnalysis {
     pub profile: self_profile::SelfProfile,
     pub profiling_data: analyzeme::AnalysisResults,
+    pub compilation_sections: Vec<CompilationSection>,
 }
 
 pub(crate) async fn download_and_analyze_self_profile(
@@ -221,15 +224,74 @@ pub(crate) async fn download_and_analyze_self_profile(
                 .map_err(|e| format!("error extracting self profiling data: {}", e))?,
             Err(e) => return Err(format!("could not fetch raw profile data: {e:?}")),
         };
+
+    let compilation_sections = compute_compilation_sections(&profiling_data);
     let profiling_data = profiling_data.perform_analysis();
     let profile =
         get_self_profile_data(metric, &profiling_data).map_err(|e| format!("{}: {}", aid, e))?;
     Ok(SelfProfileWithAnalysis {
         profile,
         profiling_data,
+        compilation_sections,
     })
 }
 
+/// Tries to categorize the duration of three high-level sections of compilation (frontend,
+/// backend, linker) from the self-profile queries.
+fn compute_compilation_sections(profile: &ProfilingData) -> Vec<CompilationSection> {
+    let mut first_event_start = None;
+    let mut frontend_end = None;
+    let mut backend_start = None;
+    let mut backend_end = None;
+    let mut linker_duration = None;
+
+    for event in profile.iter_full() {
+        if first_event_start.is_none() {
+            first_event_start = event.payload.timestamp().map(|t| t.start());
+        }
+
+        if event.label == "analysis" {
+            // End of "analysis" => end of frontend
+            frontend_end = event.payload.timestamp().map(|t| t.end());
+        } else if event.label == "codegen_crate" {
+            // Start of "codegen_crate" => start of backend
+            backend_start = event.payload.timestamp().map(|t| t.start());
+        } else if event.label == "finish_ongoing_codegen" {
+            // End of "finish_ongoing_codegen" => end of backend
+            backend_end = event.payload.timestamp().map(|t| t.end());
+        } else if event.label == "link_crate" {
+            // The "link" query overlaps codegen, so we want to look at the "link_crate" query
+            // instead.
+            linker_duration = event.duration();
+        }
+    }
+    let mut sections = vec![];
+    if let (Some(start), Some(end)) = (first_event_start, frontend_end) {
+        if let Ok(duration) = end.duration_since(start) {
+            sections.push(CompilationSection {
+                name: "Frontend".to_string(),
+                value: duration.as_nanos() as u64,
+            });
+        }
+    }
+    if let (Some(start), Some(end)) = (backend_start, backend_end) {
+        if let Ok(duration) = end.duration_since(start) {
+            sections.push(CompilationSection {
+                name: "Backend".to_string(),
+                value: duration.as_nanos() as u64,
+            });
+        }
+    }
+    if let Some(duration) = linker_duration {
+        sections.push(CompilationSection {
+            name: "Linker".to_string(),
+            value: duration.as_nanos() as u64,
+        });
+    }
+
+    sections
+}
+
 fn get_self_profile_data(
     cpu_clock: Option<f64>,
     profile: &analyzeme::AnalysisResults,