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  9631       67695   35.9 
 8      17  3182       70877   37.6 
 9      18   514       71391   37.9 
10      19   866       72257   38.3 
11      20   487       72744   38.6 
12      21  1887       74631   39.6 
13      22   359       74990   39.8 
14      23   207       75197   39.9 
15      24 57694      132891   70.5 
16      25   238      133129   70.6 
17      26   115      133244   70.7 
18      27   110      133354   70.7 
19      28   298      133652   70.9 
20      29   332      133984   71.1 
21      30    76      134060   71.1 
22      31   107      134167   71.2 
# A tibble: 5 x 4
  obj_len     n n_less_than percent
    <int> <int>       <int>   <dbl>
1     268     1      188372    99.9
2     520   115      188487   100. 
3    1032     6      188493   100. 
4    4104     2      188495   100. 
5    4109     2      188497   100  

Common Sizes
# A tibble: 8 x 2
  obj_len     n
    <int> <int>
1      24 57694
2      14 52107
3      40 32632
4      16  9631
5      32  8972
6      72  6980
7      17  3182
8       9  2956

    188,497 total allocations, total bytes = 5,325,064

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.85
 3 List<runtime_asdl::part_value_t*>* Alloc<List<runtime_asdl::pa~  5543    6.66
 4 Tuple2<runtime_asdl::span_e, int>* Alloc<Tuple2<runtime_asdl::~  3561    4.28
 5 List<process::Process*>* Alloc<List<process::Process*>>()        2971    3.57
 6 List<process::_RedirFrame*>* Alloc<List<process::_RedirFrame*>~  2971    3.57
 7 process::_FdFrame* Alloc<process::_FdFrame>()                    2971    3.57
 8 List<runtime_asdl::RedirValue*>* Alloc<List<runtime_asdl::Redi~  2970    3.57
 9 executor::_ProcessSubFrame* Alloc<executor::_ProcessSubFrame>()  2970    3.57
10 runtime_asdl::CommandStatus* Alloc<runtime_asdl::CommandStatus~  2970    3.57
11 runtime_asdl::StatusArray* Alloc<runtime_asdl::StatusArray, de~  2970    3.57
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*~  1943    2.33
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.98
16 List<List<Tuple3<Str*, bool, bool>*>*>* Alloc<List<List<Tuple3~  1505    1.81
17 mylib::BufWriter* Alloc<mylib::BufWriter>()                      1444    1.73
18 Tuple3<Str*, bool, bool>* Alloc<Tuple3<Str*, bool, bool>, Str*~  1428    1.72
19 List<syntax_asdl::Redir*>* Alloc<List<syntax_asdl::Redir*>>()    1351    1.62
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>()                      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,235 typed allocs, including 36,356 List<T>
44.16% 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.7  
 3       2  1465       53837  81.9  
 4       3  1720       55557  84.5  
 5       4  3182       58739  89.4  
 6       5   514       59253  90.1  
 7       6   866       60119  91.5  
 8       7   486       60605  92.2  
 9       8  1887       62492  95.1  
10       9   359       62851  95.6  
11      10   207       63058  95.9  
12      11   161       63219  96.2  
13      12   238       63457  96.5  
14      13   115       63572  96.7  
15      14   110       63682  96.9  
16      15   298       63980  97.3  
# A tibble: 5 x 4
  str_len     n n_less_than percent
    <int> <int>       <int>   <dbl>
1     137     1       65723    100.
2     144     1       65724    100.
3     196     1       65725    100.
4     255     1       65726    100.
5    4096     2       65728    100 

65,728 string allocations, total length = 181,312, total bytes = 1,035,776

34.87% of allocs are strings
19.45% of bytes are strings

NewSlab()
  Lengths
# A tibble: 6 x 4
  slab_len     n n_less_than percent
     <int> <int>       <int>   <dbl>
1        2  4830        4830    12.1
2        3 22465       27295    68.6
3        6  4263       31558    79.3
4        7  3075       34633    87.0
5       14  2614       37247    93.6
6       15   881       38128    95.8
# A tibble: 5 x 4
  slab_len     n n_less_than percent
     <int> <int>       <int>   <dbl>
1      120     1       39684    99.7
2      126   111       39795   100. 
3      127     1       39796   100. 
4      254     1       39797   100. 
5     1022     2       39799   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)                                              5236
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,799 slabs, total items = 241,660
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 25987       25988 31.4    
 3         2  8417       34405 41.6    
 4         3  6835       41240 49.9    
 5         4  4771       46011 55.6    
 6         5  3342       49353 59.7    
 7         6  3008       52361 63.3    
 8         7  3209       55570 67.2    
 9         8  2999       58569 70.8    
10         9  3052       61621 74.5    
11        10  2659       64280 77.7    
12        11  1693       65973 79.8    
13        12  1583       67556 81.7    
14        13  1485       69041 83.5    
15        14   860       69901 84.5    
# A tibble: 5 x 4
  num_items     n n_less_than percent
      <int> <int>       <int>   <dbl>
1       113     1       82691    100.
2       114     1       82692    100.
3       115     1       82693    100.
4       204     1       82694    100.
5      1022     2       82696    100 

82,696 reserve() calls, total items = 733,349

Untyped: 188,497
Typed + Str + Slab: 188,762