Percentage of allocs less than 32 bytes: 75.9

All allocations
# A tibble: 22 x 4
   obj_len     n n_less_than percent
     <int> <int>       <int>   <dbl>
 1       9  2956        2956    1.57
 2      10  1002        3958    2.10
 3      12   533        4491    2.38
 4      13     1        4492    2.38
 5      14 52107       56599   30.0 
 6      15  1465       58064   30.8 
 7      16  9588       67652   35.9 
 8      17  3182       70834   37.6 
 9      18   514       71348   37.9 
10      19   866       72214   38.3 
11      20   487       72701   38.6 
12      21  1894       74595   39.6 
13      22   355       74950   39.8 
14      23   217       75167   39.9 
15      24 57644      132811   70.5 
16      25   236      133047   70.6 
17      26   135      133182   70.7 
18      27   110      133292   70.8 
19      28   298      133590   70.9 
20      29   340      133930   71.1 
21      30    76      134006   71.1 
22      31   107      134113   71.2 
# A tibble: 5 x 4
  obj_len     n n_less_than percent
    <int> <int>       <int>   <dbl>
1     264   566      188226    99.9
2     520   115      188341   100. 
3    1032     6      188347   100. 
4    4104     2      188349   100. 
5    4109     2      188351   100  

Common Sizes
# A tibble: 8 x 2
  obj_len     n
    <int> <int>
1      24 57644
2      14 52107
3      40 32599
4      16  9588
5      32  8901
6      72  6972
7      17  3182
8       9  2956

    188,351 total allocations, total bytes = 5,322,093

Typed allocations
# A tibble: 20 x 3
   func_name                                                           n percent
   <chr>                                                           <int>   <dbl>
 1 List<Str*>* Alloc<List<Str*>>()                                 10080   12.1 
 2 runtime_asdl::part_value__String* Alloc<runtime_asdl::part_val~  6531    7.86
 3 List<runtime_asdl::part_value_t*>* Alloc<List<runtime_asdl::pa~  5543    6.67
 4 Tuple2<runtime_asdl::span_e, int>* Alloc<Tuple2<runtime_asdl::~  3561    4.29
 5 List<process::Process*>* Alloc<List<process::Process*>>()        2971    3.58
 6 List<process::_RedirFrame*>* Alloc<List<process::_RedirFrame*>~  2971    3.58
 7 process::_FdFrame* Alloc<process::_FdFrame>()                    2971    3.58
 8 List<runtime_asdl::RedirValue*>* Alloc<List<runtime_asdl::Redi~  2970    3.58
 9 executor::_ProcessSubFrame* Alloc<executor::_ProcessSubFrame>()  2970    3.58
10 runtime_asdl::CommandStatus* Alloc<runtime_asdl::CommandStatus~  2970    3.58
11 runtime_asdl::StatusArray* Alloc<runtime_asdl::StatusArray, de~  2970    3.58
12 runtime_asdl::value__Bool* Alloc<runtime_asdl::value__Bool, bo~  2654    3.19
13 runtime_asdl::value__Str* Alloc<runtime_asdl::value__Str, Str*~  1860    2.24
14 List<Tuple3<Str*, bool, bool>*>* Alloc<List<Tuple3<Str*, bool,~  1855    2.23
15 List<syntax_asdl::CompoundWord*>* Alloc<List<syntax_asdl::Comp~  1650    1.99
16 List<List<Tuple3<Str*, bool, bool>*>*>* Alloc<List<List<Tuple3~  1505    1.81
17 mylib::BufWriter* Alloc<mylib::BufWriter>()                      1444    1.74
18 Tuple3<Str*, bool, bool>* Alloc<Tuple3<Str*, bool, bool>, Str*~  1428    1.72
19 List<syntax_asdl::Redir*>* Alloc<List<syntax_asdl::Redir*>>()    1352    1.63
20 List<mylib::BufWriter*>* Alloc<List<mylib::BufWriter*>>()        1129    1.36
# A tibble: 5 x 3
  func_name                                                            n percent
  <chr>                                                            <int>   <dbl>
