Percentage of allocs less than 48 bytes: 90.7

All allocations
# A tibble: 22 × 4
   obj_len     n n_less_than percent
     <int> <int>       <int>   <dbl>
 1       9    39          39  0.0247
 2      10     2          41  0.0260
 3      11  2005        2046  1.30  
 4      12     1        2047  1.30  
 5      16 14757       16804 10.7   
 6      18   312       17116 10.8   
 7      19  2366       19482 12.3   
 8      20  3615       23097 14.6   
 9      21  3076       26173 16.6   
10      22    36       26209 16.6   
11      23  1025       27234 17.3   
12      24 51146       78380 49.7   
13      25  1058       79438 50.4   
14      26  4045       83483 52.9   
15      27    32       83515 52.9   
16      28    26       83541 53.0   
17      29    29       83570 53.0   
18      30    26       83596 53.0   
19      31    17       83613 53.0   
20      32 14255       97868 62.0   
21      33    10       97878 62.0   
22      34     3       97881 62.0   
# A tibble: 5 × 4
  obj_len     n n_less_than percent
    <int> <int>       <int>   <dbl>
1    1024     8      157741    100.
2    1032     6      157747    100.
3    1041     1      157748    100.
4    4096     2      157750    100.
5    4113     2      157752    100 

Common Sizes
# A tibble: 8 × 2
  obj_len     n
    <int> <int>
1      24 51146
2      48 42982
3      16 14757
4      32 14255
5      64  4165
6      26  4045
7      20  3615
8      21  3076

    157,752 total allocations, total bytes = 6,292,908

Typed allocations
# A tibble: 20 × 3
   func_name                                                           n percent
   <chr>                                                           <int>   <dbl>
 1 List<BigStr*>* Alloc<List<BigStr*>>()                           10089   11.3 
 2 List<runtime_asdl::part_value_t*>* Alloc<List<runtime_asdl::pa…  8010    8.96
 3 runtime_asdl::CommandStatus* Alloc<runtime_asdl::CommandStatus…  5010    5.60
 4 runtime_asdl::Piece* Alloc<runtime_asdl::Piece, BigStr*, bool&…  5003    5.59
 5 List<syntax_asdl::CompoundWord*>* Alloc<List<syntax_asdl::Comp…  4043    4.52
 6 syntax_asdl::word__String* Alloc<syntax_asdl::word__String, in…  4004    4.48
 7 List<int>* Alloc<List<int>>()                                    3021    3.38
 8 mylib::BufWriter* Alloc<mylib::BufWriter>()                      3007    3.36
 9 List<List<runtime_asdl::Piece*>*>* Alloc<List<List<runtime_asd…  3004    3.36
10 List<runtime_asdl::Piece*>* Alloc<List<runtime_asdl::Piece*>>()  3004    3.36
11 List<Tuple2<runtime_asdl::span_e, int>*>* Alloc<List<Tuple2<ru…  3002    3.36
12 List<mylib::BufWriter*>* Alloc<List<mylib::BufWriter*>>()        3002    3.36
13 Tuple2<runtime_asdl::span_e, int>* Alloc<Tuple2<runtime_asdl::…  3002    3.36
14 value_asdl::value__Str* Alloc<value_asdl::value__Str, BigStr*&…  2046    2.29
15 runtime_asdl::VarSubState* Alloc<runtime_asdl::VarSubState, bo…  2005    2.24
16 runtime_asdl::cmd_value__Argv* Alloc<runtime_asdl::cmd_value__…  2004    2.24
17 value_asdl::value__Str* Alloc<value_asdl::value__Str, BigStr*>…  2004    2.24
18 runtime_asdl::Piece* Alloc<runtime_asdl::Piece, BigStr*&, bool…  2003    2.24
19 syntax_asdl::loc__Word* Alloc<syntax_asdl::loc__Word, syntax_a…  2002    2.24
20 syntax_asdl::loc__Arith* Alloc<syntax_asdl::loc__Arith, syntax…  2000    2.24
# A tibble: 5 × 3
  func_name                                                            n percent
  <chr>                                                            <int>   <dbl>
