Implement an twiggy monos for finding monomorphization bloat

Fixes #6

analyze/analyze.rs

@@ -526,3 +526,168 @@ pub fn paths(items: &mut ir::Items, opts: &opt::Paths) -> Result<Box<traits::Emi
 
     Ok(Box::new(paths) as Box<traits::Emit>)
 }
+
+#[derive(Debug)]
+struct Monos {
+    monos: Vec<MonosEntry>,
+}
+
+#[derive(Debug, PartialEq, Eq)]
+struct MonosEntry {
+    generic: String,
+    insts: Vec<ir::Id>,
+    total: u32,
+    approx_potential_savings: u32,
+}
+
+impl PartialOrd for MonosEntry {
+    fn partial_cmp(&self, rhs: &MonosEntry) -> Option<cmp::Ordering> {
+        Some(self.cmp(rhs))
+    }
+}
+
+impl Ord for MonosEntry {
+    fn cmp(&self, rhs: &MonosEntry) -> cmp::Ordering {
+        rhs.approx_potential_savings
+            .cmp(&self.approx_potential_savings)
+            .then(self.insts.cmp(&rhs.insts))
+            .then(self.generic.cmp(&rhs.generic))
+    }
+}
+
+impl traits::Emit for Monos {
+    fn emit_text(&self, items: &ir::Items, dest: &mut io::Write) -> Result<(), traits::Error> {
+        let mut table = Table::with_header(vec![
+            (Align::Right, "Apprx. Bloat Bytes".into()),
+            (Align::Right, "Apprx. Bloat %".into()),
+            (Align::Right, "Bytes".into()),
+            (Align::Right, "%".into()),
+            (Align::Left, "Monomorphizations".to_string()),
+        ]);
+
+        for entry in &self.monos {
+            let total_percent = (f64::from(entry.total)) / (f64::from(items.size())) * 100.0;
+            let approx_potential_savings_percent =
+                (f64::from(entry.approx_potential_savings)) / (f64::from(items.size())) * 100.0;
+            table.add_row(vec![
+                entry.approx_potential_savings.to_string(),
+                format!("{:.2}%", approx_potential_savings_percent),
+                entry.total.to_string(),
+                format!("{:.2}%", total_percent),
+                entry.generic.clone(),
+            ]);
+
+            for &id in &entry.insts {
+                let item = &items[id];
+
+                let size = item.size();
+                let size_percent = (f64::from(size)) / (f64::from(items.size())) * 100.0;
+
+                table.add_row(vec![
+                    "".into(),
+                    "".into(),
+                    size.to_string(),
+                    format!("{:.2}%", size_percent),
+                    format!("    {}", item.name()),
+                ]);
+            }
+        }
+
+        write!(dest, "{}", &table)?;
+        Ok(())
+    }
+
+    fn emit_json(&self, items: &ir::Items, dest: &mut io::Write) -> Result<(), traits::Error> {
+        let mut arr = json::array(dest)?;
+
+        for entry in &self.monos {
+            let mut obj = arr.object()?;
+            obj.field("generic", &entry.generic[..])?;
+
+            obj.field(
+                "approximate_monomorphization_bloat_bytes",
+                entry.approx_potential_savings,
+            )?;
+            let approx_potential_savings_percent =
+                (f64::from(entry.approx_potential_savings)) / (f64::from(items.size())) * 100.0;
+            obj.field(
+                "approximate_monomorphization_bloat_percent",
+                approx_potential_savings_percent,
+            )?;
+
+            obj.field("total_size", entry.total)?;
+            let total_percent = (f64::from(entry.total)) / (f64::from(items.size())) * 100.0;
+            obj.field("total_size_percent", total_percent)?;
+
+            let mut monos = obj.array("monomorphizations")?;
+            for &id in &entry.insts {
+                let item = &items[id];
+
+                let mut obj = monos.object()?;
+                obj.field("name", item.name())?;
+
+                let size = item.size();
+                obj.field("shallow_size", size)?;
+
+                let size_percent = (f64::from(size)) / (f64::from(items.size())) * 100.0;
+                obj.field("shallow_size_percent", size_percent)?;
+            }
+        }
+
+        Ok(())
+    }
+}
+
+/// Find all retaining paths for the given items.
+pub fn monos(items: &mut ir::Items, opts: &opt::Monos) -> Result<Box<traits::Emit>, traits::Error> {
+    let mut monos = BTreeMap::new();
+    for item in items.iter() {
+        if let Some(generic) = item.monomorphization_of() {
+            monos
+                .entry(generic)
+                .or_insert(BTreeSet::new())
+                .insert(item.id());
+        }
+    }
+
+    let mut monos: Vec<_> = monos
+        .into_iter()
+        .filter_map(|(generic, insts)| {
+            if insts.len() <= 1 {
+                return None;
+            }
+
+            let max = insts.iter().map(|id| items[*id].size()).max().unwrap();
+            let total = insts.iter().map(|id| items[*id].size()).sum();
+            let size_per_inst = total / (insts.len() as u32);
+            let approx_potential_savings =
+                cmp::min(size_per_inst * (insts.len() as u32 - 1), total - max);
+
+            let generic = generic.to_string();
+
+            let mut insts: Vec<_> = insts.into_iter().collect();
+            insts.sort_by(|a, b| {
+                let a = &items[*a];
+                let b = &items[*b];
+                b.size().cmp(&a.size())
+            });
+            insts.truncate(if opts.only_generics {
+                0
+            } else {
+                opts.max_monos as usize
+            });
+
+            Some(MonosEntry {
+                generic,
+                insts,
+                total,
+                approx_potential_savings,
+            })
+        })
+        .collect();
+
+    monos.sort();
+    monos.truncate(opts.max_generics as usize);
+
+    Ok(Box::new(Monos { monos }) as Box<traits::Emit>)
+}

