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 57696      132893   70.5 
16      25   238      133131   70.6 
17      26   115      133246   70.7 
18      27   110      133356   70.7 
19      28   298      133654   70.9 
20      29   332      133986   71.1 
21      30    76      134062   71.1 
22      31   107      134169   71.2 
# A tibble: 5 x 4
  obj_len     n n_less_than percent
    <int> <int>       <int>   <dbl>
1     268     1      188378    99.9
2     520   115      188493   100. 
3    1032     6      188499   100. 
4    4104     2      188501   100. 
5    4109     2      188503   100  

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

    188,503 total allocations, total bytes = 5,325,304

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,238 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  4833        4833    12.1
2        3 22465       27298    68.6
3        6  4263       31561    79.3
4        7  3075       34636    87.0
5       14  2614       37250    93.6
6       15   881       38131    95.8
# A tibble: 5 x 4
  slab_len     n n_less_than percent
     <int> <int>       <int>   <dbl>
1      120     1       39687    99.7
2      126   111       39798   100. 
3      127     1       39799   100. 
4      254     1       39800   100. 
5     1022     2       39802   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)                                              5238
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,802 slabs, total items = 241,666
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 25988       25989 31.4    
 3         2  8418       34407 41.6    
 4         3  6835       41242 49.9    
 5         4  4771       46013 55.6    
 6         5  3342       49355 59.7    
 7         6  3008       52363 63.3    
 8         7  3209       55572 67.2    
 9         8  2999       58571 70.8    
10         9  3052       61623 74.5    
11        10  2659       64282 77.7    
12        11  1693       65975 79.8    
13        12  1583       67558 81.7    
14        13  1485       69043 83.5    
15        14   860       69903 84.5    
# A tibble: 5 x 4
  num_items     n n_less_than percent
      <int> <int>       <int>   <dbl>
1       113     1       82693    100.
2       114     1       82694    100.
3       115     1       82695    100.
4       204     1       82696    100.
5      1022     2       82698    100 

82,698 reserve() calls, total items = 733,352

Untyped: 188,503
Typed + Str + Slab: 188,768