1 ui::ErrorFormatter* Alloc<ui::ErrorFormatter, alloc::Arena*&>(a~     1 0.00120
2 util::DebugFile* Alloc<util::DebugFile, mylib::Writer*>(mylib::~     1 0.00120
3 util::NullDebugFile* Alloc<util::NullDebugFile>()                    1 0.00120
4 word_eval::NormalWordEvaluator* Alloc<word_eval::NormalWordEval~     1 0.00120
5 word_eval::TildeEvaluator* Alloc<word_eval::TildeEvaluator, sta~     1 0.00120

83,075 typed allocs, including 36,327 List<T>
44.11% 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.403
 2       1 52107       52372  79.6  
 3       2  1465       53837  81.8  
 4       3  1720       55557  84.4  
 5       4  3182       58739  89.3  
 6       5   514       59253  90.1  
 7       6   866       60119  91.4  
 8       7   486       60605  92.1  
 9       8  1894       62499  95.0  
10       9   355       62854  95.5  
11      10   217       63071  95.9  
12      11   161       63232  96.1  
13      12   236       63468  96.5  
14      13   135       63603  96.7  
15      14   110       63713  96.8  
16      15   298       64011  97.3  
# A tibble: 5 x 4
  str_len     n n_less_than percent
    <int> <int>       <int>   <dbl>
1     136     1       65784    100.
2     137     1       65785    100.
3     144     1       65786    100.
4     196     1       65787    100.
5    4096     2       65789    100 

65,789 string allocations, total length = 182,756, total bytes = 1,038,013

34.93% of allocs are strings
19.50% of bytes are strings

NewSlab()
  Lengths
# A tibble: 6 x 4
  slab_len     n n_less_than percent
     <int> <int>       <int>   <dbl>
1        2  4815        4815    12.1
2        3 22432       27247    68.5
3        6  4270       31517    79.3
4        7  3070       34587    87.0
5       14  2611       37198    93.6
6       15   880       38078    95.8
# A tibble: 5 x 4
  slab_len     n n_less_than percent
     <int> <int>       <int>   <dbl>
1      120     1       39637    99.7
2      126   111       39748   100. 
3      127     1       39749   100. 
4      254     1       39750   100. 
5     1022     2       39752   100  

  Slab Types
# A tibble: 6 x 2
  func_name                                                                    n
  <chr>                                                                    <int>
1 Slab<Str*>* NewSlab<Str*>(int)                                           15066
2 Slab<runtime_asdl::part_value_t*>* NewSlab<runtime_asdl::part_value_t*>~  5996
3 Slab<int>* NewSlab<int>(int)                                              5228
4 Slab<runtime_asdl::value_t*>* NewSlab<runtime_asdl::value_t*>(int)        2418
5 Slab<Tuple3<Str*, bool, bool>*>* NewSlab<Tuple3<Str*, bool, bool>*>(int)  1855
6 Slab<syntax_asdl::CompoundWord*>* NewSlab<syntax_asdl::CompoundWord*>(i~  1707
# A tibble: 5 x 2
  func_name                                                                    n
  <chr>                                                                    <int>
1 Slab<split::IfsSplitter*>* NewSlab<split::IfsSplitter*>(int)                 1
2 Slab<syntax_asdl::IfArm*>* NewSlab<syntax_asdl::IfArm*>(int)                 1
3 Slab<syntax_asdl::loc_t*>* NewSlab<syntax_asdl::loc_t*>(int)                 1
4 Slab<syntax_asdl::printf_part_t*>* NewSlab<syntax_asdl::printf_part_t*>~     1
5 Slab<void*>* NewSlab<void*>(int)                                             1

39,752 slabs, total items = 241,763
21.11% 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.00121
 2         1 25959       25960 31.4    
 3         2  8403       34363 41.6    
 4         3  6830       41193 49.9    
 5         4  4769       45962 55.6    
 6         5  3337       49299 59.7    
 7         6  3005       52304 63.3    
 8         7  3208       55512 67.2    
 9         8  2997       58509 70.8    
10         9  3050       61559 74.5    
11        10  2657       64216 77.7    
12        11  1691       65907 79.8    
13        12  1581       67488 81.7    
14        13  1484       68972 83.5    
15        14   859       69831 84.5    
# A tibble: 5 x 4
  num_items     n n_less_than percent
      <int> <int>       <int>   <dbl>
1       111     1       82592    100.
2       112     1       82593    100.
3       113     1       82594    100.
4       198     1       82595    100.
5      1022     2       82597    100 

82,597 reserve() calls, total items = 730,324

Untyped: 188,351
Typed + Str + Slab: 188,616