Percentage of allocs less than 32 bytes: 56.1

All allocations
# A tibble: 22 x 4
   obj_len     n n_less_than  percent
     <int> <int>       <int>    <dbl>
 1       9    10          10  0.00865
 2      12    63          73  0.0632 
 3      14  7254        7327  6.34   
 4      15  1923        9250  8.01   
 5      16 10049       19299 16.7    
 6      17  1057       20356 17.6    
 7      18   716       21072 18.2    
 8      19   734       21806 18.9    
 9      20   734       22540 19.5    
10      21  1190       23730 20.5    
11      22   571       24301 21.0    
12      23  1026       25327 21.9    
13      24 33580       58907 51.0    
14      25   213       59120 51.2    
15      26   692       59812 51.8    
16      27   115       59927 51.9    
17      28    97       60024 51.9    
18      29   261       60285 52.2    
19      30    97       60382 52.3    
20      31    80       60462 52.3    
21      32  4387       64849 56.1    
22      33    69       64918 56.2    
# A tibble: 5 x 4
  obj_len     n n_less_than percent
    <int> <int>       <int>   <dbl>
1    4104     3      115548    100.
2    4109     1      115549    100.
3    8200     1      115550    100.
4   16392     1      115551    100.
5   32776     1      115552    100 

Common Sizes
# A tibble: 8 x 2
  obj_len     n
    <int> <int>
1      40 43358
2      24 33580
3      16 10049
4      14  7254
5      32  4387
6      72  2035
7      15  1923
8      64  1702

    115,552 total allocations, total bytes = 3,755,500

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.73 
 4 List<Str*>* Alloc<List<Str*>>()                                  4426   6.29 
 5 List<syntax_asdl::CompoundWord*>* Alloc<List<syntax_asdl::Comp~  3269   4.65 
 6 List<syntax_asdl::command_t*>* Alloc<List<syntax_asdl::command~  3227   4.59 
 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*>>()    2484   3.53 
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.89 
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 List<int>* Alloc<List<int>>()                                    1123   1.60 
17 syntax_asdl::DoubleQuoted* Alloc<syntax_asdl::DoubleQuoted, sy~  1072   1.52 
18 syntax_asdl::command__CommandList* Alloc<syntax_asdl::command_~   723   1.03 
19 Tuple2<int, int>* Alloc<Tuple2<int, int>, int, int>(int&&, int~   664   0.944
20 List<syntax_asdl::Token*>* Alloc<List<syntax_asdl::Token*>>()     500   0.711
# A tibble: 5 x 3
  func_name                                                            n percent
  <chr>                                                            <int>   <dbl>
1 ui::ErrorFormatter* Alloc<ui::ErrorFormatter, alloc::Arena*&>(a~     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,369 typed allocs, including 30,171 List<T>
60.90% 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   571       14768    72.0
10      10  1026       15794    77.1
11      11   417       16211    79.1
12      12   213       16424    80.1
13      13   692       17116    83.5
14      14   115       17231    84.1
15      15    97       17328    84.5
16      16   261       17589    85.8
# A tibble: 5 x 4
  str_len     n n_less_than percent
    <int> <int>       <int>   <dbl>
1     132     1       20494    100.
2     134     1       20495    100.
3     137     1       20496    100.
4     196     1       20497    100.
5    4096     1       20498    100 

20,498 string allocations, total length = 201,540, total bytes = 468,014

17.74% of allocs are strings
12.46% 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.25
2        3 20584       20893   84.6 
3        6  1322       22215   90.0 
4        7  1840       24055   97.4 
5       14   162       24217   98.1 
6       15   154       24371   98.7 
# A tibble: 5 x 4
  slab_len     n n_less_than percent
     <int> <int>       <int>   <dbl>
1      511     1       24680    100.
2     1022     2       24682    100.
3     1023     1       24683    100.
4     2047     1       24684    100.
5     4095     1       24685    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)                                              1970
# 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,685 slabs, total items = 113,322
21.36% 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 21222       21222    50.8
 2         2  7941       29163    69.8
 3         3  2954       32117    76.8
 4         4  2685       34802    83.3
 5         5   871       35673    85.4
 6         6   385       36058    86.3
 7         7   269       36327    86.9
 8         8   200       36527    87.4
 9         9   180       36707    87.8
10        10   140       36847    88.2
11        11   123       36970    88.5
12        12   117       37087    88.7
13        13   104       37191    89.0
14        14    91       37282    89.2
15        15    77       37359    89.4
# A tibble: 5 x 4
  num_items     n n_less_than percent
      <int> <int>       <int>   <dbl>
1      2508     1       41788    100.
2      2509     1       41789    100.
3      2510     1       41790    100.
4      2511     1       41791    100.
5      2512     1       41792    100 

41,792 reserve() calls, total items = 3,312,116

Untyped: 115,552
Typed + Str + Slab: 115,552