Percentage of allocs less than 48 bytes: 92.4

All allocations
# A tibble: 22 x 4
   obj_len     n n_less_than percent
     <int> <int>       <int>   <dbl>
 1       9  2956        2956    2.15
 2      10  1002        3958    2.89
 3      12   533        4491    3.27
 4      13     1        4492    3.27
 5      16  7099       11591    8.45
 6      18 39733       51324   37.4 
 7      19   786       52110   38.0 
 8      20  1721       53831   39.2 
 9      21  1612       55443   40.4 
10      22   512       55955   40.8 
11      23   652       56607   41.3 
12      24 35941       92548   67.5 
13      25  1439       93987   68.5 
14      26   359       94346   68.8 
15      27   206       94552   68.9 
16      28   159       94711   69.0 
17      29   166       94877   69.2 
18      30   115       94992   69.2 
19      31   109       95101   69.3 
20      32  5162      100263   73.1 
21      33   332      100595   73.3 
22      34    76      100671   73.4 
# A tibble: 5 x 4
  obj_len     n n_less_than percent
    <int> <int>       <int>   <dbl>
1     272     1      137046    99.9
2     520   117      137163   100. 
3    1032     7      137170   100. 
4    4104     2      137172   100. 
5    4113     2      137174   100  

Common Sizes
# A tibble: 8 x 2
  obj_len     n
    <int> <int>
1      18 39733
2      24 35941
3      40 24285
4      16  7099
5      72  6454
6      32  5162
7       9  2956
8     136  2634

    137,174 total allocations, total bytes = 4,243,825

Typed allocations
# A tibble: 20 x 3
   func_name                                                           n percent
   <chr>                                                           <int>   <dbl>
 1 List<Str*>* Alloc<List<Str*>>()                                  7228   12.8 
 2 runtime_asdl::part_value__String* Alloc<runtime_asdl::part_val~  5403    9.55
 3 List<runtime_asdl::part_value_t*>* Alloc<List<runtime_asdl::pa~  3143    5.56
 4 List<runtime_asdl::RedirValue*>* Alloc<List<runtime_asdl::Redi~  2970    5.25
 5 runtime_asdl::CommandStatus* Alloc<runtime_asdl::CommandStatus~  2970    5.25
 6 Tuple2<runtime_asdl::span_e, int>* Alloc<Tuple2<runtime_asdl::~  2733    4.83
 7 runtime_asdl::value__Bool* Alloc<runtime_asdl::value__Bool, bo~  2654    4.69
 8 List<syntax_asdl::CompoundWord*>* Alloc<List<syntax_asdl::Comp~  1650    2.92
 9 runtime_asdl::value__Str* Alloc<runtime_asdl::value__Str, Str*~  1648    2.91
10 List<syntax_asdl::Redir*>* Alloc<List<syntax_asdl::Redir*>>()    1351    2.39
11 runtime_asdl::VarSubState* Alloc<runtime_asdl::VarSubState, bo~  1002    1.77
12 List<Tuple3<Str*, bool, bool>*>* Alloc<List<Tuple3<Str*, bool,~   955    1.69
13 runtime_asdl::part_value__String* Alloc<runtime_asdl::part_val~   925    1.63
14 args::SetToTrue* Alloc<args::SetToTrue, Str*>(Str*&&)             912    1.61
15 Dict<Str*, runtime_asdl::value_t*>* Alloc<Dict<Str*, runtime_a~   903    1.60
16 Dict<Str*, args::_Action*>* Alloc<Dict<Str*, args::_Action*>>()   902    1.59
17 List<Tuple2<Str*, bool>*>* Alloc<List<Tuple2<Str*, bool>*>>()     902    1.59
18 runtime_asdl::value__Str* Alloc<runtime_asdl::value__Str, Str*~   869    1.54
19 args::SetToString* Alloc<args::SetToString, Str*, bool, List<S~   754    1.33
20 runtime_asdl::lvalue__Named* Alloc<runtime_asdl::lvalue__Named~   729    1.29
# A tibble: 5 x 3
  func_name                                                            n percent
  <chr>                                                            <int>   <dbl>
