Percentage of allocs less than 48 bytes: 96.7

All allocations
# A tibble: 22 x 4
   obj_len     n n_less_than percent
     <int> <int>       <int>   <dbl>
 1       9    30          30  0.0402
 2      10  1824        1854  2.48  
 3      12   892        2746  3.68  
 4      16  8110       10856 14.5   
 5      18  6838       17694 23.7   
 6      19  2464       20158 27.0   
 7      20    17       20175 27.0   
 8      21    51       20226 27.1   
 9      22    30       20256 27.1   
10      23    22       20278 27.2   
11      24 26638       46916 62.9   
12      25    53       46969 62.9   
13      26    52       47021 63.0   
14      27    90       47111 63.1   
15      28    28       47139 63.2   
16      29    34       47173 63.2   
17      30   911       48084 64.4   
18      31    21       48105 64.5   
19      32  7462       55567 74.5   
20      33     9       55576 74.5   
21      35    10       55586 74.5   
22      36     6       55592 74.5   
# A tibble: 5 x 4
  obj_len     n n_less_than percent
    <int> <int>       <int>   <dbl>
1     272     1       74599    100.
2     520    20       74619    100.
3    1032     7       74626    100.
4    4104     2       74628    100.
5    4113     2       74630    100 

Common Sizes
# A tibble: 8 x 2
  obj_len     n
    <int> <int>
1      24 26638
2      40 16491
3      16  8110
4      32  7462
5      18  6838
6      19  2464
7      10  1824
8      72  1653

    74,630 total allocations, total bytes = 2,148,128

Typed allocations
# A tibble: 20 x 3
   func_name                                                           n percent
   <chr>                                                           <int>   <dbl>
 1 List<Str*>* Alloc<List<Str*>>()                                  5575   12.1 
 2 List<runtime_asdl::part_value_t*>* Alloc<List<runtime_asdl::pa~  4086    8.88
 3 List<runtime_asdl::RedirValue*>* Alloc<List<runtime_asdl::Redi~  3186    6.93
 4 runtime_asdl::CommandStatus* Alloc<runtime_asdl::CommandStatus~  3186    6.93
 5 runtime_asdl::value__Str* Alloc<runtime_asdl::value__Str, Str*~  2227    4.84
 6 syntax_asdl::word__String* Alloc<syntax_asdl::word__String, in~  1844    4.01
 7 runtime_asdl::VarSubState* Alloc<runtime_asdl::VarSubState, bo~  1814    3.94
 8 runtime_asdl::part_value__String* Alloc<runtime_asdl::part_val~  1814    3.94
 9 runtime_asdl::lvalue__Named* Alloc<runtime_asdl::lvalue__Named~  1803    3.92
10 syntax_asdl::loc__Arith* Alloc<syntax_asdl::loc__Arith, syntax~  1780    3.87
11 runtime_asdl::value__Str* Alloc<runtime_asdl::value__Str, Str*~   996    2.17
12 List<syntax_asdl::CompoundWord*>* Alloc<List<syntax_asdl::Comp~   979    2.13
13 mylib::BufWriter* Alloc<mylib::BufWriter>()                       934    2.03
14 List<List<Tuple3<Str*, bool, bool>*>*>* Alloc<List<List<Tuple3~   932    2.03
15 List<Tuple2<runtime_asdl::span_e, int>*>* Alloc<List<Tuple2<ru~   932    2.03
16 List<Tuple3<Str*, bool, bool>*>* Alloc<List<Tuple3<Str*, bool,~   932    2.03
17 List<mylib::BufWriter*>* Alloc<List<mylib::BufWriter*>>()         932    2.03
18 List<syntax_asdl::Redir*>* Alloc<List<syntax_asdl::Redir*>>()     932    2.03
19 Tuple2<runtime_asdl::span_e, int>* Alloc<Tuple2<runtime_asdl::~   932    2.03
20 Tuple3<Str*, bool, bool>* Alloc<Tuple3<Str*, bool, bool>, Str*~   932    2.03
# A tibble: 5 x 3
  func_name                                                            n percent
  <chr>                                                            <int>   <dbl>
