Add codegen schedule view

Author: Mark-Simulacrum

site/src/request_handlers/self_profile.rs

@@ -16,42 +16,80 @@ use crate::server::{Request, Response, ResponseHeaders};
 
 pub async fn handle_self_profile_processed_download(
     body: self_profile_raw::Request,
-    params: HashMap<String, String>,
+    mut params: HashMap<String, String>,
     ctxt: &SiteCtxt,
 ) -> http::Response<hyper::Body> {
-    let title = format!(
-        "{}: {} {}",
-        &body.commit[..std::cmp::min(7, body.commit.len())],
-        body.benchmark,
-        body.run_name
-    );
+    let diff_against = params.remove("base_commit");
+    if params
+        .get("type")
+        .map_or(false, |t| t != "codegen-schedule")
+        && diff_against.is_some()
+    {
+        let mut resp = Response::new("Only codegen_schedule supports diffing right now.".into());
+        *resp.status_mut() = StatusCode::BAD_REQUEST;
+        return resp;
+    }
+
+    let title = if let Some(diff_against) = diff_against.as_ref() {
+        format!(
+            "{} vs {}: {} {}",
+            &diff_against[..std::cmp::min(7, diff_against.len())],
+            &body.commit[..std::cmp::min(7, body.commit.len())],
+            body.benchmark,
+            body.run_name
+        )
+    } else {
+        format!(
+            "{}: {} {}",
+            &body.commit[..std::cmp::min(7, body.commit.len())],
+            body.benchmark,
+            body.run_name
+        )
+    };
 
     let start = Instant::now();
 
-    let (url, is_tarball) = match handle_self_profile_raw(body, ctxt).await {
-        Ok(v) => (v.url, v.is_tarball),
+    let base_data = if let Some(diff_against) = diff_against {
+        match handle_self_profile_raw(
+            self_profile_raw::Request {
+                commit: diff_against,
+                benchmark: body.benchmark.clone(),
+                run_name: body.run_name.clone(),
+                cid: None,
+            },
+            ctxt,
+        )
+        .await
+        {
+            Ok(v) => match get_self_profile_raw_data(&v.url).await {
+                Ok(v) => Some(v),
+                Err(e) => return e,
+            },
+            Err(e) => {
+                let mut resp = Response::new(e.into());
+                *resp.status_mut() = StatusCode::BAD_REQUEST;
+                return resp;
+            }
+        }
+    } else {
+        None
+    };
+
+    let data = match handle_self_profile_raw(body, ctxt).await {
+        Ok(v) => match get_self_profile_raw_data(&v.url).await {
+            Ok(v) => v,
+            Err(e) => return e,
+        },
         Err(e) => {
             let mut resp = Response::new(e.into());
             *resp.status_mut() = StatusCode::BAD_REQUEST;
             return resp;
         }
     };
 
-    if is_tarball {
-        let mut resp =
-            Response::new("Processing legacy format self-profile data is not supported".into());
-        *resp.status_mut() = StatusCode::INTERNAL_SERVER_ERROR;
-        return resp;
-    }
-
-    let data = match get_self_profile_raw_data(&url).await {
-        Ok(v) => v,
-        Err(e) => return e,
-    };
-
     log::trace!("got data in {:?}", start.elapsed());
 
-    let output = match crate::self_profile::generate(&title, data, params) {
+    let output = match crate::self_profile::generate(&title, base_data, data, params) {
         Ok(c) => c,
         Err(e) => {
             log::error!("Failed to generate json {:?}", e);
@@ -63,8 +101,12 @@ pub async fn handle_self_profile_processed_download(
     let mut builder = http::Response::builder()
         .header_typed(if output.filename.ends_with("json") {
             ContentType::json()
-        } else {
+        } else if output.filename.ends_with("svg") {
             ContentType::from("image/svg+xml".parse::<mime::Mime>().unwrap())
+        } else if output.filename.ends_with("html") {
+            ContentType::html()
+        } else {
+            unreachable!()
         })
         .status(StatusCode::OK);
 
@@ -507,27 +549,15 @@ pub async fn handle_self_profile_raw(
         .map(|(_, cid)| cid)
         .collect::<Vec<_>>();
 
-    return match fetch(&cids, cid, format!("{}.mm_profdata.sz", url_prefix), false).await {
+    return match fetch(&cids, cid, format!("{}.mm_profdata.sz", url_prefix)).await {
         Ok(fetched) => Ok(fetched),
-        Err(new_error) => {
-            match fetch(&cids, cid, format!("{}.tar.sz", url_prefix), true).await {
-                Ok(fetched) => Ok(fetched),
-                Err(old_error) => {
-                    // Both files failed to fetch; return the errors for both:
-                    Err(format!(
-                        "mm_profdata download failed: {:?}, tarball download failed: {:?}",
-                        new_error, old_error
-                    ))
-                }
-            }
-        }
+        Err(new_error) => Err(format!("mm_profdata download failed: {:?}", new_error,)),
     };
 
     async fn fetch(
         cids: &[i32],
         cid: i32,
         url: String,
-        is_tarball: bool,
     ) -> ServerResult<self_profile_raw::Response> {
         let resp = reqwest::Client::new()
             .head(&url)
@@ -545,7 +575,7 @@ pub async fn handle_self_profile_raw(
             cids: cids.to_vec(),
             cid,
             url,
-            is_tarball,
+            is_tarball: false,
         })
     }
 }

site/src/self_profile.rs

@@ -4,6 +4,7 @@
 use anyhow::Context;
 use std::collections::HashMap;
 
+mod codegen_schedule;
 pub mod crox;
 pub mod flamegraph;
 
@@ -15,6 +16,7 @@ pub struct Output {
 
 pub fn generate(
     title: &str,
+    self_profile_base_data: Option<Vec<u8>>,
     self_profile_data: Vec<u8>,
     mut params: HashMap<String, String>,
 ) -> anyhow::Result<Output> {
@@ -38,6 +40,21 @@ pub fn generate(
                 is_download: false,
             })
         }
-        _ => anyhow::bail!("Unknown type, specify type={crox,flamegraph}"),
+        Some("codegen-schedule") => {
+            let opt =
+                serde_json::from_str(&serde_json::to_string(&params).unwrap()).context("params")?;
+            Ok(Output {
+                filename: "schedule.html",
+                data: codegen_schedule::generate(
+                    title,
+                    self_profile_base_data,
+                    self_profile_data,
+                    opt,
+                )
+                .context("codegen_schedule")?,
+                is_download: false,
+            })
+        }
+        _ => anyhow::bail!("Unknown type, specify type={crox,flamegraph,codegen-schedule}"),
     }
 }

site/src/self_profile/codegen_schedule.html

@@ -0,0 +1,61 @@
+<html>
+    <head>
+        <meta charset="utf-8">
+        <title>{{title}}</title>
+        <script>
+            window.TOTAL_DURATION_BOTH = {{TOTAL_DURATION_BOTH}};
+            window.TOTAL_DURATION_BASE = {{TOTAL_DURATION_BASE}};
+            window.TOTAL_DURATION_NEW = {{TOTAL_DURATION_NEW}};
+            window.BY_THREAD_BASE = {{BY_THREAD_BASE}};
+            window.BY_THREAD = {{BY_THREAD}};
+        </script>
+        <style>
+            .legend {
+                display: inline-block;
+                width: 1em;
+                height: 1em;
+                margin-left: 0.5em;
+            }
+
+            .legend.codegen_module_optimize {
+                background-color: #aa95e8;
+            }
+
+            .legend.codegen_module {
+                background-color: #6adb00;
+            }
+
+            .legend.codegen_module_perform_lto {
+                background-color: #428eff;
+            }
+
+            [mouse-details] {
+                display: none;
+            }
+
+            #prev {
+                display: none;
+            }
+        </style>
+        <script src="../schedule.js"></script>
+    </head>
+    <body>
+        <h3>{{title}}</h3>
+        <p>Full width is {{TOTAL_DURATION_BOTH}}ms</p>
+        <p>Legend:
+            <span class="codegen_module legend"></span> codegen_module (MIR lowering)
+            <span class="codegen_module_optimize legend"></span> codegen_module_optimize (LLVM)
+            <span class="codegen_module_perform_lto legend"></span> codegen_module_perform_lto (LLVM)
+        </p>
+        <canvas id="prev"></canvas>
+        <canvas id="current"></canvas>
+        <div mouse-details class="prev">
+            <p>Details (prev):</p>
+            <p mouse-details-content-js></p>
+        </div>
+        <div mouse-details class="current">
+            <p>Details (current):</p>
+            <p mouse-details-content-js></p>
+        </div>
+    </body>
+</html>

site/src/self_profile/codegen_schedule.rs

@@ -0,0 +1,117 @@
+use analyzeme::ProfilingData;
+use anyhow::Context;
+use hashbrown::HashMap;
+use serde::Serializer;
+use std::convert::TryInto;
+use std::time::Duration;
+
+#[derive(serde::Deserialize, Debug)]
+pub struct Opt {
+    #[serde(default)]
+    force_width: Option<String>,
+}
+
+fn is_interesting(name: &str) -> bool {
+    match name {
+        "codegen_module" | "codegen_module_optimize" | "codegen_module_perform_lto" => true,
+        _ => false,
+    }
+}
+
+fn by_thread(self_profile_data: Vec<u8>) -> anyhow::Result<(u64, HashMap<u32, Vec<Event>>)> {
+    let data = ProfilingData::from_paged_buffer(self_profile_data)
+        .map_err(|e| anyhow::format_err!("{:?}", e))?;
+
+    let mut start = None;
+    for event in data.iter().filter(|e| !e.timestamp.is_instant()) {
+        let full_event = event.to_event();
+        if is_interesting(&full_event.label) {
+            start = Some(event.timestamp.start());
+            break;
+        }
+    }
+    let start = start.ok_or(anyhow::format_err!("no codegen_crate event"))?;
+
+    let mut end = start;
+    let mut by_thread = HashMap::new();
+    for event in data.iter().filter(|e| !e.timestamp.is_instant()) {
+        let full_event = event.to_event();
+
+        if is_interesting(&full_event.label) {
+            by_thread
+                .entry(event.thread_id)
+                .or_insert_with(Vec::new)
+                .push(Event {
+                    name: full_event.label.into(),
+                    start: event.timestamp.start().duration_since(start).unwrap(),
+                    end: event.timestamp.end().duration_since(start).unwrap(),
+                });
+            end = std::cmp::max(end, event.timestamp.end());
+        }
+    }
+
+    Ok((
+        end.duration_since(start).unwrap().as_millis() as u64,
+        by_thread,
+    ))
+}
+
+pub fn generate(
+    title: &str,
+    self_profile_base_data: Option<Vec<u8>>,
+    self_profile_data: Vec<u8>,
+    opt: Opt,
+) -> anyhow::Result<Vec<u8>> {
+    let (total_duration_new, by_thread_new) = by_thread(self_profile_data)?;
+    let mut total_duration = total_duration_new;
+    let prev = if let Some(self_profile_base_data) = self_profile_base_data {
+        let (total_duration_prev, by_thread_prev) = by_thread(self_profile_base_data)?;
+        total_duration = std::cmp::max(total_duration_new, total_duration_prev);
+        Some((total_duration_prev, by_thread_prev))
+    } else {
+        None
+    };
+
+    if let Some(force_width) = opt.force_width {
+        let forced = force_width
+            .parse::<u64>()
+            .context(anyhow::format_err!("{} does not parse", force_width))?;
+        total_duration = std::cmp::max(forced, total_duration);
+    }
+
+    Ok(HTML_TEMPLATE
+        .replace("{{title}}", title)
+        .replace("{{TOTAL_DURATION_BOTH}}", &total_duration.to_string())
+        .replace(
+            "{{TOTAL_DURATION_BASE}}",
+            &prev
+                .as_ref()
+                .map(|p| p.0.to_string())
+                .unwrap_or_else(|| String::from("null")),
+        )
+        .replace("{{TOTAL_DURATION_NEW}}", &total_duration_new.to_string())
+        .replace(
+            "{{BY_THREAD_BASE}}",
+            &serde_json::to_string(&prev.map(|p| p.1)).unwrap(),
+        )
+        .replace(
+            "{{BY_THREAD}}",
+            &serde_json::to_string(&by_thread_new).unwrap(),
+        )
+        .into_bytes())
+}
+
+#[derive(serde::Serialize, Debug)]
+pub struct Event {
+    pub name: String,
+    #[serde(serialize_with = "as_millis")]
+    pub start: std::time::Duration,
+    #[serde(serialize_with = "as_millis")]
+    pub end: std::time::Duration,
+}
+
+fn as_millis<S: Serializer>(d: &Duration, s: S) -> Result<S::Ok, S::Error> {
+    s.serialize_u64(d.as_millis().try_into().unwrap())
+}
+
+static HTML_TEMPLATE: &str = include_str!("codegen_schedule.html");