ir/ir.rs

@@ -426,6 +426,17 @@ impl Item {
             &self.name
         }
     }
+
+    /// The the name of the generic function that this is a monomorphization of
+    /// (if any).
+    #[inline]
+    pub fn monomorphization_of(&self) -> Option<&str> {
+        if let ItemKind::Code(ref code) = self.kind {
+            code.monomorphization_of()
+        } else {
+            None
+        }
+    }
 }
 
 impl PartialOrd for Item {
@@ -562,7 +573,7 @@ impl Code {
         // If the '<' doesn't come before the '>', then we aren't looking at a
         // generic function instantiation. If there isn't anything proceeding
         // the '<', then we aren't looking at a generic function instantiation
-        // (most likely looking at a trait method's implementation, like
+        // (most likely looking at a Rust trait method's implementation, like
         // `<MyType as SomeTrait>::trait_method()`).
         if close_bracket < open_bracket || open_bracket == 0 {
             return None;

opt/definitions.rs

@@ -25,6 +25,11 @@ pub enum Options {
     /// graph.
     #[structopt(name = "paths")]
     Paths(Paths),
+
+    /// List the generic function monomorphizations that are contributing to
+    /// code bloat.
+    #[structopt(name = "monos")]
+    Monos(Monos),
 }
 
 /// List the top code size offenders in a binary.
@@ -237,3 +242,76 @@ impl Paths {
         self.max_paths = max_paths;
     }
 }
+
+/// List the generic function monomorphizations that are contributing to
+/// code bloat.
+#[derive(Clone, Debug, Default)]
+#[derive(StructOpt)]
+#[wasm_bindgen]
+pub struct Monos {
+    /// The path to the input binary to size profile.
+    #[structopt(parse(from_os_str))]
+    pub input: path::PathBuf,
+
+    /// The destination to write the output to. Defaults to `stdout`.
+    #[structopt(short = "o", default_value = "-")]
+    pub output_destination: OutputDestination,
+
+    /// The format the output should be written in.
+    #[structopt(short = "f", long = "format", default_value = "text")]
+    pub output_format: traits::OutputFormat,
+
+    /// Hide individual monomorphizations and only show the generic functions.
+    #[structopt(short = "g", long = "only-generics")]
+    pub only_generics: bool,
+
+    /// The maximum number of generics to list.
+    #[structopt(short = "m", long = "max-generics", default_value = "10")]
+    pub max_generics: u32,
+
+    /// The maximum number of individual monomorphizations to list for each
+    /// generic function.
+    #[structopt(short = "n", long = "max-monos", default_value = "10")]
+    pub max_monos: u32,
+}
+
+#[wasm_bindgen]
+impl Monos {
+    /// Construct a new, default `Monos`.
+    pub fn new() -> Monos {
+        Monos::default()
+    }
+
+    /// Hide individual monomorphizations and only show the generic functions.
+    pub fn only_generics(&self) -> bool {
+        self.only_generics
+    }
+
+    /// The maximum number of generics to list.
+    pub fn max_generics(&self) -> u32 {
+        self.max_generics
+    }
+
+    /// The maximum number of individual monomorphizations to list for each
+    /// generic function.
+    pub fn max_monos(&self) -> u32 {
+        self.max_monos
+    }
+
+    /// Set whether to hide individual monomorphizations and only show the
+    /// generic functions.
+    pub fn set_only_generics(&mut self, do_it: bool) {
+        self.only_generics = do_it;
+    }
+
+    /// Set the maximum number of generics to list.
+    pub fn set_max_generics(&mut self, max: u32) {
+        self.max_generics = max;
+    }
+
+    /// Set the maximum number of individual monomorphizations to list for each
+    /// generic function.
+    pub fn set_max_monos(&mut self, max: u32) {
+        self.max_monos = max;
+    }
+}

opt/opt.rs

@@ -46,6 +46,7 @@ impl CommonOptions for Options {
             Options::Top(ref top) => top.input(),
             Options::Dominators(ref doms) => doms.input(),
             Options::Paths(ref paths) => paths.input(),
+            Options::Monos(ref monos) => monos.input(),
         }
     }
 
@@ -54,6 +55,7 @@ impl CommonOptions for Options {
             Options::Top(ref top) => top.output_destination(),
             Options::Dominators(ref doms) => doms.output_destination(),
             Options::Paths(ref paths) => paths.output_destination(),
+            Options::Monos(ref monos) => monos.output_destination(),
         }
     }
 
