Percentage of allocs less than 48 bytes: 91.4

All allocations
# A tibble: 22 x 4
   obj_len     n n_less_than percent
     <int> <int>       <int>   <dbl>
 1       9  2963        2963    2.15
 2      10  1002        3965    2.88
 3      12   533        4498    3.27
 4      13     1        4499    3.27
 5      16  7133       11632    8.45
 6      18 39843       51475   37.4 
 7      19   786       52261   38.0 
 8      20  1725       53986   39.2 
 9      21  1620       55606   40.4 
10      22   521       56127   40.8 
11      23   656       56783   41.3 
12      24 34453       91236   66.3 
13      25  1449       92685   67.3 
14      26   367       93052   67.6 
15      27   200       93252   67.7 
16      28   158       93410   67.9 
17      29   169       93579   68.0 
18      30   115       93694   68.1 
19      31   109       93803   68.1 
20      32  5250       99053   72.0 
21      33   332       99385   72.2 
22      34    76       99461   72.3 
# A tibble: 5 x 4
  obj_len     n n_less_than percent
    <int> <int>       <int>   <dbl>
1     272     1      137486    99.9
2     520   146      137632   100. 
3    1032    13      137645   100. 
4    4104     2      137647   100. 
5    4113     2      137649   100  

Common Sizes
# A tibble: 8 x 2
  obj_len     n
    <int> <int>
1      18 39843
2      24 34453
3      40 22600
4      16  7133
5      72  7028
6      32  5250
7     136  3418
8      48  3120

    137,649 total allocations, total bytes = 4,414,745

Typed allocations
# A tibble: 20 x 3
   func_name                                                           n percent
   <chr>                                                           <int>   <dbl>
 1 List<Str*>* Alloc<List<Str*>>()                                  7245   12.8 
 2 runtime_asdl::part_value__String* Alloc<runtime_asdl::part_val~  5403    9.52
 3 List<runtime_asdl::part_value_t*>* Alloc<List<runtime_asdl::pa~  3144    5.54
 4 List<runtime_asdl::RedirValue*>* Alloc<List<runtime_asdl::Redi~  2970    5.23
 5 runtime_asdl::CommandStatus* Alloc<runtime_asdl::CommandStatus~  2970    5.23
 6 Tuple2<runtime_asdl::span_e, int>* Alloc<Tuple2<runtime_asdl::~  2733    4.81
 7 runtime_asdl::value__Bool* Alloc<runtime_asdl::value__Bool, bo~  2659    4.68
 8 List<syntax_asdl::CompoundWord*>* Alloc<List<syntax_asdl::Comp~  1654    2.91
 9 runtime_asdl::value__Str* Alloc<runtime_asdl::value__Str, Str*~  1647    2.90
10 List<syntax_asdl::Redir*>* Alloc<List<syntax_asdl::Redir*>>()    1351    2.38
11 runtime_asdl::VarSubState* Alloc<runtime_asdl::VarSubState, bo~  1002    1.77
12 List<Tuple3<Str*, bool, bool>*>* Alloc<List<Tuple3<Str*, bool,~   956    1.68
13 runtime_asdl::part_value__String* Alloc<runtime_asdl::part_val~   925    1.63
14 args::SetToTrue* Alloc<args::SetToTrue, Str*>(Str*&&)             917    1.62
15 Dict<Str*, runtime_asdl::value_t*>* Alloc<Dict<Str*, runtime_a~   907    1.60
16 Dict<Str*, args::_Action*>* Alloc<Dict<Str*, args::_Action*>>()   906    1.60
17 List<Tuple2<Str*, bool>*>* Alloc<List<Tuple2<Str*, bool>*>>()     906    1.60
18 runtime_asdl::value__Str* Alloc<runtime_asdl::value__Str, Str*~   869    1.53
19 args::SetToString* Alloc<args::SetToString, Str*, bool, List<S~   766    1.35
20 runtime_asdl::lvalue__Named* Alloc<runtime_asdl::lvalue__Named~   747    1.32
# A tibble: 5 x 3
  func_name                                                            n percent
  <chr>                                                            <int>   <dbl>
