Percentage of allocs less than 32 bytes: 57.1

All allocations
# A tibble: 22 x 4
   obj_len     n n_less_than percent
     <int> <int>       <int>   <dbl>
 1       9    77          77  0.0638
 2      12    63         140  0.116 
 3      14  7254        7394  6.13  
 4      15  1923        9317  7.72  
 5      16  9297       18614 15.4   
 6      17  1057       19671 16.3   
 7      18   716       20387 16.9   
 8      19   734       21121 17.5   
 9      20   734       21855 18.1   
10      21  1190       23045 19.1   
11      22   572       23617 19.6   
12      23  1026       24643 20.4   
13      24 37557       62200 51.6   
14      25   213       62413 51.7   
15      26   692       63105 52.3   
16      27   115       63220 52.4   
17      28    97       63317 52.5   
18      29   261       63578 52.7   
19      30    98       63676 52.8   
20      31    79       63755 52.9   
21      32  5169       68924 57.1   
22      33    68       68992 57.2   
# A tibble: 5 x 4
  obj_len     n n_less_than percent
    <int> <int>       <int>   <dbl>
1   16392     2      120606    100.
2   32776     2      120608    100.
3   65544     1      120609    100.
4  131080     1      120610    100.
5  262152     1      120611    100 

Common Sizes
# A tibble: 8 x 2
  obj_len     n
    <int> <int>
1      40 44627
2      24 37557
3      16  9297
4      14  7254
5      32  5169
6      72  2032
7      15  1923
8      64  1703

    120,611 total allocations, total bytes = 4,423,260

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  27.7  
 2 List<syntax_asdl::word_part_t*>* Alloc<List<syntax_asdl::word_~  7307   9.84 
 3 syntax_asdl::compound_word* Alloc<syntax_asdl::compound_word, ~  6143   8.28 
 4 List<int>* Alloc<List<int>>()                                    5276   7.11 
 5 List<Str*>* Alloc<List<Str*>>()                                  4426   5.96 
 6 List<syntax_asdl::compound_word*>* Alloc<List<syntax_asdl::com~  3268   4.40 
 7 List<syntax_asdl::command_t*>* Alloc<List<syntax_asdl::command~  3227   4.35 
 8 List<syntax_asdl::word_t*>* Alloc<List<syntax_asdl::word_t*>>()  2634   3.55 
 9 syntax_asdl::SourceLine* Alloc<syntax_asdl::SourceLine, int&, ~  2512   3.38 