1 ui::ErrorFormatter* Alloc<ui::ErrorFormatter>()                      1 0.00177
2 util::DebugFile* Alloc<util::DebugFile, mylib::Writer*>(mylib::~     1 0.00177
3 util::NullDebugFile* Alloc<util::NullDebugFile>()                    1 0.00177
4 word_eval::NormalWordEvaluator* Alloc<word_eval::NormalWordEval~     1 0.00177
5 word_eval::TildeEvaluator* Alloc<word_eval::TildeEvaluator, sta~     1 0.00177

56,575 typed allocs, including 21,759 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.529
 2       1 39733       39998  79.9  
 3       2   786       40784  81.5  
 4       3  1720       42504  84.9  
 5       4  1612       44116  88.1  
 6       5   512       44628  89.2  
 7       6   652       45280  90.5  
 8       7   484       45764  91.4  
 9       8  1439       47203  94.3  
10       9   359       47562  95.0  
11      10   206       47768  95.4  
12      11   159       47927  95.8  
13      12   166       48093  96.1  
14      13   115       48208  96.3  
15      14   109       48317  96.5  
16      15    70       48387  96.7  
# A tibble: 5 x 4
  str_len     n n_less_than percent
    <int> <int>       <int>   <dbl>
1     137     1       50048    100.
2     144     1       50049    100.
3     196     1       50050    100.
4     255     1       50051    100.
5    4096     2       50053    100 

50,053 string allocations, total length = 149,648, total bytes = 1,000,549

36.49% of allocs are strings
23.58% of bytes are strings

NewSlab()
  Lengths
# A tibble: 6 x 4
  slab_len     n n_less_than percent
     <int> <int>       <int>   <dbl>
1        2  4836        4836    15.7
2        3 14071       18907    61.4
3        6  4263       23170    75.2
4        7  2549       25719    83.5
5       14  2614       28333    92.0
6       15   804       29137    94.6
# A tibble: 5 x 4
  slab_len     n n_less_than percent
     <int> <int>       <int>   <dbl>
1      120     1       30693    99.6
2      126   114       30807   100. 
3      127     1       30808   100. 
4      254     1       30809   100. 
5     1022     2       30811   100  

  Slab Types
# A tibble: 6 x 2
  func_name                                                                    n
  <chr>                                                                    <int>
1 Slab<Str*>* NewSlab<Str*>(int)                                           11689
2 Slab<int>* NewSlab<int>(int)                                              5243
3 Slab<runtime_asdl::part_value_t*>* NewSlab<runtime_asdl::part_value_t*>~  3596
4 Slab<runtime_asdl::value_t*>* NewSlab<runtime_asdl::value_t*>(int)        2419
5 Slab<syntax_asdl::CompoundWord*>* NewSlab<syntax_asdl::CompoundWord*>(i~  1931
6 Slab<args::_Action*>* NewSlab<args::_Action*>(int)                         980
# 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,811 slabs, total items = 212,031
22.46% 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.00135
 2         1 18427       18428 24.9    
 3         2  8470       26898 36.4    
 4         3  6996       33894 45.8    
 5         4  4668       38562 52.1    
 6         5  4213       42775 57.8    
 7         6  3512       46287 62.6    
 8         7  3250       49537 67.0    
 9         8  2719       52256 70.7    
10         9  2446       54702 74.0    
11        10  1833       56535 76.4    
12        11  1382       57917 78.3    
13        12  1353       59270 80.1    
14        13  1256       60526 81.8    
15        14   699       61225 82.8    
# A tibble: 5 x 4
  num_items     n n_less_than percent
      <int> <int>       <int>   <dbl>
1       113     1       73952    100.
2       114     1       73953    100.
3       115     1       73954    100.
4       204     1       73955    100.
5      1022     2       73957    100 

73,957 reserve() calls, total items = 705,816

Untyped: 137,174
Typed + Str + Slab: 137,439