1 util::DebugFile* Alloc<util::DebugFile, mylib::Writer*>(mylib::~     1 0.00176
2 util::NullDebugFile* Alloc<util::NullDebugFile>()                    1 0.00176
3 word_eval::CompletionWordEvaluator* Alloc<word_eval::Completion~     1 0.00176
4 word_eval::NormalWordEvaluator* Alloc<word_eval::NormalWordEval~     1 0.00176
5 word_eval::TildeEvaluator* Alloc<word_eval::TildeEvaluator, sta~     1 0.00176

56,765 typed allocs, including 21,790 List<T>
41.24% 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       0   265         265   0.528
 2       1 39843       40108  79.9  
 3       2   786       40894  81.4  
 4       3  1724       42618  84.9  
 5       4  1620       44238  88.1  
 6       5   521       44759  89.1  
 7       6   656       45415  90.4  
 8       7   500       45915  91.4  
 9       8  1449       47364  94.3  
10       9   367       47731  95.0  
11      10   200       47931  95.4  
12      11   158       48089  95.8  
13      12   169       48258  96.1  
14      13   115       48373  96.3  
15      14   109       48482  96.5  
16      15    74       48556  96.7  
# A tibble: 5 x 4
  str_len     n n_less_than percent
    <int> <int>       <int>   <dbl>
1     137     1       50217    100.
2     144     1       50218    100.
3     196     1       50219    100.
4     255     1       50220    100.
5    4096     2       50222    100 

50,222 string allocations, total length = 150,160, total bytes = 1,003,934

36.49% of allocs are strings
22.74% of bytes are strings

NewSlab()
  Lengths
# A tibble: 6 x 4
  slab_len     n n_less_than percent
     <int> <int>       <int>   <dbl>
1        2  3248        3248    10.5
2        3 15714       18962    61.3
3        6  2931       21893    70.8
4        7  2557       24450    79.1
5        9  1359       25809    83.5
6       14  1817       27626    89.3
# A tibble: 5 x 4
  slab_len     n n_less_than percent
     <int> <int>       <int>   <dbl>
1      126   108       30917    100.
2      127     1       30918    100.
3      189     6       30924    100.
4      254     1       30925    100.
5     1022     2       30927    100 

  Slab Types
# A tibble: 6 x 2
  func_name                                                                    n
  <chr>                                                                    <int>
1 Slab<Str*>* NewSlab<Str*>(int)                                           11741
2 Slab<int>* NewSlab<int>(int)                                              5274
3 Slab<runtime_asdl::part_value_t*>* NewSlab<runtime_asdl::part_value_t*>~  3597
4 Slab<runtime_asdl::value_t*>* NewSlab<runtime_asdl::value_t*>(int)        2431
5 Slab<syntax_asdl::CompoundWord*>* NewSlab<syntax_asdl::CompoundWord*>(i~  1935
6 Slab<args::_Action*>* NewSlab<args::_Action*>(int)                         988
# A tibble: 5 x 2
  func_name                                                                    n
  <chr>                                                                    <int>
1 Slab<runtime_asdl::RedirValue*>* NewSlab<runtime_asdl::RedirValue*>(int)     1
2 Slab<split::IfsSplitter*>* NewSlab<split::IfsSplitter*>(int)                 1
3 Slab<syntax_asdl::IfArm*>* NewSlab<syntax_asdl::IfArm*>(int)                 1
4 Slab<syntax_asdl::loc_t*>* NewSlab<syntax_asdl::loc_t*>(int)                 1
5 Slab<syntax_asdl::printf_part_t*>* NewSlab<syntax_asdl::printf_part_t*>~     1

30,927 slabs, total items = 226,414
22.47% 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     3           3  0.00469
 2         1 18458       18461 28.9    
 3         2  7106       25567 40.0    
 4         3  7013       32580 51.0    
 5         4  3405       35985 56.3    
 6         5  3022       39007 61.0    
 7         6  2480       41487 64.9    
 8         7  3258       44745 70.0    
 9         8  1914       46659 73.0    
10         9  1641       48300 75.6    
11        10  1030       49330 77.2    
12        11   886       50216 78.6    
13        12   858       51074 79.9    
14        13   761       51835 81.1    
15        14   655       52490 82.1    
# A tibble: 5 x 4
  num_items     n n_less_than percent
      <int> <int>       <int>   <dbl>
1        77    15       63900    100.
2        78     8       63908    100.
3       105     2       63910    100.
4       204     1       63911    100.
5      1022     2       63913    100 

63,913 reserve() calls, total items = 595,958

Untyped: 137,649
Typed + Str + Slab: 137,914