Generate links to flamegraph and crox

Author: Mark-Simulacrum

Cargo.lock

@@ -42,7 +42,7 @@ bytes = "0.5.6"
 url = "2"
 analyzeme = { git = "https://github.com/rust-lang/measureme" }
 tar = "0.4"
-inferno = { version="0.9.1", default-features = false }
+inferno = { version="0.10", default-features = false }
 mime = "0.3"
 
 [dependencies.collector]

site/Cargo.toml

@@ -14,27 +14,36 @@ type Response = http::Response<hyper::Body>;
 pub mod crox;
 pub mod flamegraph;
 
+pub struct Output {
+    pub data: Vec<u8>,
+    pub filename: &'static str,
+    pub is_download: bool,
+}
+
 pub fn generate(
+    title: &str,
     pieces: Pieces,
     mut params: HashMap<String, String>,
-) -> anyhow::Result<(&'static str, Vec<u8>)> {
+) -> anyhow::Result<Output> {
     let removed = params.remove("type");
     match removed.as_deref() {
         Some("crox") => {
             let opt = serde_json::from_str(&serde_json::to_string(&params).unwrap())
                 .context("crox opts")?;
-            Ok((
-                "chrome_profiler.json",
-                crox::generate(pieces, opt).context("crox")?,
-            ))
+            Ok(Output {
+                filename: "chrome_profiler.json",
+                data: crox::generate(pieces, opt).context("crox")?,
+                is_download: true,
+            })
         }
         Some("flamegraph") => {
             let opt = serde_json::from_str(&serde_json::to_string(&params).unwrap())
                 .context("flame opts")?;
-            Ok((
-                "flamegraph.svg",
-                flamegraph::generate(pieces, opt).context("flame")?,
-            ))
+            Ok(Output {
+                filename: "flamegraph.svg",
+                data: flamegraph::generate(title, pieces, opt).context("flame")?,
+                is_download: false,
+            })
         }
         _ => anyhow::bail!("Unknown type, specify type={crox,flamegraph}"),
     }

site/src/flamegraph.svg

@@ -5,7 +5,7 @@ use inferno::flamegraph::{from_lines, Options as FlamegraphOptions};
 #[derive(serde::Deserialize, Debug)]
 pub struct Opt {}
 
-pub fn generate(pieces: super::Pieces, _: Opt) -> anyhow::Result<Vec<u8>> {
+pub fn generate(title: &str, pieces: super::Pieces, _: Opt) -> anyhow::Result<Vec<u8>> {
     let profiling_data =
         ProfilingData::from_buffers(pieces.string_data, pieces.string_index, pieces.events)
             .map_err(|e| anyhow::format_err!("{:?}", e))?;
@@ -17,6 +17,7 @@ pub fn generate(pieces: super::Pieces, _: Opt) -> anyhow::Result<Vec<u8>> {
 
     let mut file = Vec::new();
     let mut flamegraph_options = FlamegraphOptions::default();
+    flamegraph_options.title = title.to_owned();
 
     from_lines(
         &mut flamegraph_options,

site/src/self_profile.rs

@@ -790,14 +790,15 @@ pub async fn handle_self_profile_processed_download(
     params: HashMap<String, String>,
     data: &InputData,
 ) -> Response {
+    let title = format!("{}: {} {}", body.commit, body.benchmark, body.run_name);
     let start = Instant::now();
     let pieces = match crate::self_profile::get_pieces(body, data).await {
         Ok(v) => v,
         Err(e) => return e,
     };
     log::trace!("got pieces {:?} in {:?}", pieces, start.elapsed());
 
-    let (filename, json) = match crate::self_profile::generate(pieces, params) {
+    let output = match crate::self_profile::generate(&title, pieces, params) {
         Ok(c) => c,
         Err(e) => {
             log::error!("Failed to generate json {:?}", e);
@@ -807,22 +808,24 @@ pub async fn handle_self_profile_processed_download(
         }
     };
     let mut builder = http::Response::builder()
-        .header_typed(if filename.ends_with("json") {
+        .header_typed(if output.filename.ends_with("json") {
             ContentType::json()
         } else {
             ContentType::from("image/svg+xml".parse::<mime::Mime>().unwrap())
         })
         .status(StatusCode::OK);
 
-    builder.headers_mut().unwrap().insert(
-        hyper::header::CONTENT_DISPOSITION,
-        hyper::header::HeaderValue::from_maybe_shared(format!(
-            "attachment; filename=\"{}\"",
-            filename,
-        ))
-        .expect("valid header"),
-    );
-    builder.body(hyper::Body::from(json)).unwrap()
+    if output.is_download {
+        builder.headers_mut().unwrap().insert(
+            hyper::header::CONTENT_DISPOSITION,
+            hyper::header::HeaderValue::from_maybe_shared(format!(
+                "attachment; filename=\"{}\"",
+                output.filename,
+            ))
+            .expect("valid header"),
+        );
+    }
+    builder.body(hyper::Body::from(output.data)).unwrap()
 }
 
 pub async fn handle_self_profile_raw_download(

site/src/self_profile/flamegraph.rs

@@ -127,9 +127,22 @@ <h3 id="title"></h3>
                 let url = dl_url(commit, bench, run);
                 return `<a href="${url}">Download raw results for ${commit.substring(0, 10)}</a>`;
             };
+            let processed_link = (commit, bench, run, ty) => {
+                let url = `/perf/processed-self-profile?commit=${commit}&benchmark=${bench}&run_name=${run}&type=${ty}`;
+                return `<a href="${url}">Download/view ${ty} results for ${commit.substring(0, 10)}</a>`;
+            };
             txt = dl_link(state.commit, state.benchmark, state.run_name);
+            txt += "<br>";
+            txt += processed_link(state.commit, state.benchmark, state.run_name, "flamegraph");
+            txt += "<br>";
+            txt += processed_link(state.commit, state.benchmark, state.run_name, "crox");
             if (state.base_commit) {
+                txt += "<br>";
                 txt += dl_link(state.base_commit, state.benchmark, state.run_name);
+                txt += "<br>";
+                txt += processed_link(state.base_commit, state.benchmark, state.run_name, "flamegraph");
+                txt += "<br>";
+                txt += processed_link(state.base_commit, state.benchmark, state.run_name, "crox");
             }
             document.querySelector("#raw-urls").innerHTML = txt;
             let sort_idx = state.sort_idx;