Percentage of allocs less than 48 bytes: 93.1

All allocations
# A tibble: 22 x 4
   obj_len     n n_less_than percent
     <int> <int>       <int>   <dbl>
 1       9  2963        2963    2.16
 2      10  1002        3965    2.90
 3      12   758        4723    3.45
 4      13     1        4724    3.45
 5      16  6984       11708    8.55
 6      18 40968       52676   38.5 
 7      19   786       53462   39.1 
 8      20  1726       55188   40.3 
 9      21  1618       56806   41.5 
10      22   519       57325   41.9 
11      23   655       57980   42.4 
12      24 34355       92335   67.5 
13      25  1437       93772   68.5 
14      26   359       94131   68.8 
15      27   183       94314   68.9 
16      28   158       94472   69.0 
17      29   162       94634   69.1 
18      30   118       94752   69.2 
19      31   106       94858   69.3 
20      32  4725       99583   72.8 
21      33   335       99918   73.0 
22      34    78       99996   73.1 
# A tibble: 5 x 4
  obj_len     n n_less_than percent
    <int> <int>       <int>   <dbl>
1     520    35      136852    100.
2    1024     8      136860    100.
3    1032     6      136866    100.
4    4096     2      136868    100.
5    4113     2      136870    100 

Common Sizes
# A tibble: 8 x 2
  obj_len     n
    <int> <int>
1      18 40968
2      24 34355
3      48 22102
4      16  6984
5      32  4725
6      40  4589
7      64  3483
8       9  2963

    136,870 total allocations, total bytes = 4,387,204

Typed allocations
# A tibble: 20 x 3
   func_name                                                           n percent
   <chr>                                                           <int>   <dbl>
 1 List<BigStr*>* Alloc<List<BigStr*>>()                            7099   12.4 
 2 runtime_asdl::part_value__String* Alloc<runtime_asdl::part_val~  5403    9.45
 3 List<runtime_asdl::part_value_t*>* Alloc<List<runtime_asdl::pa~  3144    5.50
 4 List<runtime_asdl::RedirValue*>* Alloc<List<runtime_asdl::Redi~  2970    5.20
 5 runtime_asdl::CommandStatus* Alloc<runtime_asdl::CommandStatus~  2970    5.20
 6 Tuple2<runtime_asdl::span_e, int>* Alloc<Tuple2<runtime_asdl::~  2733    4.78
 7 value_asdl::value__Bool* Alloc<value_asdl::value__Bool, bool&>~  2659    4.65
 8 List<syntax_asdl::CompoundWord*>* Alloc<List<syntax_asdl::Comp~  1654    2.89
 9 value_asdl::value__Str* Alloc<value_asdl::value__Str, BigStr*>~  1647    2.88
10 List<syntax_asdl::Redir*>* Alloc<List<syntax_asdl::Redir*>>()    1351    2.36
11 runtime_asdl::VarSubState* Alloc<runtime_asdl::VarSubState, bo~  1002    1.75
12 List<Tuple3<BigStr*, bool, bool>*>* Alloc<List<Tuple3<BigStr*,~   956    1.67
13 runtime_asdl::part_value__String* Alloc<runtime_asdl::part_val~   925    1.62
14 args::SetToTrue* Alloc<args::SetToTrue, BigStr*>(BigStr*&&)       917    1.60
15 Dict<BigStr*, value_asdl::value_t*>* Alloc<Dict<BigStr*, value~   908    1.59
16 Dict<BigStr*, args::_Action*>* Alloc<Dict<BigStr*, args::_Acti~   906    1.58
17 List<Tuple2<BigStr*, bool>*>* Alloc<List<Tuple2<BigStr*, bool>~   906    1.58
18 value_asdl::value__Str* Alloc<value_asdl::value__Str, BigStr*&~   870    1.52
19 args::SetToString* Alloc<args::SetToString, BigStr*, bool, Lis~   766    1.34
20 runtime_asdl::StatusArray* Alloc<runtime_asdl::StatusArray, de~   691    1.21
# A tibble: 5 x 3
  func_name                                                            n percent
  <chr>                                                            <int>   <dbl>
