Percentage of allocs less than 48 bytes: 96.4

All allocations
# A tibble: 22 x 4
   obj_len     n n_less_than percent
     <int> <int>       <int>   <dbl>
 1       9    17          17  0.0153
 2      12    63          80  0.0721
 3      16  9471        9551  8.60  
 4      18  7364       16915 15.2   
 5      19  1923       18838 17.0   
 6      20   591       19429 17.5   
 7      21  1069       20498 18.5   
 8      22   724       21222 19.1   
 9      23   739       21961 19.8   
10      24 33561       55522 50.0   
11      25   653       56175 50.6   
12      26   410       56585 51.0   
13      27   455       57040 51.4   
14      28   417       57457 51.8   
15      29   211       57668 51.9   
16      30   155       57823 52.1   
17      31   112       57935 52.2   
18      32  4346       62281 56.1   
19      33   124       62405 56.2   
20      34    79       62484 56.3   
21      35    77       62561 56.4   
22      36    82       62643 56.4   
# A tibble: 5 x 4
  obj_len     n n_less_than percent
    <int> <int>       <int>   <dbl>
1   16384     2      111016    100.
2   32768     2      111018    100.
3   65536     1      111019    100.
4  131072     1      111020    100.
5  262144     1      111021    100 

Common Sizes
# A tibble: 8 x 2
  obj_len     n
    <int> <int>
1      24 33561
2      48 22559
3      40 21257
4      16  9471
5      18  7364
6      32  4346
7      19  1923
8      64  1896

    111,021 total allocations, total bytes = 4,334,235

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<BigStr*>* Alloc<List<BigStr*>>()                            4441   6.31 
 5 List<syntax_asdl::CompoundWord*>* Alloc<List<syntax_asdl::Comp~  3271   4.65 
 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<syntax_asdl::ParsedAssignment*>* Alloc<List<syntax_asdl::~  1589   2.26 
11 syntax_asdl::SimpleVarSub* Alloc<syntax_asdl::SimpleVarSub, sy~  1327   1.89 
12 List<Tuple2<BigStr*, int>*>* Alloc<List<Tuple2<BigStr*, 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~   545   0.774
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 value_asdl::value__Int* Alloc<value_asdl::value__Int, int&>(int~     1 0.00142
2 value_asdl::value__List* Alloc<value_asdl::value__List, List<va~     1 0.00142
3 word_eval::CompletionWordEvaluator* Alloc<word_eval::Completion~     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,383 typed allocs, including 30,016 List<T>
63.40% 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  7364        7364    41.6
 2       2  1923        9287    52.5
 3       3   591        9878    55.8
 4       4  1069       10947    61.9
 5       5   724       11671    66.0
 6       6   739       12410    70.1
 7       7   746       13156    74.4
 8       8   653       13809    78.1
 9       9   410       14219    80.4
10      10   455       14674    82.9
11      11   403       15077    85.2
12      12   211       15288    86.4
13      13   155       15443    87.3
14      14   112       15555    87.9
15      15   101       15656    88.5
16      16   124       15780    89.2
# A tibble: 5 x 4
  str_len     n n_less_than percent
    <int> <int>       <int>   <dbl>
1     134     1       17688    100.
2     137     1       17689    100.
3     196     1       17690    100.
4     255     1       17691    100.
5    4096     1       17692    100 

17,692 string allocations, total length = 135,598, total bytes = 436,362

15.94% of allocs are strings
10.07% of bytes are strings

NewSlab()
  Lengths
# A tibble: 6 x 4
  slab_len     n n_less_than percent
     <int> <int>       <int>   <dbl>
1        5 20604       20604    89.8
2        7   372       20976    91.4
3        8    35       21011    91.6
4       10  1192       22203    96.8
5       14    76       22279    97.1
6       15   192       22471    97.9
# A tibble: 5 x 4
  slab_len     n n_less_than percent
     <int> <int>       <int>   <dbl>
1     2047     2       22941    100.
2     4095     2       22943    100.
3     8191     1       22944    100.
4    16383     1       22945    100.
5    32767     1       22946    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)  7413
2 Slab<syntax_asdl::CompoundWord*>* NewSlab<syntax_asdl::CompoundWord*>(i~  3215
3 Slab<BigStr*>* NewSlab<BigStr*>(int)                                      3169
4 Slab<syntax_asdl::command_t*>* NewSlab<syntax_asdl::command_t*>(int)      3158
5 Slab<syntax_asdl::word_t*>* NewSlab<syntax_asdl::word_t*>(int)            2783
6 Slab<int>* NewSlab<int>(int)                                              1707
# A tibble: 5 x 2
  func_name                                                                    n
  <chr>                                                                    <int>
1 Slab<state::_ArgFrame*>* NewSlab<state::_ArgFrame*>(int)                     1
2 Slab<syntax_asdl::debug_frame_t*>* NewSlab<syntax_asdl::debug_frame_t*>~     1
3 Slab<value_asdl::regex_match_t*>* NewSlab<value_asdl::regex_match_t*>(i~     1
4 Slab<value_asdl::value__Dict*>* NewSlab<value_asdl::value__Dict*>(int)       1
5 Slab<vm::_AssignBuiltin*>* NewSlab<vm::_AssignBuiltin*>(int)                 1

22,946 slabs, total items = 220,897
20.67% 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         0     2           2  0.00332
 2         1 21178       21180 35.1    
 3         2  7837       29017 48.1    
 4         3  2878       31895 52.9    
 5         4  2559       34454 57.1    
 6         5   810       35264 58.5    
 7         6   351       35615 59.1    
 8         7   214       35829 59.4    
 9         8   167       35996 59.7    
10         9   130       36126 59.9    
11        10    92       36218 60.1    
12        11   116       36334 60.3    
13        12    74       36408 60.4    
14        13    60       36468 60.5    
15        14    49       36517 60.6    
# A tibble: 5 x 4
  num_items     n n_less_than percent
      <int> <int>       <int>   <dbl>
1     20388     1       60286    100.
2     20389     1       60287    100.
3     20390     1       60288    100.
4     20391     1       60289    100.
5     20392     1       60290    100 

60,290 reserve() calls, total items = 212,788,801

Untyped: 111,021
Typed + Str + Slab: 111,021