Percentage of allocs less than 48 bytes: 95.2

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.0647 
 3      16  9585        9658  8.56   
 4      18  7254       16912 15.0    
 5      19  1923       18835 16.7    
 6      20   589       19424 17.2    
 7      21  1063       20487 18.2    
 8      22   717       21204 18.8    
 9      23   736       21940 19.5    
10      24 33883       55823 49.5    
11      25   655       56478 50.1    
12      26   411       56889 50.4    
13      27   480       57369 50.9    
14      28   418       57787 51.2    
15      29   215       58002 51.4    
16      30   152       58154 51.6    
17      31   115       58269 51.7    
18      32  4337       62606 55.5    
19      33   121       62727 55.6    
20      34    77       62804 55.7    
21      35    79       62883 55.8    
22      36    76       62959 55.8    
# A tibble: 5 x 4
  obj_len     n n_less_than percent
    <int> <int>       <int>   <dbl>
1   16392     2      112769    100.
2   32776     2      112771    100.
3   65544     1      112772    100.
4  131080     1      112773    100.
5  262152     1      112774    100 

Common Sizes
# A tibble: 8 x 2
  obj_len     n
    <int> <int>
1      40 43347
2      24 33883
3      16  9585
4      18  7254
5      32  4337
6      72  2035
7      19  1923
8      64  1448

    112,774 total allocations, total bytes = 4,251,002

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.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.56 
 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.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.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.49 
18 syntax_asdl::command__CommandList* Alloc<syntax_asdl::command_~   723   1.03 
19 Tuple2<int, int>* Alloc<Tuple2<int, int>, int, int>(int&&, int~   713   1.01 
20 List<syntax_asdl::Token*>* Alloc<List<syntax_asdl::Token*>>()     500   0.709
# 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,483 typed allocs, including 30,118 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.2
 2       2  1923        9177    52.2
 3       3   589        9766    55.5
 4       4  1063       10829    61.6
 5       5   717       11546    65.6
 6       6   736       12282    69.8
 7       7   735       13017    74.0
 8       8   655       13672    77.7
 9       9   411       14083    80.1
10      10   480       14563    82.8
11      11   418       14981    85.2
12      12   215       15196    86.4
13      13   152       15348    87.2
14      14   115       15463    87.9
15      15    97       15560    88.4
16      16   121       15681    89.1
# A tibble: 5 x 4
  str_len     n n_less_than percent
    <int> <int>       <int>   <dbl>
1     134     1       17588    100.
2     137     1       17589    100.
3     196     1       17590    100.
4     255     1       17591    100.
5    4096     1       17592    100 

17,592 string allocations, total length = 135,692, total bytes = 434,756

15.60% of allocs are strings
10.23% of bytes are strings

NewSlab()
  Lengths
# A tibble: 6 x 4
  slab_len     n n_less_than percent
     <int> <int>       <int>   <dbl>
1        2   330         330    1.34
2        3 20626       20956   84.8 
3        6  1249       22205   89.9 
4        7  1848       24053   97.4 
5       14   165       24218   98.1 
6       15   156       24374   98.7 
# A tibble: 5 x 4
  slab_len     n n_less_than percent
     <int> <int>       <int>   <dbl>
1     2047     2       24694    100.
2     4095     2       24696    100.
3     8191     1       24697    100.
4    16383     1       24698    100.
5    32767     1       24699    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)                                            3114
6 Slab<int>* NewSlab<int>(int)                                              1919
# 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::DebugFrame*>* NewSlab<state::DebugFrame*>(int)             1
5 Slab<state::_ArgFrame*>* NewSlab<state::_ArgFrame*>(int)               1

24,699 slabs, total items = 178,769
21.90% 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 21258       21258    34.1
 2         2  7961       29219    46.8
 3         3  2963       32182    51.6
 4         4  2624       34806    55.8
 5         5   879       35685    57.2
 6         6   391       36076    57.8
 7         7   272       36348    58.2
 8         8   203       36551    58.6
 9         9   183       36734    58.9
10        10   143       36877    59.1
11        11   126       37003    59.3
12        12   120       37123    59.5
13        13   106       37229    59.7
14        14    93       37322    59.8
15        15    78       37400    59.9
# A tibble: 5 x 4
  num_items     n n_less_than percent
      <int> <int>       <int>   <dbl>
1     20388     1       62400    100.
2     20389     1       62401    100.
3     20390     1       62402    100.
4     20391     1       62403    100.
5     20392     1       62404    100 

62,404 reserve() calls, total items = 212,843,667

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