Percentage of allocs less than 32 bytes: 55.8

All allocations
# A tibble: 22 x 4
   obj_len     n n_less_than  percent
     <int> <int>       <int>    <dbl>
 1       9    10          10  0.00887
 2      12    63          73  0.0648 
 3      14  7254        7327  6.50   
 4      15  1923        9250  8.21   
 5      16 10158       19408 17.2    
 6      17  1057       20465 18.2    
 7      18   716       21181 18.8    
 8      19   734       21915 19.4    
 9      20   734       22649 20.1    
10      21   653       23302 20.7    
11      22   411       23713 21.0    
12      23   480       24193 21.5    
13      24 33538       57731 51.2    
14      25   215       57946 51.4    
15      26   152       58098 51.6    
16      27   115       58213 51.7    
17      28    97       58310 51.7    
18      29   121       58431 51.9    
19      30    77       58508 51.9    
20      31    80       58588 52.0    
21      32  4316       62904 55.8    
22      33    72       62976 55.9    
# A tibble: 5 x 4
  obj_len     n n_less_than percent
    <int> <int>       <int>   <dbl>
1    4104     3      112673    100.
2    4109     1      112674    100.
3    8200     1      112675    100.
4   16392     1      112676    100.
5   32776     1      112677    100 

Common Sizes
# A tibble: 8 x 2
  obj_len     n
    <int> <int>
1      40 43325
2      24 33538
3      16 10158
4      14  7254
5      32  4316
6      72  2033
7      15  1923
8      64  1432

    112,677 total allocations, total bytes = 3,651,863

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.2  
 2 List<syntax_asdl::word_part_t*>* Alloc<List<syntax_asdl::word_~  7307  10.4  
 3 syntax_asdl::CompoundWord* Alloc<syntax_asdl::CompoundWord, Li~  6143   8.72 
 4 List<Str*>* Alloc<List<Str*>>()                                  4426   6.28 
 5 List<syntax_asdl::CompoundWord*>* Alloc<List<syntax_asdl::Comp~  3269   4.64 
 6 List<syntax_asdl::command_t*>* Alloc<List<syntax_asdl::command~  3227   4.58 
 7 List<syntax_asdl::word_t*>* Alloc<List<syntax_asdl::word_t*>>()  2634   3.74 
 8 syntax_asdl::SourceLine* Alloc<syntax_asdl::SourceLine, int&, ~  2512   3.57 
 9 List<syntax_asdl::Redir*>* Alloc<List<syntax_asdl::Redir*>>()    2457   3.49 
10 List<Tuple4<syntax_asdl::Token*, syntax_asdl::Token*, int, syn~  1589   2.26 
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.71 
14 syntax_asdl::command__Simple* Alloc<syntax_asdl::command__Simp~  1202   1.71 
15 syntax_asdl::loc__Word* Alloc<syntax_asdl::loc__Word, syntax_a~  1202   1.71 
16 syntax_asdl::DoubleQuoted* Alloc<syntax_asdl::DoubleQuoted, sy~  1072   1.52 
17 List<int>* Alloc<List<int>>()                                    1053   1.50 
18 syntax_asdl::command__CommandList* Alloc<syntax_asdl::command_~   723   1.03 
19 Tuple2<int, int>* Alloc<Tuple2<int, int>, int, int>(int&&, int~   703   0.998
20 List<syntax_asdl::Token*>* Alloc<List<syntax_asdl::Token*>>()     500   0.710
# A tibble: 5 x 3
  func_name                                                            n percent
  <chr>                                                            <int>   <dbl>
1 ui::ErrorFormatter* Alloc<ui::ErrorFormatter>()                      1 0.00142
2 util::DebugFile* Alloc<util::DebugFile, mylib::Writer*>(mylib::~     1 0.00142
3 util::NullDebugFile* Alloc<util::NullDebugFile>()                    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,427 typed allocs, including 30,108 List<T>
62.50% 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  7254        7254    41.3
 2       2  1923        9177    52.2
 3       3   589        9766    55.5
 4       4  1057       10823    61.6
 5       5   716       11539    65.6
 6       6   734       12273    69.8
 7       7   734       13007    74.0
 8       8   653       13660    77.7
 9       9   411       14071    80.0
10      10   480       14551    82.8
11      11   417       14968    85.1
12      12   215       15183    86.3
13      13   152       15335    87.2
14      14   115       15450    87.9
15      15    97       15547    88.4
16      16   121       15668    89.1
# A tibble: 5 x 4
  str_len     n n_less_than percent
    <int> <int>       <int>   <dbl>
1     134     1       17580    100.
2     137     1       17581    100.
3     196     1       17582    100.
4     255     1       17583    100.
5    4096     1       17584    100 

17,584 string allocations, total length = 135,745, total bytes = 364,337

15.61% of allocs are strings
9.98% of bytes are strings

NewSlab()
  Lengths
# A tibble: 6 x 4
  slab_len     n n_less_than percent
     <int> <int>       <int>   <dbl>
1        2   324         324    1.31
2        3 20617       20941   84.9 
3        6  1249       22190   90.0 
4        7  1845       24035   97.4 
5       14   165       24200   98.1 
6       15   155       24355   98.7 
# A tibble: 5 x 4
  slab_len     n n_less_than percent
     <int> <int>       <int>   <dbl>
1      511     1       24661    100.
2     1022     2       24663    100.
3     1023     1       24664    100.
4     2047     1       24665    100.
5     4095     1       24666    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~  3806
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)                                            3113
6 Slab<int>* NewSlab<int>(int)                                              1912
# A tibble: 5 x 2
  func_name                                                              n
  <chr>                                                              <int>
1 Slab<process::_FdFrame*>* NewSlab<process::_FdFrame*>(int)             1
2 Slab<runtime_asdl::HayNode*>* NewSlab<runtime_asdl::HayNode*>(int)     1
3 Slab<state::DebugFrame*>* NewSlab<state::DebugFrame*>(int)             1
4 Slab<state::_ArgFrame*>* NewSlab<state::_ArgFrame*>(int)               1
5 Slab<void*>* NewSlab<void*>(int)                                       1

24,666 slabs, total items = 112,823
21.89% 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         1 21250       21250    50.8
 2         2  7956       29206    69.8
 3         3  2959       32165    76.9
 4         4  2621       34786    83.2
 5         5   876       35662    85.3
 6         6   388       36050    86.2
 7         7   270       36320    86.8
 8         8   202       36522    87.3
 9         9   182       36704    87.8
10        10   142       36846    88.1
11        11   125       36971    88.4
12        12   119       37090    88.7
13        13   105       37195    88.9
14        14    92       37287    89.1
15        15    77       37364    89.3
# A tibble: 5 x 4
  num_items     n n_less_than percent
      <int> <int>       <int>   <dbl>
1      2508     1       41822    100.
2      2509     1       41823    100.
3      2510     1       41824    100.
4      2511     1       41825    100.
5      2512     1       41826    100 

41,826 reserve() calls, total items = 3,314,879

Untyped: 112,677
Typed + Str + Slab: 112,677