1 util::DebugFile* Alloc<util::DebugFile, mylib::Writer*>(mylib::~     1 0.00217
2 util::NullDebugFile* Alloc<util::NullDebugFile>()                    1 0.00217
3 word_eval::NormalWordEvaluator* Alloc<word_eval::NormalWordEval~     1 0.00217
4 word_eval::TildeEvaluator* Alloc<word_eval::TildeEvaluator, sta~     1 0.00217
5 word_parse::WordParser* Alloc<word_parse::WordParser, parse_lib~     1 0.00217

45,997 typed allocs, including 20,106 List<T>
61.63% of allocs are typed

Str - NewStr() and OverAllocatedStr()
# A tibble: 16 x 4
   str_len     n n_less_than percent
     <int> <int>       <int>   <dbl>
 1       1  6838        6838    63.8
 2       2  2464        9302    86.7
 3       3    17        9319    86.9
 4       4    51        9370    87.4
 5       5    30        9400    87.7
 6       6    22        9422    87.9
 7       7    39        9461    88.2
 8       8    53        9514    88.7
 9       9    52        9566    89.2
10      10    90        9656    90.0
11      11    28        9684    90.3
12      12    34        9718    90.6
13      13   911       10629    99.1
14      14    21       10650    99.3
15      15     5       10655    99.4
16      16     9       10664    99.4
# A tibble: 5 x 4
  str_len     n n_less_than percent
    <int> <int>       <int>   <dbl>
1     134     1       10719    100.
2     137     1       10720    100.
3     196     1       10721    100.
4     255     1       10722    100.
5    4096     2       10724    100 

10,724 string allocations, total length = 38,134, total bytes = 220,442

14.37% of allocs are strings
10.26% of bytes are strings

NewSlab()
  Lengths
# A tibble: 6 x 4
  slab_len     n n_less_than percent
     <int> <int>       <int>   <dbl>
1        2   393         393    2.19
2        3 14906       15299   85.4 
3        6   211       15510   86.6 
4        7  1482       16992   94.9 
5       14   165       17157   95.8 
6       15    26       17183   95.9 
# A tibble: 5 x 4
  slab_len     n n_less_than percent
     <int> <int>       <int>   <dbl>
1      120     1       17887    99.9
2      126    18       17905   100. 
3      127     1       17906   100. 
4      254     1       17907   100. 
5     1022     2       17909   100  

  Slab Types
# A tibble: 6 x 2
  func_name                                                                    n
  <chr>                                                                    <int>
1 Slab<Str*>* NewSlab<Str*>(int)                                            6105
2 Slab<runtime_asdl::part_value_t*>* NewSlab<runtime_asdl::part_value_t*>~  4086
3 Slab<syntax_asdl::CompoundWord*>* NewSlab<syntax_asdl::CompoundWord*>(i~  1885
4 Slab<List<Tuple3<Str*, bool, bool>*>*>* NewSlab<List<Tuple3<Str*, bool,~   932
5 Slab<Tuple2<runtime_asdl::span_e, int>*>* NewSlab<Tuple2<runtime_asdl::~   932
6 Slab<Tuple3<Str*, bool, bool>*>* NewSlab<Tuple3<Str*, bool, bool>*>(int)   932
# A tibble: 5 x 2
  func_name                                                        n
  <chr>                                                        <int>
1 Slab<split::IfsSplitter*>* NewSlab<split::IfsSplitter*>(int)     1
2 Slab<state::DebugFrame*>* NewSlab<state::DebugFrame*>(int)       1
3 Slab<state::_ArgFrame*>* NewSlab<state::_ArgFrame*>(int)         1
4 Slab<syntax_asdl::Token*>* NewSlab<syntax_asdl::Token*>(int)     1
5 Slab<syntax_asdl::loc_t*>* NewSlab<syntax_asdl::loc_t*>(int)     1

17,909 slabs, total items = 86,343
24.00% of allocs are slabs

::reserve(int n)

  Num Items
# A tibble: 15 x 4
   num_items     n n_less_than  percent
       <int> <int>       <int>    <dbl>
 1         0     1           1  0.00289
 2         1 20741       20742 59.9    
 3         2  4397       25139 72.5    
 4         3  1769       26908 77.6    
 5         4  2469       29377 84.8    
 6         5  2791       32168 92.8    
 7         6   554       32722 94.4    
 8         7    82       32804 94.7    
 9         8    74       32878 94.9    
10         9    74       32952 95.1    
11        10    70       33022 95.3    
12        11    55       33077 95.4    
13        12    54       33131 95.6    
14        13    51       33182 95.8    
15        14    51       33233 95.9    
# A tibble: 5 x 4
  num_items     n n_less_than percent
      <int> <int>       <int>   <dbl>
1       113     1       34649    100.
2       114     1       34650    100.
3       115     1       34651    100.
4       204     1       34652    100.
5      1022     2       34654    100 

34,654 reserve() calls, total items = 122,197

Untyped: 74,630
Typed + Str + Slab: 74,630