Percentage of allocs less than 48 bytes: 90.8

All allocations
# A tibble: 22 × 4
   obj_len     n n_less_than percent
     <int> <int>       <int>   <dbl>
 1       9  2738        2738    2.50
 2      10    73        2811    2.57
 3      11  1002        3813    3.48
 4      12     9        3822    3.49
 5      13     1        3823    3.49
 6      16  7865       11688   10.7 
 7      18 16229       27917   25.5 
 8      19   807       28724   26.2 
 9      20  1502       30226   27.6 
10      21   711       30937   28.3 
11      22   519       31456   28.7 
12      23   580       32036   29.3 
13      24 29972       62008   56.6 
14      25  2569       64577   59.0 
15      26  1709       66286   60.5 
16      27   184       66470   60.7 
17      28   159       66629   60.8 
18      29   157       66786   61.0 
19      30   122       66908   61.1 
20      31   104       67012   61.2 
21      32  5307       72319   66.0 
22      33   341       72660   66.4 
# A tibble: 5 × 4
  obj_len     n n_less_than percent
    <int> <int>       <int>   <dbl>
1    1024     8      109495    100.
2    1032     6      109501    100.
3    1041     1      109502    100.
4    4096     2      109504    100.
5    4113     2      109506    100 

Common Sizes
# A tibble: 8 × 2
  obj_len     n
    <int> <int>
1      24 29972
2      48 21736
3      18 16229
4      16  7865
5      32  5307
6      40  4239
7      64  3418
8       9  2738

    109,506 total allocations, total bytes = 3,906,882

Typed allocations
# A tibble: 20 × 3
   func_name                                                           n percent
   <chr>                                                           <int>   <dbl>
 1 List<BigStr*>* Alloc<List<BigStr*>>()                            6457   12.2 
 2 runtime_asdl::Piece* Alloc<runtime_asdl::Piece, BigStr*, bool&…  4353    8.20
 3 List<runtime_asdl::part_value_t*>* Alloc<List<runtime_asdl::pa…  3518    6.63
 4 runtime_asdl::CommandStatus* Alloc<runtime_asdl::CommandStatus…  2971    5.60
 5 Tuple2<runtime_asdl::span_e, int>* Alloc<Tuple2<runtime_asdl::…  2733    5.15
 6 value_asdl::value__Bool* Alloc<value_asdl::value__Bool, bool&>…  2434    4.59
 7 runtime_asdl::Piece* Alloc<runtime_asdl::Piece, BigStr*&, bool…  1925    3.63
 8 List<syntax_asdl::CompoundWord*>* Alloc<List<syntax_asdl::Comp…  1659    3.13
 9 value_asdl::value__Str* Alloc<value_asdl::value__Str, BigStr*>…  1647    3.10
