Percentage of allocs less than 48 bytes: 90.7

All allocations
# A tibble: 22 × 4
   obj_len     n n_less_than percent
     <int> <int>       <int>   <dbl>
 1       9  3042        3042    2.74
 2      10    73        3115    2.81
 3      11  1002        4117    3.71
 4      12     9        4126    3.72
 5      13     1        4127    3.72
 6      16  7866       11993   10.8 
 7      18 17139       29132   26.3 
 8      19   807       29939   27.0 
 9      20  1502       31441   28.4 
10      21   711       32152   29.0 
11      22   519       32671   29.5 
12      23   580       33251   30.0 
13      24 29973       63224   57.0 
14      25  2568       65792   59.3 
15      26  1709       67501   60.9 
16      27   184       67685   61.0 
17      28   159       67844   61.2 
18      29   157       68001   61.3 
19      30   122       68123   61.4 
20      31   104       68227   61.5 
21      32  5307       73534   66.3 
22      33   341       73875   66.6 
# A tibble: 5 × 4
  obj_len     n n_less_than percent
    <int> <int>       <int>   <dbl>
1    1024     8      110862    100.
2    1032     6      110868    100.
3    1041     1      110869    100.
4    4096     2      110871    100.
5    4113     2      110873    100 

Common Sizes
# A tibble: 8 × 2
  obj_len     n
    <int> <int>
1      24 29973
2      48 21585
3      18 17139
4      16  7866
5      32  5307
6      40  4238
7      64  3418
8       9  3042

    110,873 total allocations, total bytes = 3,946,693

Typed allocations
# A tibble: 20 × 3
   func_name                                                           n percent
   <chr>                                                           <int>   <dbl>
 1 List<BigStr*>* Alloc<List<BigStr*>>()                            6457   12.1 
 2 runtime_asdl::Piece* Alloc<runtime_asdl::Piece, BigStr*, bool&…  4353    8.16
 3 List<runtime_asdl::part_value_t*>* Alloc<List<runtime_asdl::pa…  3518    6.59
 4 runtime_asdl::CommandStatus* Alloc<runtime_asdl::CommandStatus…  2971    5.57
 5 value_asdl::value__Bool* Alloc<value_asdl::value__Bool, bool&>…  2738    5.13
 6 Tuple2<runtime_asdl::span_e, int>* Alloc<Tuple2<runtime_asdl::…  2733    5.12
 7 runtime_asdl::Piece* Alloc<runtime_asdl::Piece, BigStr*&, bool…  1925    3.61
 8 List<syntax_asdl::CompoundWord*>* Alloc<List<syntax_asdl::Comp…  1659    3.11
 9 value_asdl::value__Str* Alloc<value_asdl::value__Str, BigStr*>…  1647    3.09
10 List<int>* Alloc<List<int>>()                                    1080    2.02
11 runtime_asdl::VarSubState* Alloc<runtime_asdl::VarSubState, bo…  1002    1.88
12 List<runtime_asdl::Piece*>* Alloc<List<runtime_asdl::Piece*>>()   956    1.79
13 runtime_asdl::Piece* Alloc<runtime_asdl::Piece, BigStr*&, bool…   925    1.73
14 Dict<BigStr*, value_asdl::value_t*>* Alloc<Dict<BigStr*, value…   908    1.70
15 Dict<BigStr*, args::_Action*>* Alloc<Dict<BigStr*, args::_Acti…   906    1.70
16 List<Tuple2<BigStr*, bool>*>* Alloc<List<Tuple2<BigStr*, bool>…   906    1.70
17 args::SetToInt* Alloc<args::SetToInt, BigStr*>(BigStr*&&)         901    1.69
18 value_asdl::value__Int* Alloc<value_asdl::value__Int, int&>(in…   901    1.69
19 value_asdl::value__Str* Alloc<value_asdl::value__Str, BigStr*&…   870    1.63
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.00187
2 value_asdl::value__List* Alloc<value_asdl::value__List, List<va…     1 0.00187
3 word_eval::CompletionWordEvaluator* Alloc<word_eval::Completion…     1 0.00187
4 word_eval::NormalWordEvaluator* Alloc<word_eval::NormalWordEval…     1 0.00187
5 word_eval::TildeEvaluator* Alloc<word_eval::TildeEvaluator, sta…     1 0.00187

53,365 typed allocs, including 18,242 List<T>
48.13% 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.954
 2       1 17139       17414  60.4  
 3       2   807       18221  63.2  
 4       3  1429       19650  68.2  
 5       4   711       20361  70.6  
 6       5   519       20880  72.4  
 7       6   580       21460  74.4  
 8       7   493       21953  76.2  
 9       8  2568       24521  85.1  
10       9  1709       26230  91.0  
11      10   184       26414  91.6  
12      11   152       26566  92.2  
13      12   157       26723  92.7  
14      13   122       26845  93.1  
15      14   104       26949  93.5  
16      15    77       27026  93.7  
# A tibble: 5 × 4
  str_len     n n_less_than percent
    <int> <int>       <int>   <dbl>
1     160     1       28823    100.
2     202     1       28824    100.
3     255     1       28825    100.
4    1024     1       28826    100.
5    4096     2       28828    100 

28,828 string allocations, total length = 149,629, total bytes = 639,705

26.00% of allocs are strings
16.21% 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.0
2        7  3043       19846    68.5
3        8  1530       21376    73.8
4       10  1156       22532    77.8
5       14   349       22881    79.0
6       15  2423       25304    87.4
# A tibble: 5 × 4
  slab_len     n n_less_than percent
     <int> <int>       <int>   <dbl>
1      127    11       28910    99.8
2      128    36       28946   100. 
3      254     1       28947   100. 
4      256     6       28953   100. 
5     1022     2       28955   100  

  Slab Types
# A tibble: 6 × 2
  func_name                                                                    n
  <chr>                                                                    <int>
1 Slab<BigStr*>* NewSlab<BigStr*>(int)                                      9574
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,955 slabs, total items = 300,233
26.12% 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.00762
 2         1 18676       18681 28.5    
 3         2  7001       25682 39.1    
 4         3  5722       31404 47.9    
 5         4  3314       34718 52.9    
 6         5  3244       37962 57.9    
 7         6  3352       41314 63.0    
 8         7  2515       43829 66.8    
 9         8  3136       46965 71.6    
10         9  1799       48764 74.3    
11        10  1998       50762 77.4    
12        11  1002       51764 78.9    
13        12   857       52621 80.2    
14        13   829       53450 81.5    
15        14   740       54190 82.6    
# A tibble: 5 × 4
  num_items     n n_less_than percent
      <int> <int>       <int>   <dbl>
1        77    15       65590    100.
2        78     8       65598    100.
3       111     2       65600    100.
4       179     1       65601    100.
5      1022     2       65603    100 

65,603 reserve() calls, total items = 616,832

Untyped: 110,873
Typed + Str + Slab: 111,148