Handle artifact sizes

Author: rylev

summarize/src/analysis.rs

@@ -1,4 +1,4 @@
-use crate::query_data::{QueryData, Results};
+use crate::query_data::{ArtifactSize, QueryData, Results};
 use analyzeme::{Event, EventPayload, ProfilingData, Timestamp};
 use measureme::rustc::*;
 use rustc_hash::FxHashMap;
@@ -116,6 +116,7 @@ pub fn perform_analysis(data: ProfilingData) -> Results {
     }
 
     let mut query_data = FxHashMap::<String, QueryData>::default();
+    let mut artifact_sizes = Vec::<ArtifactSize>::default();
     let mut threads = FxHashMap::<_, PerThreadState>::default();
 
     let mut record_event_data = |label: &Cow<'_, str>, f: &dyn Fn(&mut QueryData)| {
@@ -252,7 +253,9 @@ pub fn perform_analysis(data: ProfilingData) -> Results {
                 // Bring the stack up-to-date
                 thread.stack.push(current_event)
             }
-            EventPayload::Integer(_) => todo!("Handle integers"),
+            EventPayload::Integer(value) => {
+                artifact_sizes.push(ArtifactSize::new(current_event.label.into_owned(), value))
+            }
         }
     }
 
@@ -263,6 +266,7 @@ pub fn perform_analysis(data: ProfilingData) -> Results {
 
     Results {
         query_data: query_data.drain().map(|(_, value)| value).collect(),
+        artifact_sizes,
         total_time,
     }
 }

summarize/src/diff.rs

@@ -1,19 +1,30 @@
-use crate::query_data::{QueryData, QueryDataDiff, Results};
+use crate::query_data::{ArtifactSize, ArtifactSizeDiff, QueryData, QueryDataDiff, Results};
 use crate::signed_duration::SignedDuration;
 use rustc_hash::{FxHashMap, FxHashSet};
 use serde::{Deserialize, Serialize};
+use std::collections::HashSet;
 use std::time::Duration;
 
 #[derive(Serialize, Deserialize)]
 pub struct DiffResults {
     pub query_data: Vec<QueryDataDiff>,
+    pub artifact_sizes: Vec<ArtifactSizeDiff>,
     pub total_time: SignedDuration,
 }
 
 fn build_query_lookup(query_data: &[QueryData]) -> FxHashMap<&str, usize> {
     let mut lookup = FxHashMap::with_capacity_and_hasher(query_data.len(), Default::default());
-    for i in 0..query_data.len() {
-        lookup.insert(&query_data[i].label[..], i);
+    for (i, data) in query_data.iter().enumerate() {
+        lookup.insert(&data.label[..], i);
+    }
+
+    lookup
+}
+
+fn build_artifact_lookup(artifact_sizes: &[ArtifactSize]) -> FxHashMap<&str, usize> {
+    let mut lookup = FxHashMap::with_capacity_and_hasher(artifact_sizes.len(), Default::default());
+    for (i, data) in artifact_sizes.iter().enumerate() {
+        lookup.insert(&data.label[..], i);
     }
 
     lookup
@@ -53,8 +64,33 @@ pub fn calculate_diff(base: Results, change: Results) -> DiffResults {
 
     query_data.sort_by(|l, r| r.self_time.duration.cmp(&l.self_time.duration));
 
+    let base_data = build_artifact_lookup(&base.artifact_sizes);
+    let change_data = build_artifact_lookup(&change.artifact_sizes);
+    let all_labels = base
+        .artifact_sizes
+        .iter()
+        .chain(&change.artifact_sizes)
+        .map(|a| a.label.as_str())
+        .collect::<HashSet<_>>();
+    let mut artifact_sizes: Vec<_> = all_labels
+        .iter()
+        .map(|l| {
+            let b = base_data.get(l).map(|i| &base.artifact_sizes[*i]);
+            let c = change_data.get(l).map(|i| &change.artifact_sizes[*i]);
+
+            match (b, c) {
+                (Some(b), Some(c)) => c.clone() - b.clone(),
+                (Some(_b), None) => todo!(),
+                (None, Some(_c)) => todo!(),
+                (None, None) => unreachable!(),
+            }
+        })
+        .collect();
+    artifact_sizes.sort_by(|l, r| r.size_change.cmp(&l.size_change));
+
     DiffResults {
         query_data,
+        artifact_sizes,
         total_time: sd(change.total_time) - sd(base.total_time),
     }
 }

summarize/src/main.rs

@@ -148,6 +148,24 @@ fn diff(opt: DiffOpt) -> Result<(), Box<dyn Error + Send + Sync>> {
 
     println!("Total cpu time: {:?}", results.total_time);
 
+    let mut table = Table::new();
+
+    table.add_row(row!("Item", "Artifact Size Change",));
+
+    for artifact_size in results.artifact_sizes {
+        let exclude = opt.exclude.iter().any(|e| artifact_size.label.contains(e));
+        if exclude {
+            continue;
+        }
+
+        table.add_row(row![
+            artifact_size.label,
+            format!("{:.2?} bytes", artifact_size.size_change),
+        ]);
+    }
+
+    table.printstd();
+
     Ok(())
 }
 
@@ -281,6 +299,19 @@ fn summarize(opt: SummarizeOpt) -> Result<(), Box<dyn Error + Send + Sync>> {
         );
     }
 
+    let mut table = Table::new();
+
+    table.add_row(row!("Item", "Artifact Size",));
+
+    for artifact_size in results.artifact_sizes {
+        table.add_row(row![
+            artifact_size.label,
+            format!("{:.2?} bytes", artifact_size.value),
+        ]);
+    }
+
+    table.printstd();
+
     Ok(())
 }
 

summarize/src/query_data.rs

@@ -125,6 +125,7 @@ fn percentage_change(base: Duration, change: Duration) -> f64 {
 #[derive(Serialize, Deserialize)]
 pub struct Results {
     pub query_data: Vec<QueryData>,
+    pub artifact_sizes: Vec<ArtifactSize>,
     pub total_time: Duration,
 }
 
@@ -135,3 +136,32 @@ impl Results {
         self.query_data.iter().find(|qd| qd.label == label).unwrap()
     }
 }
+
+#[derive(Serialize, Deserialize, Debug, Clone)]
+pub struct ArtifactSize {
+    pub label: String,
+    pub value: u64,
+}
+
+impl ArtifactSize {
+    pub fn new(label: String, value: u64) -> Self {
+        Self { label, value }
+    }
+}
+
+#[derive(Serialize, Deserialize, Debug)]
+pub struct ArtifactSizeDiff {
+    pub label: String,
+    pub size_change: i64,
+}
+
+impl Sub for ArtifactSize {
+    type Output = ArtifactSizeDiff;
+
+    fn sub(self, rhs: ArtifactSize) -> ArtifactSizeDiff {
+        ArtifactSizeDiff {
+            label: self.label,
+            size_change: self.value as i64 - rhs.value as i64,
+        }
+    }
+}