24 |
25 | ## About
26 |
27 | Twiggy is a code size profiler for Wasm. It analyzes a binary's call graph to
28 | answer questions like:
29 |
30 | * Why was this function included in the binary in the first place? Who calls it?
31 |
32 | * What is the *retained size* of this function? I.e. how much space would be
33 | saved if I removed it and all the functions that become dead code after its
34 | removal.
35 |
36 | Use Twiggy to make your binaries slim!
37 |
38 | ## Install Twiggy
39 |
40 | Ensure that you have [the Rust toolchain installed](https://www.rust-lang.org/),
41 | then run:
42 |
43 | ```
44 | cargo install twiggy
45 | ```
46 |
47 | ## Learn More!
48 |
49 | [**Read the Twiggy guide!**](https://rustwasm.github.io/twiggy)
50 |
51 |
52 |
53 |
54 |
--------------------------------------------------------------------------------
/_travis.yml:
--------------------------------------------------------------------------------
1 | language: rust
2 | cache: cargo
3 |
4 | rust:
5 | - stable
6 | - beta
7 | - nightly
8 |
9 | env:
10 | matrix:
11 | - JOB="test"
12 |
13 | matrix:
14 | fast_finish: true
15 | include:
16 | - rust: nightly
17 | env: JOB="wasm"
18 | # Build and deploy the mdbook guide.
19 | - rust: stable
20 | env: JOB="guide"
21 | before_script:
22 | - (test -x $HOME/.cargo/bin/cargo-install-update || cargo install cargo-update)
23 | - (test -x $HOME/.cargo/bin/mdbook || cargo install --vers "^0.2" mdbook)
24 | - cargo install-update -a
25 | script:
26 | - cd guide && mdbook build
27 | deploy:
28 | provider: pages
29 | skip-cleanup: true
30 | github-token: $GITHUB_TOKEN
31 | local-dir: guide/book
32 | keep-history: false
33 | on:
34 | branch: master
35 | - rust: stable
36 | env: JOB="format"
37 | before_script:
38 | - rustup component add rustfmt --toolchain stable
39 | script:
40 | - cargo fmt -- --check
41 | - rust: stable
42 | env: JOB="lint"
43 | before_script:
44 | - rustup component add clippy --toolchain stable
45 | script:
46 | - cargo clippy -- -D warnings
47 | allow_failures:
48 | - rust: stable
49 | env: JOB="lint"
50 |
51 | script:
52 | - ./ci/script.sh
53 |
--------------------------------------------------------------------------------
/analyze/Cargo.toml:
--------------------------------------------------------------------------------
1 | [package]
2 | authors = ["Nick Fitzgerald "]
3 | categories = []
4 | description = "Analyses for the Twiggy code size profiler."
5 | license = "Apache-2.0/MIT"
6 | name = "twiggy-analyze"
7 | readme = "../README.md"
8 | repository = "https://github.com/rustwasm/twiggy"
9 | version = "0.7.0"
10 | edition = "2018"
11 |
12 | [lib]
13 | path = "./analyze.rs"
14 |
15 | [dependencies]
16 | anyhow = "1.0"
17 | twiggy-ir = { version = "=0.7.0", path = "../ir" }
18 | twiggy-opt = { version = "=0.7.0", path = "../opt", default-features = false }
19 | twiggy-traits = { version = "=0.7.0", path = "../traits" }
20 | csv = "1.2.2"
21 | regex = "1.4.2"
22 | serde = "1.0"
23 | serde_derive = "1.0"
24 | petgraph = "0.6.2"
25 |
26 | [features]
27 | default = ["emit_csv", "emit_json", "emit_text"]
28 | emit_json = ["twiggy-traits/emit_json"]
29 | emit_csv = ["twiggy-traits/emit_csv"]
30 | emit_text = ["twiggy-traits/emit_text"]
31 |
--------------------------------------------------------------------------------
/analyze/analyses/dominators/mod.rs:
--------------------------------------------------------------------------------
1 | use std::collections::BTreeMap;
2 |
3 | use regex;
4 |
5 | use twiggy_ir as ir;
6 | use twiggy_opt as opt;
7 | use twiggy_traits as traits;
8 |
9 | use crate::analyses::garbage;
10 |
11 | mod emit;
12 |
13 | struct DominatorTree {
14 | tree: BTreeMap>,
15 | items: Vec,
16 | opts: opt::Dominators,
17 | unreachable_items_summary: Option,
18 | }
19 |
20 | struct UnreachableItemsSummary {
21 | count: usize,
22 | size: u32,
23 | size_percent: f64,
24 | }
25 |
26 | /// Compute the dominator tree for the given IR graph.
27 | pub fn dominators(
28 | items: &mut ir::Items,
29 | opts: &opt::Dominators,
30 | ) -> anyhow::Result> {
31 | items.compute_dominator_tree();
32 | items.compute_dominators();
33 | items.compute_retained_sizes();
34 | items.compute_predecessors();
35 |
36 | let arguments = opts.items();
37 | let dominator_items = if arguments.is_empty() {
38 | vec![items.meta_root()]
39 | } else if opts.using_regexps() {
40 | let regexps = regex::RegexSet::new(arguments)?;
41 | let mut sorted_items: Vec<_> = items
42 | .iter()
43 | .filter(|item| regexps.is_match(&item.name()))
44 | .map(|item| item.id())
45 | .collect();
46 | sorted_items.sort_by_key(|id| -i64::from(items.retained_size(*id)));
47 | sorted_items
48 | } else {
49 | arguments
50 | .iter()
51 | .filter_map(|name| items.get_item_by_name(name))
52 | .map(|item| item.id())
53 | .collect()
54 | };
55 |
56 | let tree = DominatorTree {
57 | tree: items.dominator_tree().clone(),
58 | items: dominator_items,
59 | opts: opts.clone(),
60 | unreachable_items_summary: summarize_unreachable_items(items, opts),
61 | };
62 |
63 | Ok(Box::new(tree) as Box<_>)
64 | }
65 |
66 | fn summarize_unreachable_items(
67 | items: &mut ir::Items,
68 | opts: &opt::Dominators,
69 | ) -> Option {
70 | let (size, count) = garbage::get_unreachable_items(&items)
71 | .map(|item| item.size())
72 | .fold((0, 0), |(s, c), curr| (s + curr, c + 1));
73 | if opts.items().is_empty() && size > 0 {
74 | Some(UnreachableItemsSummary {
75 | count,
76 | size,
77 | size_percent: (f64::from(size)) / (f64::from(items.size())) * 100.0,
78 | })
79 | } else {
80 | None
81 | }
82 | }
83 |
--------------------------------------------------------------------------------
/analyze/analyses/mod.rs:
--------------------------------------------------------------------------------
1 | pub mod diff;
2 | pub mod dominators;
3 | pub mod garbage;
4 | pub mod monos;
5 | pub mod paths;
6 | pub mod top;
7 |
--------------------------------------------------------------------------------
/analyze/analyses/monos/entry.rs:
--------------------------------------------------------------------------------
1 | #[derive(Debug, PartialEq, Eq)]
2 | pub(super) struct MonosEntry {
3 | pub name: String,
4 | pub insts: Vec<(String, u32)>,
5 | pub size: u32,
6 | pub bloat: u32,
7 | }
8 |
9 | impl PartialOrd for MonosEntry {
10 | fn partial_cmp(&self, rhs: &MonosEntry) -> Option {
11 | Some(self.cmp(rhs))
12 | }
13 | }
14 |
15 | impl Ord for MonosEntry {
16 | fn cmp(&self, rhs: &MonosEntry) -> std::cmp::Ordering {
17 | rhs.bloat
18 | .cmp(&self.bloat)
19 | .then(rhs.size.cmp(&self.size))
20 | .then(self.insts.cmp(&rhs.insts))
21 | .then(self.name.cmp(&rhs.name))
22 | }
23 | }
24 |
--------------------------------------------------------------------------------
/analyze/analyses/paths/mod.rs:
--------------------------------------------------------------------------------
1 | use std::collections::BTreeSet;
2 |
3 | use regex;
4 |
5 | use twiggy_ir as ir;
6 | use twiggy_opt as opt;
7 | use twiggy_traits as traits;
8 |
9 | mod paths_emit;
10 | mod paths_entry;
11 |
12 | use self::paths_entry::PathsEntry;
13 |
14 | #[derive(Debug)]
15 | struct Paths {
16 | opts: opt::Paths,
17 | entries: Vec,
18 | }
19 |
20 | /// Find all retaining paths for the given items.
21 | pub fn paths(items: &mut ir::Items, opts: &opt::Paths) -> anyhow::Result> {
22 | // The predecessor tree only needs to be computed if we are ascending
23 | // through the retaining paths.
24 | if !opts.descending() {
25 | items.compute_predecessors();
26 | }
27 |
28 | // Initialize the collection of Id values whose retaining paths we will emit.
29 | let opts = opts.clone();
30 | let entries = get_starting_positions(items, &opts)?
31 | .iter()
32 | .map(|id| create_entry(*id, items, &opts, &mut BTreeSet::new()))
33 | .collect();
34 |
35 | let paths = Paths { opts, entries };
36 |
37 | Ok(Box::new(paths) as Box<_>)
38 | }
39 |
40 | /// This helper function is used to collect the `ir::Id` values for the top-most
41 | /// path entries for the `Paths` object, based on the given options.
42 | fn get_starting_positions(items: &ir::Items, opts: &opt::Paths) -> anyhow::Result> {
43 | // Collect Id's if no arguments are given and we are ascending the retaining paths.
44 | let get_functions_default = || -> Vec {
45 | let mut sorted_items = items
46 | .iter()
47 | .filter(|item| item.id() != items.meta_root())
48 | .collect::>();
49 | sorted_items.sort_by(|a, b| b.size().cmp(&a.size()));
50 | sorted_items.iter().map(|item| item.id()).collect()
51 | };
52 |
53 | // Collect Id's if no arguments are given and we are descending the retaining paths.
54 | let get_functions_default_desc = || -> Vec {
55 | let mut roots = items
56 | .neighbors(items.meta_root())
57 | .map(|id| &items[id])
58 | .collect::>();
59 | roots.sort_by(|a, b| b.size().cmp(&a.size()));
60 | roots.into_iter().map(|item| item.id()).collect()
61 | };
62 |
63 | // Collect Id's if arguments were given that should be used as regular expressions.
64 | let get_regexp_matches = || -> anyhow::Result> {
65 | let regexps = regex::RegexSet::new(opts.functions())?;
66 | let matches = items
67 | .iter()
68 | .filter(|item| regexps.is_match(item.name()))
69 | .map(|item| item.id())
70 | .collect();
71 | Ok(matches)
72 | };
73 |
74 | // Collect Id's if arguments were given that should be used as exact names.
75 | let get_exact_matches = || -> Vec {
76 | opts.functions()
77 | .iter()
78 | .filter_map(|s| items.get_item_by_name(s))
79 | .map(|item| item.id())
80 | .collect()
81 | };
82 |
83 | // Collect the starting positions based on the relevant options given.
84 | // If arguments were given, search for matches depending on whether or
85 | // not these should be treated as regular expressions. Otherwise, collect
86 | // the starting positions based on the direction we will be traversing.
87 | let args_given = !opts.functions().is_empty();
88 | let using_regexps = opts.using_regexps();
89 | let descending = opts.descending();
90 | let res = match (args_given, using_regexps, descending) {
91 | (true, true, _) => get_regexp_matches()?,
92 | (true, false, _) => get_exact_matches(),
93 | (false, _, true) => get_functions_default_desc(),
94 | (false, _, false) => get_functions_default(),
95 | };
96 |
97 | Ok(res)
98 | }
99 |
100 | /// Create a `PathsEntry` object for the given item.
101 | fn create_entry(
102 | id: ir::Id,
103 | items: &ir::Items,
104 | opts: &opt::Paths,
105 | seen: &mut BTreeSet,
106 | ) -> PathsEntry {
107 | // Determine the item's name and size.
108 | let item = &items[id];
109 | let name = item.name().to_string();
110 | let size = item.size();
111 |
112 | // Collect the `ir::Id` values of this entry's children, depending on
113 | // whether we are ascending or descending the IR-tree.
114 | let children_ids: Vec = if opts.descending() {
115 | items
116 | .neighbors(id)
117 | .map(|id| id as ir::Id)
118 | .filter(|id| !seen.contains(id))
119 | .filter(|&id| id != items.meta_root())
120 | .collect()
121 | } else {
122 | items
123 | .predecessors(id)
124 | .map(|id| id as ir::Id)
125 | .filter(|id| !seen.contains(id))
126 | .filter(|&id| id != items.meta_root())
127 | .collect()
128 | };
129 |
130 | // Temporarily add the current item to the set of discovered nodes, and
131 | // create an entry for each child. Collect these into a `children` vector.
132 | seen.insert(id);
133 | let children = children_ids
134 | .into_iter()
135 | .map(|id| create_entry(id, items, opts, seen))
136 | .collect();
137 | seen.remove(&id);
138 |
139 | PathsEntry {
140 | name,
141 | size,
142 | children,
143 | }
144 | }
145 |
--------------------------------------------------------------------------------
/analyze/analyses/paths/paths_entry.rs:
--------------------------------------------------------------------------------
1 | use std::cmp;
2 |
3 | #[derive(Debug, PartialEq, Eq)]
4 | pub(super) struct PathsEntry {
5 | pub name: String,
6 | pub size: u32,
7 | pub children: Vec,
8 | }
9 |
10 | impl PathsEntry {
11 | pub fn _count(&self) -> u32 {
12 | 1 + self.children.iter().map(|c| c._count()).sum::()
13 | }
14 | }
15 |
16 | impl PartialOrd for PathsEntry {
17 | fn partial_cmp(&self, rhs: &Self) -> Option {
18 | Some(self.cmp(rhs))
19 | }
20 | }
21 |
22 | impl Ord for PathsEntry {
23 | fn cmp(&self, rhs: &Self) -> cmp::Ordering {
24 | rhs.size.cmp(&self.size).then(self.name.cmp(&rhs.name))
25 | }
26 | }
27 |
--------------------------------------------------------------------------------
/analyze/analyze.rs:
--------------------------------------------------------------------------------
1 | //! Implementations of the analyses that `twiggy` runs on its IR.
2 |
3 | #![deny(missing_docs)]
4 | #![deny(missing_debug_implementations)]
5 |
6 | mod analyses;
7 | mod formats;
8 |
9 | pub use analyses::{
10 | diff::diff, dominators::dominators, garbage::garbage, monos::monos, paths::paths, top::top,
11 | };
12 |
--------------------------------------------------------------------------------
/analyze/formats/json.rs:
--------------------------------------------------------------------------------
1 | // A couple methods are dead, but removing them would make the API oddly
2 | // imbalanced and we might want to use them in some future analysis.
3 | #![allow(dead_code)]
4 |
5 | use std::io;
6 |
7 | pub trait JsonPrimitive {
8 | fn json_primitive(&self, w: &mut dyn io::Write) -> io::Result<()>;
9 | }
10 |
11 | impl<'a> JsonPrimitive for &'a str {
12 | fn json_primitive(&self, w: &mut dyn io::Write) -> io::Result<()> {
13 | write!(w, "\"")?;
14 | for c in self.chars() {
15 | match c {
16 | '"' => write!(w, "\\\"")?,
17 | '\\' => write!(w, "\\")?,
18 | '\n' => writeln!(w,)?,
19 | c => write!(w, "{}", c)?,
20 | }
21 | }
22 | write!(w, "\"")
23 | }
24 | }
25 |
26 | impl JsonPrimitive for f64 {
27 | fn json_primitive(&self, w: &mut dyn io::Write) -> io::Result<()> {
28 | write!(w, "{}", self)
29 | }
30 | }
31 |
32 | impl JsonPrimitive for u32 {
33 | fn json_primitive(&self, w: &mut dyn io::Write) -> io::Result<()> {
34 | write!(w, "{}", self)
35 | }
36 | }
37 |
38 | pub fn array(w: &mut dyn io::Write) -> io::Result {
39 | write!(w, "[")?;
40 | Ok(Array {
41 | w,
42 | need_comma: false,
43 | })
44 | }
45 |
46 | pub fn object(w: &mut dyn io::Write) -> io::Result
9 | 
10 | 
11 | 
12 | 
53 |