Percentage of allocs less than 48 bytes: 89.4

All allocations
# A tibble: 22 × 4
   obj_len     n n_less_than percent
     <int> <int>       <int>   <dbl>
 1       9  3188        3188    2.80
 2      10    73        3261    2.86
 3      11  1002        4263    3.74
 4      12     9        4272    3.75
 5      13     1        4273    3.75
 6      16  7845       12118   10.6 
 7      18 16227       28345   24.9 
 8      19  1707       30052   26.4 
 9      20  1430       31482   27.6 
10      21  2511       33993   29.8 
11      22   519       34512   30.3 
12      23   580       35092   30.8 
13      24 30397       65489   57.5 
14      25  1443       66932   58.8 
15      26  1709       68641   60.3 
16      27   184       68825   60.4 
17      28   159       68984   60.6 
18      29   157       69141   60.7 
19      30   122       69263   60.8 
20      31   104       69367   60.9 
21      32  5307       74674   65.6 
22      33   341       75015   65.9 
# A tibble: 5 × 4
  obj_len     n n_less_than percent
    <int> <int>       <int>   <dbl>
1    1024     8      113875    100.
2    1032     6      113881    100.
3    1041     1      113882    100.
4    4096     2      113884    100.
5    4113     2      113886    100 

Common Sizes
# A tibble: 8 × 2
  obj_len     n
    <int> <int>
1      24 30397
2      48 21736
3      18 16227
4      16  7845
5      32  5307
6      40  4239
7      64  3868
8       9  3188

    113,886 total allocations, total bytes = 4,342,094

Typed allocations
# A tibble: 20 × 3
   func_name                                                           n percent
   <chr>                                                           <int>   <dbl>
 1 List<BigStr*>* Alloc<List<BigStr*>>()                            6457   12.0 
 2 runtime_asdl::Piece* Alloc<runtime_asdl::Piece, BigStr*, bool&…  4353    8.08
 3 List<runtime_asdl::part_value_t*>* Alloc<List<runtime_asdl::pa…  3518    6.53
 4 runtime_asdl::CommandStatus* Alloc<runtime_asdl::CommandStatus…  2971    5.52
 5 value_asdl::value__Bool* Alloc<value_asdl::value__Bool, bool&>…  2884    5.36
 6 Tuple2<runtime_asdl::span_e, int>* Alloc<Tuple2<runtime_asdl::…  2733    5.08
 7 runtime_asdl::Piece* Alloc<runtime_asdl::Piece, BigStr*&, bool…  1925    3.58
 8 List<syntax_asdl::CompoundWord*>* Alloc<List<syntax_asdl::Comp…  1659    3.08
 9 value_asdl::value__Str* Alloc<value_asdl::value__Str, BigStr*>…  1647    3.06
10 List<int>* Alloc<List<int>>()                                    1073    1.99
11 runtime_asdl::VarSubState* Alloc<runtime_asdl::VarSubState, bo…  1002    1.86
12 List<runtime_asdl::Piece*>* Alloc<List<runtime_asdl::Piece*>>()   956    1.78
13 runtime_asdl::Piece* Alloc<runtime_asdl::Piece, BigStr*&, bool…   925    1.72
14 Dict<BigStr*, value_asdl::value_t*>* Alloc<Dict<BigStr*, value…   908    1.69
15 Dict<BigStr*, args::_Action*>* Alloc<Dict<BigStr*, args::_Acti…   906    1.68
16 List<Tuple2<BigStr*, bool>*>* Alloc<List<Tuple2<BigStr*, bool>…   906    1.68
17 args::SetToInt* Alloc<args::SetToInt, BigStr*>(BigStr*&&)         901    1.67
18 value_asdl::value__Int* Alloc<value_asdl::value__Int, int&>(in…   901    1.67
19 value_asdl::value__Str* Alloc<value_asdl::value__Str, BigStr*&…   869    1.61
20 args::SetToString* Alloc<args::SetToString, BigStr*, bool, Lis…   766    1.42
# 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.00186
2 value_asdl::value__List* Alloc<value_asdl::value__List, List<va…     1 0.00186
3 word_eval::CompletionWordEvaluator* Alloc<word_eval::Completion…     1 0.00186
4 word_eval::NormalWordEvaluator* Alloc<word_eval::NormalWordEval…     1 0.00186
5 word_eval::TildeEvaluator* Alloc<word_eval::TildeEvaluator, sta…     1 0.00186

53,842 typed allocs, including 18,235 List<T>
47.28% 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.932
 2       1 16227       16502  56.0  
 3       2  1707       18209  61.7  
 4       3  1429       19638  66.6  
 5       4  2511       22149  75.1  
 6       5   519       22668  76.9  
 7       6   580       23248  78.8  
 8       7   493       23741  80.5  
 9       8  1443       25184  85.4  
10       9  1709       26893  91.2  
11      10   184       27077  91.8  
12      11   152       27229  92.3  
13      12   157       27386  92.9  
14      13   122       27508  93.3  
15      14   104       27612  93.6  
16      15    77       27689  93.9  
# A tibble: 5 × 4
  str_len     n n_less_than percent
    <int> <int>       <int>   <dbl>
1     160     1       29486    100.
2     202     1       29487    100.
3     255     1       29488    100.
4    1024     1       29489    100.
5    4096     2       29491    100 

29,491 string allocations, total length = 148,717, total bytes = 650,064

25.90% of allocs are strings
14.97% 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    54.5
2        7  3493       20296    65.8
3        8  1530       21826    70.8
4       10  1156       22982    74.5
5       14   349       23331    75.7
6       15  2271       25602    83.0
# A tibble: 5 × 4
  slab_len     n n_less_than percent
     <int> <int>       <int>   <dbl>
1      127    11       30783    99.9
2      128    36       30819   100. 
3      254     1       30820   100. 
4      256     6       30826   100. 
5     1022     2       30828   100  

  Slab Types
# A tibble: 6 × 2
  func_name                                                                    n
  <chr>                                                                    <int>
1 Slab<BigStr*>* NewSlab<BigStr*>(int)                                     10097
2 Slab<int>* NewSlab<int>(int)                                              6350
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)            2880
5 Slab<syntax_asdl::CompoundWord*>* NewSlab<syntax_asdl::CompoundWord*>(i…  1778
6 Slab<args::_Action*>* NewSlab<args::_Action*>(int)                         988
# 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

30,828 slabs, total items = 361,403
27.07% 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.00758
 2         1 18676       18681 28.3    
 3         2  7001       25682 38.9    
 4         3  5722       31404 47.6    
 5         4  3314       34718 52.6    
 6         5  3244       37962 57.5    
 7         6  3577       41539 63.0    
 8         7  2515       44054 66.8    
 9         8  2984       47038 71.3    
10         9  1647       48685 73.8    
11        10  1998       50683 76.8    
12        11  1002       51685 78.3    
13        12   857       52542 79.6    
14        13   829       53371 80.9    
15        14   740       54111 82.0    
# A tibble: 5 × 4
  num_items     n n_less_than percent
      <int> <int>       <int>   <dbl>
1        77    15       65961    100.
2        78     8       65969    100.
3       107     2       65971    100.
4       179     1       65972    100.
5      1022     2       65974    100 

65,974 reserve() calls, total items = 622,790

Untyped: 113,886
Typed + Str + Slab: 114,161