@@ -62,6 +64,7 @@ impl CommonOptions for Options {
             Options::Top(ref top) => top.output_format(),
             Options::Dominators(ref doms) => doms.output_format(),
             Options::Paths(ref paths) => paths.output_format(),
+            Options::Monos(ref monos) => monos.output_format(),
         }
     }
 }
@@ -108,6 +111,20 @@ impl CommonOptions for Paths {
     }
 }
 
+impl CommonOptions for Monos {
+    fn input(&self) -> &path::Path {
+        &self.input
+    }
+
+    fn output_destination(&self) -> &OutputDestination {
+        &self.output_destination
+    }
+
+    fn output_format(&self) -> traits::OutputFormat {
+        self.output_format
+    }
+}
+
 /// Where to output results.
 #[derive(Clone, Debug)]
 pub enum OutputDestination {

twiggy/tests/expectations/cpp_monos

@@ -0,0 +1,6 @@
+ Apprx. Bloat Bytes │ Apprx. Bloat % │ Bytes │ %     │ Monomorphizations
+────────────────────┼────────────────┼───────┼───────┼─────────────────────────
+                 14 ┊          3.01% ┊    21 ┊ 4.52% ┊ void generic
+                    ┊                ┊     7 ┊ 1.51% ┊     void generic<Zero>()
+                    ┊                ┊     7 ┊ 1.51% ┊     void generic<One>()
+                    ┊                ┊     7 ┊ 1.51% ┊     void generic<Two>()

twiggy/tests/expectations/monos

@@ -0,0 +1,50 @@
+ Apprx. Bloat Bytes │ Apprx. Bloat % │ Bytes │ %     │ Monomorphizations
+────────────────────┼────────────────┼───────┼───────┼────────────────────────────────────────────────────────────────────────────────────────────────────
+               1977 ┊          3.40% ┊  3003 ┊ 5.16% ┊ alloc::slice::merge_sort
+                    ┊                ┊  1026 ┊ 1.76% ┊     alloc::slice::merge_sort::hb3d195f9800bdad6
+                    ┊                ┊  1026 ┊ 1.76% ┊     alloc::slice::merge_sort::hfcf2318d7dc71d03
+                    ┊                ┊   951 ┊ 1.63% ┊     alloc::slice::merge_sort::hcfca67f5c75a52ef
+               1302 ┊          2.24% ┊  3996 ┊ 6.87% ┊ <&'a T as core::fmt::Debug>::fmt
+                    ┊                ┊  2694 ┊ 4.63% ┊     <&'a T as core::fmt::Debug>::fmt::h1c27955d8de3ff17
+                    ┊                ┊   568 ┊ 0.98% ┊     <&'a T as core::fmt::Debug>::fmt::hea6a77c4dcddb7ac
+                    ┊                ┊   433 ┊ 0.74% ┊     <&'a T as core::fmt::Debug>::fmt::hfbacf6f5c9f53bb2
+                    ┊                ┊   301 ┊ 0.52% ┊     <&'a T as core::fmt::Debug>::fmt::h199e8e1c5752e6f1
+                973 ┊          1.67% ┊  1118 ┊ 1.92% ┊ core::result::unwrap_failed
+                    ┊                ┊   145 ┊ 0.25% ┊     core::result::unwrap_failed::h9bd27c3a9ad7c001
+                    ┊                ┊   145 ┊ 0.25% ┊     core::result::unwrap_failed::h4cc73eb9bf19ce32
+                    ┊                ┊   145 ┊ 0.25% ┊     core::result::unwrap_failed::h137aa4f433aba1a9
+                    ┊                ┊   138 ┊ 0.24% ┊     core::result::unwrap_failed::ha3e58cfc7f422ab4
+                    ┊                ┊   138 ┊ 0.24% ┊     core::result::unwrap_failed::h9a7678774db14d67
+                    ┊                ┊   138 ┊ 0.24% ┊     core::result::unwrap_failed::hcb258ce32bda3d85
+                    ┊                ┊   138 ┊ 0.24% ┊     core::result::unwrap_failed::ha7651fcaac40f701
+                    ┊                ┊   131 ┊ 0.23% ┊     core::result::unwrap_failed::hcfddf900474e698a
+                558 ┊          0.96% ┊   714 ┊ 1.23% ┊ <alloc::raw_vec::RawVec<T, A>>::double
+                    ┊                ┊   156 ┊ 0.27% ┊     <alloc::raw_vec::RawVec<T, A>>::double::h28f86621ee2a10aa
+                    ┊                ┊   156 ┊ 0.27% ┊     <alloc::raw_vec::RawVec<T, A>>::double::h956450b93bdc9e1e
+                    ┊                ┊   156 ┊ 0.27% ┊     <alloc::raw_vec::RawVec<T, A>>::double::hcb2fb5861b96a3b0
+                    ┊                ┊   147 ┊ 0.25% ┊     <alloc::raw_vec::RawVec<T, A>>::double::ha715b4e5cc3c60ae
+                    ┊                ┊    99 ┊ 0.17% ┊     <alloc::raw_vec::RawVec<T, A>>::double::h77ff8547127c5db2
+                512 ┊          0.88% ┊   798 ┊ 1.37% ┊ std::thread::local::os::destroy_value
+                    ┊                ┊   286 ┊ 0.49% ┊     std::thread::local::os::destroy_value::hca8124786bee4a79
+                    ┊                ┊   281 ┊ 0.48% ┊     std::thread::local::os::destroy_value::h094cf4f2a025ba2b
+                    ┊                ┊   231 ┊ 0.40% ┊     std::thread::local::os::destroy_value::h453d41f6c315da32
+                234 ┊          0.40% ┊   354 ┊ 0.61% ┊ alloc::slice::insert_head
+                    ┊                ┊   120 ┊ 0.21% ┊     alloc::slice::insert_head::haf6e08236bab8bde
+                    ┊                ┊   120 ┊ 0.21% ┊     alloc::slice::insert_head::h2cdb84a455761146
+                    ┊                ┊   114 ┊ 0.20% ┊     alloc::slice::insert_head::hed0e79da03eeec8b
+                196 ┊          0.34% ┊   294 ┊ 0.51% ┊ <core::fmt::Write::write_fmt::Adapter<'a, T> as core::fmt::Write>::write_fmt
+                    ┊                ┊    98 ┊ 0.17% ┊     <core::fmt::Write::write_fmt::Adapter<'a, T> as core::fmt::Write>::write_fmt::h1b74a5fafe15c8eb
+                    ┊                ┊    98 ┊ 0.17% ┊     <core::fmt::Write::write_fmt::Adapter<'a, T> as core::fmt::Write>::write_fmt::h24034d1c07bfae93
+                    ┊                ┊    98 ┊ 0.17% ┊     <core::fmt::Write::write_fmt::Adapter<'a, T> as core::fmt::Write>::write_fmt::h5ebed3e159974658
+                195 ┊          0.34% ┊   270 ┊ 0.46% ┊ <alloc::vec::Vec<T>>::push
+                    ┊                ┊    75 ┊ 0.13% ┊     <alloc::vec::Vec<T>>::push::h98b02eda22d1ca25
+                    ┊                ┊    66 ┊ 0.11% ┊     <alloc::vec::Vec<T>>::push::hc927b4bedb35b00d
+                    ┊                ┊    66 ┊ 0.11% ┊     <alloc::vec::Vec<T>>::push::h5729b9e7651ef67b
+                    ┊                ┊    63 ┊ 0.11% ┊     <alloc::vec::Vec<T>>::push::h9415ef699ccc65d8
+                119 ┊          0.20% ┊   180 ┊ 0.31% ┊ <core::ops::range::Range<usize> as core::slice::SliceIndex<[T]>>::index_mut
+                    ┊                ┊    61 ┊ 0.10% ┊     <core::ops::range::Range<usize> as core::slice::SliceIndex<[T]>>::index_mut::hba42cce6d0c0099b
+                    ┊                ┊    61 ┊ 0.10% ┊     <core::ops::range::Range<usize> as core::slice::SliceIndex<[T]>>::index_mut::hbf8fcfe76c1f6657
+                    ┊                ┊    58 ┊ 0.10% ┊     <core::ops::range::Range<usize> as core::slice::SliceIndex<[T]>>::index_mut::h1c053f01b6f95d93
+                 95 ┊          0.16% ┊   190 ┊ 0.33% ┊ core::fmt::Write::write_fmt
+                    ┊                ┊    95 ┊ 0.16% ┊     core::fmt::Write::write_fmt::ha5ae3249cacba520
+                    ┊                ┊    95 ┊ 0.16% ┊     core::fmt::Write::write_fmt::hef4632e1398f5ac8

twiggy/tests/expectations/monos_json

@@ -0,0 +1 @@
+[{"generic":"alloc::slice::merge_sort","approximate_monomorphization_bloat_bytes":1977,"approximate_monomorphization_bloat_percent":3.396673768125902,"total_size":3003,"total_size_percent":5.159439213799739,"monomorphizations":[{"name":"alloc::slice::merge_sort::hb3d195f9800bdad6","shallow_size":1026,"shallow_size_percent":1.7627654456738369}]},{"generic":"<&'a T as core::fmt::Debug>::fmt","approximate_monomorphization_bloat_bytes":1302,"approximate_monomorphization_bloat_percent":2.2369596591299565,"total_size":3996,"total_size_percent":6.865507525255995,"monomorphizations":[{"name":"<&'a T as core::fmt::Debug>::fmt::h1c27955d8de3ff17","shallow_size":2694,"shallow_size_percent":4.6285478661260395}]}]

twiggy/tests/expectations/monos_maxes

@@ -0,0 +1,6 @@
+ Apprx. Bloat Bytes │ Apprx. Bloat % │ Bytes │ %     │ Monomorphizations
+────────────────────┼────────────────┼───────┼───────┼────────────────────────────────────────────────────────
+               1977 ┊          3.40% ┊  3003 ┊ 5.16% ┊ alloc::slice::merge_sort
+                    ┊                ┊  1026 ┊ 1.76% ┊     alloc::slice::merge_sort::hb3d195f9800bdad6
+               1302 ┊          2.24% ┊  3996 ┊ 6.87% ┊ <&'a T as core::fmt::Debug>::fmt
+                    ┊                ┊  2694 ┊ 4.63% ┊     <&'a T as core::fmt::Debug>::fmt::h1c27955d8de3ff17