Percentage of allocs less than 48 bytes: 91.1

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  7876       12003   10.8 
 7      18 17141       29144   26.3 
 8      19   807       29951   27.0 
 9      20  1502       31453   28.4 
10      21   711       32164   29.0 
11      22   519       32683   29.5 
12      23   580       33263   30.0 
13      24 29989       63252   57.0 
14      25  2569       65821   59.3 
15      26  1709       67530   60.9 
16      27   184       67714   61.1 
17      28   159       67873   61.2 
18      29   157       68030   61.3 
19      30   122       68152   61.4 
20      31   104       68256   61.5 
21      32  5307       73563   66.3 
22      33   341       73904   66.6 
# A tibble: 5 × 4
  obj_len     n n_less_than percent
    <int> <int>       <int>   <dbl>
1    1024     8      110903    100.
2    1032     6      110909    100.
3    1041     1      110910    100.
4    4096     2      110912    100.
5    4113     2      110914    100 

Common Sizes
# A tibble: 8 × 2
  obj_len     n
    <int> <int>
1      24 29989
2      48 21591
3      18 17141
4      16  7876
5      32  5307
6      40  4772
7      64  3420
8       9  3042

    110,914 total allocations, total bytes = 3,939,434

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.15
 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.56
 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.08
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*&…   871    1.63
20 args::SetToString* Alloc<args::SetToString, BigStr*, bool, Lis…   766    1.43
# 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,394 typed allocs, including 18,242 List<T>
48.14% 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 17141       17416  60.4  
 3       2   807       18223  63.2  
 4       3  1429       19652  68.2  
 5       4   711       20363  70.6  
 6       5   519       20882  72.4  
 7       6   580       21462  74.4  
 8       7   493       21955  76.2  
 9       8  2569       24524  85.1  
10       9  1709       26233  91.0  
11      10   184       26417  91.6  
12      11   152       26569  92.2  
13      12   157       26726  92.7  
14      13   122       26848  93.1  
15      14   104       26952  93.5  
16      15    77       27029  93.7  
# A tibble: 5 × 4
  str_len     n n_less_than percent
    <int> <int>       <int>   <dbl>
1     160     1       28826    100.
2     202     1       28827    100.
3     255     1       28828    100.
4    1024     1       28829    100.
5    4096     2       28831    100 

28,831 string allocations, total length = 149,639, total bytes = 639,766

25.99% of allocs are strings
16.24% of bytes are strings

NewSlab()
  Lengths
# A tibble: 6 × 4
  slab_len     n n_less_than percent
     <int> <int>       <int>   <dbl>
1        5 16807       16807    58.0
2        7  3045       19852    68.5
3        8  1532       21384    73.8
4       10  1156       22540    77.8
5       14   349       22889    79.0
6       15  2423       25312    87.4
# A tibble: 5 × 4
  slab_len     n n_less_than percent
     <int> <int>       <int>   <dbl>
1      127    11       28919    99.8
2      128    36       28955   100. 
3      254     1       28956   100. 
4      256     6       28962   100. 
5     1022     2       28964   100  

  Slab Types
# A tibble: 6 × 2
  func_name                                                                    n
  <chr>                                                                    <int>
1 Slab<BigStr*>* NewSlab<BigStr*>(int)                                      9577
2 Slab<int>* NewSlab<int>(int)                                              5678
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)            2433
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,964 slabs, total items = 300,299
26.11% 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 18678       18683 28.5    
 3         2  7001       25684 39.1    
 4         3  5722       31406 47.9    
 5         4  3314       34720 52.9    
 6         5  3244       37964 57.9    
 7         6  3353       41317 63.0    
 8         7  2515       43832 66.8    
 9         8  3136       46968 71.6    
10         9  1799       48767 74.3    
11        10  1998       50765 77.4    
12        11  1003       51768 78.9    
13        12   857       52625 80.2    
14        13   829       53454 81.5    
15        14   740       54194 82.6    
# A tibble: 5 × 4
  num_items     n n_less_than percent
      <int> <int>       <int>   <dbl>
1        77    15       65594    100.
2        78     8       65602    100.
3       113     2       65604    100.
4       179     1       65605    100.
5      1022     2       65607    100 

65,607 reserve() calls, total items = 616,855

Untyped: 110,914
Typed + Str + Slab: 111,189