Percentage of allocs less than 48 bytes: 95.1

All allocations
# A tibble: 22 x 4
   obj_len     n n_less_than percent
     <int> <int>       <int>   <dbl>
 1       9    17          17  0.0150
 2      12    63          80  0.0707
 3      16  9620        9700  8.57  
 4      18  7364       17064 15.1   
 5      19  1923       18987 16.8   
 6      20   593       19580 17.3   
 7      21  1071       20651 18.2   
 8      22   726       21377 18.9   
 9      23   740       22117 19.5   
10      24 33888       56005 49.5   
11      25   665       56670 50.0   
12      26   419       57089 50.4   
13      27   474       57563 50.8   
14      28   417       57980 51.2   
15      29   218       58198 51.4   
16      30   152       58350 51.5   
17      31   115       58465 51.6   
18      32  4345       62810 55.5   
19      33   121       62931 55.6   
20      34    77       63008 55.6   
21      35    79       63087 55.7   
22      36    76       63163 55.8   
# A tibble: 5 x 4
  obj_len     n n_less_than percent
    <int> <int>       <int>   <dbl>
1   16392     2      113229    100.
2   32776     2      113231    100.
3   65544     1      113232    100.
4  131080     1      113233    100.
5  262152     1      113234    100 

Common Sizes
# A tibble: 8 x 2
  obj_len     n
    <int> <int>
1      40 43188
2      24 33888
3      16  9620
4      18  7364
5      32  4345
6      72  2080
7      19  1923
8      64  1452

    113,234 total allocations, total bytes = 4,295,362

Typed allocations
# A tibble: 20 x 3
   func_name                                                           n percent
   <chr>                                                           <int>   <dbl>
 1 syntax_asdl::Token* Alloc<syntax_asdl::Token, int&, int&, int&~ 20544  29.1  
 2 List<syntax_asdl::word_part_t*>* Alloc<List<syntax_asdl::word_~  7307  10.3  
 3 syntax_asdl::CompoundWord* Alloc<syntax_asdl::CompoundWord, Li~  6143   8.69 
 4 List<Str*>* Alloc<List<Str*>>()                                  4442   6.29 
 5 List<syntax_asdl::CompoundWord*>* Alloc<List<syntax_asdl::Comp~  3271   4.63 
 6 List<syntax_asdl::command_t*>* Alloc<List<syntax_asdl::command~  3227   4.57 
 7 List<syntax_asdl::word_t*>* Alloc<List<syntax_asdl::word_t*>>()  2634   3.73 
 8 syntax_asdl::SourceLine* Alloc<syntax_asdl::SourceLine, int&, ~  2512   3.55 
 9 List<syntax_asdl::Redir*>* Alloc<List<syntax_asdl::Redir*>>()    2457   3.48 