10 List<int>* Alloc<List<int>>()                                    1080    2.04
11 runtime_asdl::VarSubState* Alloc<runtime_asdl::VarSubState, bo…  1002    1.89
12 List<runtime_asdl::Piece*>* Alloc<List<runtime_asdl::Piece*>>()   956    1.80
13 runtime_asdl::Piece* Alloc<runtime_asdl::Piece, BigStr*&, bool…   925    1.74
14 Dict<BigStr*, value_asdl::value_t*>* Alloc<Dict<BigStr*, value…   908    1.71
15 Dict<BigStr*, args::_Action*>* Alloc<Dict<BigStr*, args::_Acti…   906    1.71
16 List<Tuple2<BigStr*, bool>*>* Alloc<List<Tuple2<BigStr*, bool>…   906    1.71
17 args::SetToInt* Alloc<args::SetToInt, BigStr*>(BigStr*&&)         901    1.70
18 value_asdl::value__Int* Alloc<value_asdl::value__Int, int&>(in…   901    1.70
19 value_asdl::value__Str* Alloc<value_asdl::value__Str, BigStr*&…   869    1.64
20 args::SetToString* Alloc<args::SetToString, BigStr*, bool, Lis…   766    1.44
# A tibble: 5 × 3
  func_name                                                            n percent
  <chr>                                                            <int>   <dbl>
1 value_asdl::value__List* Alloc<value_asdl::value__List, List<va…     1 0.00188
2 value_asdl::value__List* Alloc<value_asdl::value__List, List<va…     1 0.00188
3 word_eval::CompletionWordEvaluator* Alloc<word_eval::Completion…     1 0.00188
4 word_eval::NormalWordEvaluator* Alloc<word_eval::NormalWordEval…     1 0.00188
5 word_eval::TildeEvaluator* Alloc<word_eval::TildeEvaluator, sta…     1 0.00188

53,059 typed allocs, including 18,242 List<T>
48.45% of allocs are typed

Str - NewStr() and OverAllocatedStr()
# A tibble: 16 × 4
   str_len     n n_less_than percent
     <int> <int>       <int>   <dbl>
 1       0   275         275   0.985
 2       1 16229       16504  59.1  
 3       2   807       17311  62.0  
 4       3  1429       18740  67.1  
 5       4   711       19451  69.7  
 6       5   519       19970  71.5  
 7       6   580       20550  73.6  
 8       7   493       21043  75.4  
 9       8  2569       23612  84.6  
10       9  1709       25321  90.7  
11      10   184       25505  91.4  
12      11   152       25657  91.9  
13      12   157       25814  92.5  
14      13   122       25936  92.9  
15      14   104       26040  93.3  
16      15    77       26117  93.5  
# A tibble: 5 × 4
  str_len     n n_less_than percent
    <int> <int>       <int>   <dbl>
1     160     1       27914    100.
2     202     1       27915    100.
3     255     1       27916    100.
4    1024     1       27917    100.
5    4096     2       27919    100 

27,919 string allocations, total length = 148,727, total bytes = 623,350

25.50% of allocs are strings
15.96% of bytes are strings

NewSlab()
  Lengths
# A tibble: 6 × 4
  slab_len     n n_less_than percent
     <int> <int>       <int>   <dbl>
1        5 16803       16803    58.3
2        7  3043       19846    68.9
3        8  1530       21376    74.2
4       10  1156       22532    78.2
5       14   349       22881    79.4
6       15  2271       25152    87.3
# A tibble: 5 × 4
  slab_len     n n_less_than percent
     <int> <int>       <int>   <dbl>
1      127    11       28758    99.8
2      128    36       28794   100. 
3      254     1       28795   100. 
4      256     6       28801   100. 
5     1022     2       28803   100  

  Slab Types
# A tibble: 6 × 2
  func_name                                                                    n
  <chr>                                                                    <int>
1 Slab<BigStr*>* NewSlab<BigStr*>(int)                                      9422
2 Slab<int>* NewSlab<int>(int)                                              5675
3 Slab<runtime_asdl::part_value_t*>* NewSlab<runtime_asdl::part_value_t*>…  4129
4 Slab<value_asdl::value_t*>* NewSlab<value_asdl::value_t*>(int)            2430
5 Slab<syntax_asdl::CompoundWord*>* NewSlab<syntax_asdl::CompoundWord*>(i…  1778
6 Slab<runtime_asdl::Piece*>* NewSlab<runtime_asdl::Piece*>(int)             956
# A tibble: 5 × 2
  func_name                                                                    n
  <chr>                                                                    <int>
1 Slab<syntax_asdl::printf_part_t*>* NewSlab<syntax_asdl::printf_part_t*>…     1
2 Slab<value_asdl::regex_match_t*>* NewSlab<value_asdl::regex_match_t*>(i…     1
3 Slab<value_asdl::value__Dict*>* NewSlab<value_asdl::value__Dict*>(int)       1
4 Slab<value_asdl::value__Proc*>* NewSlab<value_asdl::value__Proc*>(int)       1
5 Slab<vm::_AssignBuiltin*>* NewSlab<vm::_AssignBuiltin*>(int)                 1

28,803 slabs, total items = 297,953
26.30% of allocs are slabs

::reserve(int n)

  Num Items
# A tibble: 15 × 4
   num_items     n n_less_than  percent
       <int> <int>       <int>    <dbl>
 1         0     5           5  0.00766
 2         1 18676       18681 28.6    
 3         2  7001       25682 39.3    
 4         3  5722       31404 48.1    
 5         4  3314       34718 53.2    
 6         5  3244       37962 58.1    
 7         6  3352       41314 63.3    
 8         7  2515       43829 67.1    
 9         8  2984       46813 71.7    
10         9  1647       48460 74.2    
11        10  1998       50458 77.3    
12        11  1003       51461 78.8    
13        12   857       52318 80.1    
14        13   829       53147 81.4    
15        14   740       53887 82.5    
# A tibble: 5 × 4
  num_items     n n_less_than percent
      <int> <int>       <int>   <dbl>
1        77    15       65287    100.
2        78     8       65295    100.
3       109     2       65297    100.
4       179     1       65298    100.
5      1022     2       65300    100 

65,300 reserve() calls, total items = 614,255

Untyped: 109,506
Typed + Str + Slab: 109,781