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 33540       57733 51.2    
14      25   215       57948 51.4    
15      26   152       58100 51.6    
16      27   115       58215 51.7    
17      28    97       58312 51.7    
18      29   121       58433 51.9    
19      30    77       58510 51.9    
20      31    80       58590 52.0    
21      32  4316       62906 55.8    
22      33    72       62978 55.9    
# A tibble: 5 x 4
  obj_len     n n_less_than percent
    <int> <int>       <int>   <dbl>
1    4104     3      112679    100.
2    4109     1      112680    100.
3    8200     1      112681    100.
4   16392     1      112682    100.
5   32776     1      112683    100 

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

    112,683 total allocations, total bytes = 3,652,103

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,430 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.60% 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   327         327    1.33
2        3 20617       20944   84.9 
3        6  1249       22193   90.0 
4        7  1845       24038   97.4 
5       14   165       24203   98.1 
6       15   155       24358   98.7 
# A tibble: 5 x 4
  slab_len     n n_less_than percent
     <int> <int>       <int>   <dbl>
1      511     1       24664    100.
2     1022     2       24666    100.
3     1023     1       24667    100.
4     2047     1       24668    100.
5     4095     1       24669    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)                                              1914
# 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,669 slabs, total items = 112,829
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 21251       21251    50.8
 2         2  7957       29208    69.8
 3         3  2959       32167    76.9
 4         4  2621       34788    83.2
 5         5   876       35664    85.3
 6         6   388       36052    86.2
 7         7   270       36322    86.8
 8         8   202       36524    87.3
 9         9   182       36706    87.8
10        10   142       36848    88.1
11        11   125       36973    88.4
12        12   119       37092    88.7
13        13   105       37197    88.9
14        14    92       37289    89.1
15        15    77       37366    89.3
# A tibble: 5 x 4
  num_items     n n_less_than percent
      <int> <int>       <int>   <dbl>
1      2508     1       41824    100.
2      2509     1       41825    100.
3      2510     1       41826    100.
4      2511     1       41827    100.
5      2512     1       41828    100 

41,828 reserve() calls, total items = 3,314,882

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