Merge pull request #1087 from rylev/self-profile-artifact-size-on-demand

Fetch self profile data from s3 on demand and parse artifact sizes

Author: rylev

site/src/api.rs

@@ -296,6 +296,7 @@ pub mod self_profile {
     pub struct SelfProfile {
         pub totals: QueryData,
         pub query_data: Vec<QueryData>,
+        pub artifact_sizes: Option<Vec<ArtifactSize>>,
     }
 
     #[derive(Serialize, Deserialize, Clone, Debug)]
@@ -313,10 +314,17 @@ pub mod self_profile {
         pub incremental_load_time: u64,
     }
 
+    #[derive(Serialize, Deserialize, Clone, Debug)]
+    pub struct ArtifactSize {
+        pub label: QueryLabel,
+        pub bytes: u64,
+    }
+
     #[derive(Serialize, Debug, Clone)]
     pub struct SelfProfileDelta {
         pub totals: QueryDataDelta,
         pub query_data: Vec<QueryDataDelta>,
+        pub artifact_sizes: Vec<ArtifactSizeDelta>,
     }
 
     #[derive(Serialize, Clone, Debug)]
@@ -327,6 +335,11 @@ pub mod self_profile {
         // Nanoseconds
         pub incremental_load_time: i64,
     }
+
+    #[derive(Serialize, Clone, Debug)]
+    pub struct ArtifactSizeDelta {
+        pub bytes: u64,
+    }
 }
 
 pub mod github {

site/src/request_handlers/self_profile.rs

@@ -1,12 +1,14 @@
-use std::collections::HashSet;
+use std::collections::{BTreeMap, HashSet};
 use std::io::Read;
 use std::sync::Arc;
 use std::time::{Duration, Instant};
 
 use bytes::Buf;
+use database::ArtifactIdNumber;
 use headers::{ContentType, Header};
 use hyper::StatusCode;
 
+use crate::api::self_profile::ArtifactSizeDelta;
 use crate::api::{self_profile, self_profile_processed, self_profile_raw, ServerResult};
 use crate::db::ArtifactId;
 use crate::load::SiteCtxt;
@@ -142,6 +144,7 @@ pub async fn handle_self_profile_processed_download(
 fn get_self_profile_data(
     cpu_clock: Option<f64>,
     self_profile: Option<crate::selector::SelfProfileData>,
+    raw_data: Vec<u8>,
 ) -> ServerResult<self_profile::SelfProfile> {
     let profile = self_profile
         .as_ref()
@@ -178,6 +181,7 @@ fn get_self_profile_data(
             .map(|qd| qd.incremental_load_time)
             .sum(),
     };
+    let artifact_sizes = raw_mmprof_data_to_artifact_sizes(raw_data).ok();
     let profile = self_profile::SelfProfile {
         query_data: profile
             .query_data
@@ -195,6 +199,7 @@ fn get_self_profile_data(
             })
             .collect(),
         totals,
+        artifact_sizes,
     };
 
     Ok(profile)
@@ -239,11 +244,11 @@ fn add_uninvoked_base_profile_queries(
 fn get_self_profile_delta(
     profile: &self_profile::SelfProfile,
     base_profile: &Option<self_profile::SelfProfile>,
+    raw_data: Vec<u8>,
+    base_raw_data: Option<Vec<u8>>,
 ) -> Option<self_profile::SelfProfileDelta> {
-    let base_profile = match base_profile.as_ref() {
-        Some(bp) => bp,
-        None => return None,
-    };
+    let base_profile = base_profile.as_ref()?;
+    let base_raw_data = base_raw_data?;
 
     let totals = self_profile::QueryDataDelta {
         self_time: profile.totals.self_time as i64 - base_profile.totals.self_time as i64,
@@ -283,7 +288,21 @@ fn get_self_profile_delta(
         }
     }
 
-    Some(self_profile::SelfProfileDelta { totals, query_data })
+    let first = raw_mmprof_data_to_artifact_sizes(raw_data).unwrap_or_else(|_| Vec::new());
+    let base = raw_mmprof_data_to_artifact_sizes(base_raw_data).unwrap_or_else(|_| Vec::new());
+    let artifact_sizes = first
+        .into_iter()
+        .zip(base.into_iter())
+        .map(|(a1, a2)| ArtifactSizeDelta {
+            bytes: a1.bytes - a2.bytes,
+        })
+        .collect();
+
+    Some(self_profile::SelfProfileDelta {
+        totals,
+        query_data,
+        artifact_sizes,
+    })
 }
 
 fn sort_self_profile(
@@ -489,10 +508,10 @@ pub async fn handle_self_profile_raw(
 ) -> ServerResult<self_profile_raw::Response> {
     log::info!("handle_self_profile_raw({:?})", body);
     let mut it = body.benchmark.rsplitn(2, '-');
-    let bench_ty = it.next().ok_or(format!("no benchmark type"))?;
+    let profile = it.next().ok_or(format!("no benchmark type"))?;
     let bench_name = it.next().ok_or(format!("no benchmark name"))?;
 
-    let cache = body
+    let scenario = body
         .run_name
         .parse::<database::Scenario>()
         .map_err(|e| format!("invalid run name: {:?}", e))?;
@@ -506,7 +525,7 @@ pub async fn handle_self_profile_raw(
                 date: database::Date::empty(),
             }),
             bench_name,
-            bench_ty,
+            profile,
             &body.run_name,
         )
         .await;
@@ -526,20 +545,20 @@ pub async fn handle_self_profile_raw(
         _ => first_cid,
     };
 
+    let cids = aids_and_cids
+        .into_iter()
+        .map(|(_, cid)| cid)
+        .collect::<Vec<_>>();
+
     let url_prefix = format!(
         "https://perf-data.rust-lang.org/self-profile/{}/{}/{}/{}/self-profile-{}",
         aid.0,
         bench_name,
-        bench_ty,
-        cache.to_id(),
+        profile,
+        scenario.to_id(),
         cid,
     );
 
-    let cids = aids_and_cids
-        .into_iter()
-        .map(|(_, cid)| cid)
-        .collect::<Vec<_>>();
-
     return match fetch(&cids, cid, format!("{}.mm_profdata.sz", url_prefix)).await {
         Ok(fetched) => Ok(fetched),
         Err(new_error) => Err(format!("mm_profdata download failed: {:?}", new_error,)),
@@ -570,6 +589,21 @@ pub async fn handle_self_profile_raw(
     }
 }
 
+pub async fn fetch_raw_self_profile_data(
+    aid: ArtifactIdNumber,
+    benchmark: &str,
+    profile: &str,
+    scenario: &str,
+    cid: i32,
+) -> Result<Vec<u8>, Response> {
+    let url = format!(
+        "https://perf-data.rust-lang.org/self-profile/{}/{}/{}/{}/self-profile-{}.mm_profdata.sz",
+        aid.0, benchmark, profile, scenario, cid,
+    );
+
+    get_self_profile_raw_data(&url).await
+}
+
 pub async fn handle_self_profile(
     body: self_profile::Request,
     ctxt: &SiteCtxt,
@@ -653,30 +687,76 @@ pub async fn handle_self_profile(
         .await?;
     assert_eq!(cpu_responses.len(), 1, "all selectors are exact");
     let mut cpu_response = cpu_responses.remove(0).series;
-
+    let mut raw_self_profile_data = Vec::new();
+    let conn = ctxt.conn().await;
+    for commit in commits.iter() {
+        let aids_and_cids = conn
+            .list_self_profile(commit.clone(), bench_name, profile, &body.run_name)
+            .await;
+        if let Some((aid, cid)) = aids_and_cids.first() {
+            match fetch_raw_self_profile_data(*aid, bench_name, profile, &body.run_name, *cid).await
+            {
+                Ok(d) => raw_self_profile_data.push(d),
+                Err(_) => return Err(format!("could not fetch raw profile data")),
+            };
+        }
+    }
+    let raw_data = raw_self_profile_data.remove(0);
     let mut profile = get_self_profile_data(
         cpu_response.next().unwrap().1,
         sp_response.next().unwrap().1,
+        raw_data.clone(),
     )
     .map_err(|e| format!("{}: {}", body.commit, e))?;
-    let base_profile = if body.base_commit.is_some() {
-        Some(
-            get_self_profile_data(
-                cpu_response.next().unwrap().1,
-                sp_response.next().unwrap().1,
-            )
-            .map_err(|e| format!("{}: {}", body.base_commit.as_ref().unwrap(), e))?,
+    let (base_profile, base_raw_data) = if body.base_commit.is_some() {
+        let base_raw_data = raw_self_profile_data.remove(0);
+        let profile = get_self_profile_data(
+            cpu_response.next().unwrap().1,
+            sp_response.next().unwrap().1,
+            base_raw_data.clone(),
         )
+        .map_err(|e| format!("{}: {}", body.base_commit.as_ref().unwrap(), e))?;
+        (Some(profile), Some(base_raw_data))
     } else {
-        None
+        (None, None)
     };
 
     add_uninvoked_base_profile_queries(&mut profile, &base_profile);
-    let mut base_profile_delta = get_self_profile_delta(&profile, &base_profile);
+    let mut base_profile_delta =
+        get_self_profile_delta(&profile, &base_profile, raw_data, base_raw_data);
     sort_self_profile(&mut profile, &mut base_profile_delta, sort_idx);
 
     Ok(self_profile::Response {
         base_profile_delta,
         profile,
     })
 }
+
+fn raw_mmprof_data_to_artifact_sizes(
+    data: Vec<u8>,
+) -> anyhow::Result<Vec<self_profile::ArtifactSize>> {
+    let profiling_data = analyzeme::ProfilingData::from_paged_buffer(data, None)
+        .map_err(|_| anyhow::Error::msg("could not parse profiling data"))?;
+
+    let mut artifact_sizes: BTreeMap<_, u64> = Default::default();
+
+    for event in profiling_data.iter_full() {
+        // TODO: Use constant from measureme::rustc
+        if event.event_kind == "ArtifactSize" {
+            if !event.payload.is_integer() {
+                anyhow::bail!("Found ArtifactSize payload that is not an integer")
+            }
+
+            let bytes = event.payload.integer().unwrap();
+            *artifact_sizes.entry(event.label).or_default() += bytes;
+        }
+    }
+
+    Ok(artifact_sizes
+        .iter()
+        .map(|(k, v)| self_profile::ArtifactSize {
+            label: k[..].into(),
+            bytes: *v,
+        })
+        .collect())
+}

site/static/detailed-query.html

@@ -59,6 +59,14 @@
             border-radius: 3px;
             user-select: all;
         }
+
+        #artifact-table th {
+            text-align: center;
+        }
+
+        #artifact-table td {
+            padding: 0 0 0 20px;
+        }
     </style>
 </head>
 
@@ -70,6 +78,18 @@
     <div id="content">
         <h3 id="title"></h3>
         <div id="raw-urls"></div>
+        <h4>Artifact Size</h4>
+        <table id="artifact-table">
+            <thead>
+                <tr id="table-header">
+                    <th>Artifact</th>
+                    <th>Size</th>
+                    <th>Size delta</th>
+                </tr>
+            </thead>
+            <tbody id="artifact-body">
+            </tbody>
+        </table>
         <p>'Time (%)' is the percentage of the cpu-clock time spent on this query (we do not use
             wall-time as we want to account for parallelism).</p>
         <p>Executions do not include cached executions.</p>
@@ -152,7 +172,7 @@ <h3 id="title"></h3>
             let processed_url = (commit, bench, run, ty) => {
                 return `/perf/processed-self-profile?commit=${commit}&benchmark=${bench}&run_name=${run}&type=${ty}`;
             };
-            let processed_link = (commit, {benchmark, run_name}, ty) => {
+            let processed_link = (commit, { benchmark, run_name }, ty) => {
                 let url = processed_url(commit, benchmark, run_name, ty);
                 return `<a href="${url}">${ty}</a>`;
             };
@@ -313,7 +333,7 @@ <h3 id="title"></h3>
                         fmt_delta(
                             to_seconds(cur.incremental_load_time),
                             to_seconds(delta.incremental_load_time),
-                           false,
+                            false,
                         ),
                         true).classList.add("incr");
                 } else {
@@ -322,6 +342,25 @@ <h3 id="title"></h3>
                 table.appendChild(row);
                 idx += 1;
             }
+
+            let artifactTable = document.getElementById("artifact-body");
+            function td(row, content) {
+                let td = document.createElement("td");
+                td.innerHTML = content;
+                row.appendChild(td);
+                return td;
+            }
+            for (let [idx, element] of data.profile.artifact_sizes.entries()) {
+                let row = document.createElement("tr");
+                const label = td(row, element.label);
+                label.style.textAlign = "center";
+                td(row, element.bytes);
+                if (data.base_profile_delta && data.base_profile_delta.artifact_sizes[idx]) {
+                    td(row, data.base_profile_delta.artifact_sizes[idx].bytes);
+                }
+                artifactTable.appendChild(row);
+                idx += 1;
+            }
         }
 
         function to_object(element) {
@@ -368,4 +407,4 @@ <h3 id="title"></h3>
     </script>
 </body>
 
-</html>
+</html>