10 List<syntax_asdl::redir*>* Alloc<List<syntax_asdl::redir*>>()    2484   3.35 
11 List<Tuple4<syntax_asdl::Token*, syntax_asdl::Token*, int, syn~  1589   2.14 
12 syntax_asdl::simple_var_sub* Alloc<syntax_asdl::simple_var_sub~  1327   1.79 
13 List<Tuple2<Str*, int>*>* Alloc<List<Tuple2<Str*, int>*>>()      1291   1.74 
14 List<syntax_asdl::env_pair*>* Alloc<List<syntax_asdl::env_pair~  1202   1.62 
15 syntax_asdl::command__Simple* Alloc<syntax_asdl::command__Simp~  1202   1.62 
16 syntax_asdl::loc__Word* Alloc<syntax_asdl::loc__Word, syntax_a~  1202   1.62 
17 syntax_asdl::double_quoted* Alloc<syntax_asdl::double_quoted, ~  1072   1.44 
18 syntax_asdl::command__CommandList* Alloc<syntax_asdl::command_~   723   0.974
19 Tuple2<int, int>* Alloc<Tuple2<int, int>, int, int>(int&&, int~   664   0.894
20 Tuple2<int, int>* Alloc<Tuple2<int, int>, int&, int&>(int&, in~   396   0.533
# A tibble: 5 x 3
  func_name                                                            n percent
  <chr>                                                            <int>   <dbl>
1 ui::ErrorFormatter* Alloc<ui::ErrorFormatter, alloc::Arena*&>(a~     1 0.00135
2 util::DebugFile* Alloc<util::DebugFile, mylib::Writer*>(mylib::~     1 0.00135
3 util::NullDebugFile* Alloc<util::NullDebugFile>()                    1 0.00135
4 word_eval::NormalWordEvaluator* Alloc<word_eval::NormalWordEval~     1 0.00135
5 word_eval::TildeEvaluator* Alloc<word_eval::TildeEvaluator, sta~     1 0.00135

74,233 typed allocs, including 34,003 List<T>
61.55% 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    35.4
 2       2  1923        9177    44.8
 3       3   589        9766    47.6
 4       4  1057       10823    52.8
 5       5   716       11539    56.3
 6       6   734       12273    59.9
 7       7   734       13007    63.5
 8       8  1190       14197    69.3
 9       9   572       14769    72.0
10      10  1026       15795    77.1
11      11   417       16212    79.1
12      12   213       16425    80.1
13      13   692       17117    83.5
14      14   115       17232    84.1
15      15    97       17329    84.5
16      16   261       17590    85.8
# A tibble: 5 x 4
  str_len     n n_less_than percent
    <int> <int>       <int>   <dbl>
1     132     1       20495    100.
2     134     1       20496    100.
3     137     1       20497    100.
4     196     1       20498    100.
5    4096     1       20499    100 

20,499 string allocations, total length = 201,532, total bytes = 468,019

17.00% of allocs are strings
10.58% of bytes are strings

NewSlab()
  Lengths
# A tibble: 6 x 4
  slab_len     n n_less_than percent
     <int> <int>       <int>   <dbl>
1        2   309         309    1.19
2        3 20302       20611   79.6 
3        6  2788       23399   90.4 
4        7  1838       25237   97.5 
5       14   162       25399   98.1 
6       15   155       25554   98.7 
# A tibble: 5 x 4
  slab_len     n n_less_than percent
     <int> <int>       <int>   <dbl>
1     2047     2       25874    100.
2     4095     2       25876    100.
3     8191     1       25877    100.
4    16383     1       25878    100.
5    32767     1       25879    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::compound_word*>* NewSlab<syntax_asdl::compound_word*>~  3805
3 Slab<int>* NewSlab<int>(int)                                              3436
4 Slab<syntax_asdl::word_t*>* NewSlab<syntax_asdl::word_t*>(int)            3379
5 Slab<syntax_asdl::command_t*>* NewSlab<syntax_asdl::command_t*>(int)      3211
6 Slab<Str*>* NewSlab<Str*>(int)                                            3113
# A tibble: 5 x 2
  func_name                                                                n
  <chr>                                                                <int>
1 Slab<runtime_asdl::hay_node*>* NewSlab<runtime_asdl::hay_node*>(int)     1
2 Slab<state::DebugFrame*>* NewSlab<state::DebugFrame*>(int)               1
3 Slab<state::_ArgFrame*>* NewSlab<state::_ArgFrame*>(int)                 1
4 Slab<syntax_asdl::loc_t*>* NewSlab<syntax_asdl::loc_t*>(int)             1
5 Slab<void*>* NewSlab<void*>(int)                                         1

25,879 slabs, total items = 186,766
21.46% 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 22406       22406    34.9
 2         2  8443       30849    48.0
 3         3  3199       34048    53.0
 4         4  2687       36735    57.2
 5         5   871       37606    58.5
 6         6   386       37992    59.1
 7         7   270       38262    59.5
 8         8   201       38463    59.9
 9         9   181       38644    60.1
10        10   141       38785    60.4
11        11   124       38909    60.5
12        12   118       39027    60.7
13        13   105       39132    60.9
14        14    92       39224    61.0
15        15    78       39302    61.2
# A tibble: 5 x 4
  num_items     n n_less_than percent
      <int> <int>       <int>   <dbl>
1     20388     1       64258    100.
2     20389     1       64259    100.
3     20390     1       64260    100.
4     20391     1       64261    100.
5     20392     1       64262    100 

64,262 reserve() calls, total items = 212,842,998

Untyped: 120,611
Typed + Str + Slab: 120,611