1 value_asdl::value__Proc* Alloc<value_asdl::value__Proc, BigStr*…     1 0.00112
2 word_eval::CompletionWordEvaluator* Alloc<word_eval::Completion…     1 0.00112
3 word_eval::NormalWordEvaluator* Alloc<word_eval::NormalWordEval…     1 0.00112
4 word_eval::TildeEvaluator* Alloc<word_eval::TildeEvaluator, sta…     1 0.00112
5 word_parse::WordParser* Alloc<word_parse::WordParser, parse_lib…     1 0.00112

89,445 typed allocs, including 41,733 List<T>
56.70% of allocs are typed

Str - NewStr() and OverAllocatedStr()
# A tibble: 16 × 4
   str_len     n n_less_than percent
     <int> <int>       <int>   <dbl>
 1       1   312         312    1.98
 2       2  2366        2678   17.0 
 3       3  3615        6293   39.8 
 4       4  3076        9369   59.3 
 5       5    36        9405   59.5 
 6       6  1025       10430   66.0 
 7       7    53       10483   66.4 
 8       8  1058       11541   73.1 
 9       9  4045       15586   98.7 
10      10    32       15618   98.9 
11      11    17       15635   99.0 
12      12    29       15664   99.2 
13      13    26       15690   99.3 
14      14    17       15707   99.4 
15      15     7       15714   99.5 
16      16    10       15724   99.5 
# A tibble: 5 × 4
  str_len     n n_less_than percent
    <int> <int>       <int>   <dbl>
1     134     1       15791    100.
2     202     1       15792    100.
3     255     1       15793    100.
4    1024     1       15794    100.
5    4096     2       15796    100 

15,796 string allocations, total length = 93,498, total bytes = 362,030

10.01% of allocs are strings
5.75% of bytes are strings

NewSlab()
  Lengths
# A tibble: 6 × 4
  slab_len     n n_less_than percent
     <int> <int>       <int>   <dbl>
1        5 36658       36658    69.8
2        7  3076       39734    75.7
3        8  1042       40776    77.7
4       10  3153       43929    83.7
5       14    78       44007    83.8
6       15  2064       46071    87.7
# A tibble: 5 × 4
  slab_len     n n_less_than percent
     <int> <int>       <int>   <dbl>
1      127    11       52466    99.9
2      128    36       52502   100. 
3      254     1       52503   100. 
4      256     6       52509   100. 
5     1022     2       52511   100  

  Slab Types
# A tibble: 6 × 2
  func_name                                                                    n
  <chr>                                                                    <int>
1 Slab<BigStr*>* NewSlab<BigStr*>(int)                                     18189
2 Slab<runtime_asdl::part_value_t*>* NewSlab<runtime_asdl::part_value_t*>…  8010
3 Slab<int>* NewSlab<int>(int)                                              7693
4 Slab<syntax_asdl::CompoundWord*>* NewSlab<syntax_asdl::CompoundWord*>(i…  5033
5 Slab<List<runtime_asdl::Piece*>*>* NewSlab<List<runtime_asdl::Piece*>*>…  3004
6 Slab<runtime_asdl::Piece*>* NewSlab<runtime_asdl::Piece*>(int)            3003
# A tibble: 5 × 2
  func_name                                                                    n
  <chr>                                                                    <int>
1 Slab<syntax_asdl::loc_t*>* NewSlab<syntax_asdl::loc_t*>(int)                 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

52,511 slabs, total items = 515,143
33.29% of allocs are slabs

::reserve(int n)

  Num Items
# A tibble: 15 × 4
   num_items     n n_less_than  percent
       <int> <int>       <int>    <dbl>
 1         0     9           9  0.00965
 2         1 46590       46599 49.9    
 3         2 13221       59820 64.1    
 4         3  9027       68847 73.8    
 5         4 11087       79934 85.7    
 6         5  5048       84982 91.1    
 7         6  3055       88037 94.4    
 8         7  1017       89054 95.5    
 9         8  2035       91089 97.6    
10         9  1013       92102 98.7    
11        10     8       92110 98.7    
12        11    45       92155 98.8    
13        12     7       92162 98.8    
14        13     5       92167 98.8    
15        14     6       92173 98.8    
# A tibble: 5 × 4
  num_items     n n_less_than percent
      <int> <int>       <int>   <dbl>
1        63     1       93282    100.
2        64     5       93287    100.
3       111     2       93289    100.
4       179     1       93290    100.
5      1022     2       93292    100 

93,292 reserve() calls, total items = 242,533

Untyped: 157,752
Typed + Str + Slab: 157,752