1 value_asdl::value__IO* Alloc<value_asdl::value__IO, cmd_eval::C~     1 0.00175
2 value_asdl::value__List* Alloc<value_asdl::value__List, List<va~     1 0.00175
3 word_eval::CompletionWordEvaluator* Alloc<word_eval::Completion~     1 0.00175
4 word_eval::NormalWordEvaluator* Alloc<word_eval::NormalWordEval~     1 0.00175
5 word_eval::TildeEvaluator* Alloc<word_eval::TildeEvaluator, sta~     1 0.00175

57,165 typed allocs, including 21,894 List<T>
41.77% 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   271         271   0.528
 2       1 40968       41239  80.4  
 3       2   786       42025  81.9  
 4       3  1725       43750  85.3  
 5       4  1618       45368  88.5  
 6       5   519       45887  89.5  
 7       6   655       46542  90.7  
 8       7   495       47037  91.7  
 9       8  1437       48474  94.5  
10       9   359       48833  95.2  
11      10   183       49016  95.6  
12      11   144       49160  95.8  
13      12   162       49322  96.2  
14      13   118       49440  96.4  
15      14   106       49546  96.6  
16      15    74       49620  96.7  
# A tibble: 5 x 4
  str_len     n n_less_than percent
    <int> <int>       <int>   <dbl>
1     137     1       51285    100.
2     144     1       51286    100.
3     196     1       51287    100.
4     255     1       51288    100.
5    4096     2       51290    100 

51,290 string allocations, total length = 150,717, total bytes = 1,022,647

37.47% of allocs are strings
23.31% of bytes are strings

NewSlab()
  Lengths
# A tibble: 6 x 4
  slab_len     n n_less_than percent
     <int> <int>       <int>   <dbl>
1        5 17063       17063    59.5
2        7  3183       20246    70.6
3        8  1537       21783    75.9
4       10   736       22519    78.5
5       14   262       22781    79.4
6       15  2348       25129    87.6
# A tibble: 5 x 4
  slab_len     n n_less_than percent
     <int> <int>       <int>   <dbl>
1      127    11       28642    99.8
2      128    35       28677   100. 
3      254     1       28678   100. 
4      256     6       28684   100. 
5     1022     2       28686   100  

  Slab Types
# A tibble: 6 x 2
  func_name                                                                    n
  <chr>                                                                    <int>
1 Slab<BigStr*>* NewSlab<BigStr*>(int)                                     10499
2 Slab<int>* NewSlab<int>(int)                                              5105
3 Slab<runtime_asdl::part_value_t*>* NewSlab<runtime_asdl::part_value_t*>~  3525
4 Slab<value_asdl::value_t*>* NewSlab<value_asdl::value_t*>(int)            2429
5 Slab<syntax_asdl::CompoundWord*>* NewSlab<syntax_asdl::CompoundWord*>(i~  1773
6 Slab<Tuple3<BigStr*, bool, bool>*>* NewSlab<Tuple3<BigStr*, bool, bool>~   956
# A tibble: 5 x 2
  func_name                                                                    n
  <chr>                                                                    <int>
1 Slab<syntax_asdl::printf_part_t*>* NewSlab<syntax_asdl::printf_part_t*>~     1
2 Slab<value_asdl::regex_match_t*>* NewSlab<value_asdl::regex_match_t*>(i~     1
3 Slab<value_asdl::value__Dict*>* NewSlab<value_asdl::value__Dict*>(int)       1
4 Slab<value_asdl::value__Proc*>* NewSlab<value_asdl::value__Proc*>(int)       1
5 Slab<vm::_AssignBuiltin*>* NewSlab<vm::_AssignBuiltin*>(int)                 1

28,686 slabs, total items = 292,923
20.96% 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.00454
 2         1 18588       18591 28.2    
 3         2  7296       25887 39.2    
 4         3  5862       31749 48.1    
 5         4  3626       35375 53.6    
 6         5  3241       38616 58.5    
 7         6  3782       42398 64.2    
 8         7  2666       45064 68.3    
 9         8  2983       48047 72.8    
10         9  1867       49914 75.6    
11        10  1484       51398 77.9    
12        11   922       52320 79.3    
13        12   857       53177 80.6    
14        13   760       53937 81.7    
15        14   655       54592 82.7    
# A tibble: 5 x 4
  num_items     n n_less_than percent
      <int> <int>       <int>   <dbl>
1        77    15       66001    100.
2        78     8       66009    100.
3       106     2       66011    100.
4       177     1       66012    100.
5      1022     2       66014    100 

66,014 reserve() calls, total items = 614,142

Untyped: 136,870
Typed + Str + Slab: 137,141