10 List<Tuple4<syntax_asdl::Token*, syntax_asdl::Token*, int, syn~  1589   2.25 
11 syntax_asdl::SimpleVarSub* Alloc<syntax_asdl::SimpleVarSub, sy~  1327   1.88 
12 List<Tuple2<Str*, int>*>* Alloc<List<Tuple2<Str*, int>*>>()      1291   1.83 
13 List<syntax_asdl::EnvPair*>* Alloc<List<syntax_asdl::EnvPair*>~  1202   1.70 
14 syntax_asdl::command__Simple* Alloc<syntax_asdl::command__Simp~  1202   1.70 
15 syntax_asdl::loc__Word* Alloc<syntax_asdl::loc__Word, syntax_a~  1202   1.70 
16 syntax_asdl::DoubleQuoted* Alloc<syntax_asdl::DoubleQuoted, sy~  1072   1.52 
17 List<int>* Alloc<List<int>>()                                    1053   1.49 
18 syntax_asdl::command__CommandList* Alloc<syntax_asdl::command_~   723   1.02 
19 Tuple2<int, int>* Alloc<Tuple2<int, int>, int, int>(int&&, int~   706   0.999
20 List<syntax_asdl::Token*>* Alloc<List<syntax_asdl::Token*>>()     500   0.708
# A tibble: 5 x 3
  func_name                                                            n percent
  <chr>                                                            <int>   <dbl>
1 util::DebugFile* Alloc<util::DebugFile, mylib::Writer*>(mylib::~     1 0.00142
2 util::NullDebugFile* Alloc<util::NullDebugFile>()                    1 0.00142
3 word_eval::CompletionWordEvaluator* Alloc<word_eval::Completion~     1 0.00142
4 word_eval::NormalWordEvaluator* Alloc<word_eval::NormalWordEval~     1 0.00142
5 word_eval::TildeEvaluator* Alloc<word_eval::TildeEvaluator, sta~     1 0.00142

70,665 typed allocs, including 30,141 List<T>
62.41% 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       1  7364        7364    41.5
 2       2  1923        9287    52.3
 3       3   593        9880    55.6
 4       4  1071       10951    61.7
 5       5   726       11677    65.7
 6       6   740       12417    69.9
 7       7   751       13168    74.1
 8       8   665       13833    77.9
 9       9   419       14252    80.2
10      10   474       14726    82.9
11      11   417       15143    85.3
12      12   218       15361    86.5
13      13   152       15513    87.3
14      14   115       15628    88.0
15      15   101       15729    88.6
16      16   121       15850    89.2
# A tibble: 5 x 4
  str_len     n n_less_than percent
    <int> <int>       <int>   <dbl>
1     134     1       17757    100.
2     137     1       17758    100.
3     196     1       17759    100.
4     255     1       17760    100.
5    4096     1       17761    100 

17,761 string allocations, total length = 136,204, total bytes = 438,141

15.69% of allocs are strings
10.20% of bytes are strings

NewSlab()
  Lengths
# A tibble: 6 x 4
  slab_len     n n_less_than percent
     <int> <int>       <int>   <dbl>
1        2   244         244   0.984
2        3 20760       21004  84.7  
3        6  1200       22204  89.5  
4        7  1856       24060  97.0  
5        9    76       24136  97.3  
6       14   122       24258  97.8  
# A tibble: 5 x 4
  slab_len     n n_less_than percent
     <int> <int>       <int>   <dbl>
1     2047     2       24803    100.
2     4095     2       24805    100.
3     8191     1       24806    100.
4    16383     1       24807    100.
5    32767     1       24808    100 

  Slab Types
# A tibble: 6 x 2
  func_name                                                                    n
  <chr>                                                                    <int>
1 Slab<syntax_asdl::word_part_t*>* NewSlab<syntax_asdl::word_part_t*>(int)  7628
2 Slab<syntax_asdl::CompoundWord*>* NewSlab<syntax_asdl::CompoundWord*>(i~  3808
3 Slab<syntax_asdl::word_t*>* NewSlab<syntax_asdl::word_t*>(int)            3379
4 Slab<syntax_asdl::command_t*>* NewSlab<syntax_asdl::command_t*>(int)      3211
5 Slab<Str*>* NewSlab<Str*>(int)                                            3165
6 Slab<int>* NewSlab<int>(int)                                              1950
# A tibble: 5 x 2
  func_name                                                                    n
  <chr>                                                                    <int>
1 Slab<bool>* NewSlab<bool>(int)                                               1
2 Slab<process::_FdFrame*>* NewSlab<process::_FdFrame*>(int)                   1
3 Slab<runtime_asdl::HayNode*>* NewSlab<runtime_asdl::HayNode*>(int)           1
4 Slab<state::_ArgFrame*>* NewSlab<state::_ArgFrame*>(int)                     1
5 Slab<syntax_asdl::debug_frame_t*>* NewSlab<syntax_asdl::debug_frame_t*>~     1

24,808 slabs, total items = 182,502
21.91% 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     2           2  0.00330
 2         1 21282       21284 35.1    
 3         2  7881       29165 48.2    
 4         3  2980       32145 53.1    
 5         4  2569       34714 57.3    
 6         5   822       35536 58.7    
 7         6   338       35874 59.2    
 8         7   280       36154 59.7    
 9         8   152       36306 59.9    
10         9   132       36438 60.2    
11        10    94       36532 60.3    
12        11    80       36612 60.4    
13        12    75       36687 60.6    
14        13    61       36748 60.7    
15        14    49       36797 60.8    
# A tibble: 5 x 4
  num_items     n n_less_than percent
      <int> <int>       <int>   <dbl>
1     20388     1       60567    100.
2     20389     1       60568    100.
3     20390     1       60569    100.
4     20391     1       60570    100.
5     20392     1       60571    100 

60,571 reserve() calls, total items = 212,789,347

Untyped: 113,234
Typed + Str + Slab: 113,234