Percentage of allocs less than 48 bytes: 90.6

All allocations
# A tibble: 22 × 4
   obj_len     n n_less_than percent
     <int> <int>       <int>   <dbl>
 1       9  3042        3042    2.69
 2      10    73        3115    2.75
 3      12     9        3124    2.76
 4      13     1        3125    2.76
 5      16  7836       10961    9.68
 6      18 17141       28102   24.8 
 7      19   807       28909   25.5 
 8      20  1505       30414   26.9 
 9      21   715       31129   27.5 
10      22   519       31648   28.0 
11      23   581       32229   28.5 
12      24 30593       62822   55.5 
13      25  2569       65391   57.8 
14      26  1712       67103   59.3 
15      27   184       67287   59.5 
16      28   159       67446   59.6 
17      29   157       67603   59.7 
18      30   122       67725   59.8 
19      31   105       67830   59.9 
20      32  6964       74794   66.1 
21      33   341       75135   66.4 
22      34    81       75216   66.5 
# A tibble: 5 × 4
  obj_len     n n_less_than percent
    <int> <int>       <int>   <dbl>
1    1024     6      113170    100.
2    1032     5      113175    100.
3    1041     1      113176    100.
4    4096     2      113178    100.
5    4113     2      113180    100 

Common Sizes
# A tibble: 8 × 2
  obj_len     n
    <int> <int>
1      24 30593
2      48 22208
3      18 17141
4      16  7836
5      32  6964
6      40  4331
7      64  3618
8       9  3042

    113,180 total allocations, total bytes = 4,068,779

Typed allocations
# A tibble: 20 × 3
   func_name                                                           n percent
   <chr>                                                           <int>   <dbl>
 1 List<BigStr*>* Alloc<List<BigStr*>>()                            6536   11.9 
 2 runtime_asdl::Piece* Alloc<runtime_asdl::Piece, BigStr*, bool&…  4353    7.95
 3 List<runtime_asdl::part_value_t*>* Alloc<List<runtime_asdl::pa…  3518    6.43
 4 runtime_asdl::CommandStatus* Alloc<runtime_asdl::CommandStatus…  2971    5.43
 5 value_asdl::value__Bool* Alloc<value_asdl::value__Bool, bool&>…  2738    5.00
 6 Tuple2<runtime_asdl::span_e, int>* Alloc<Tuple2<runtime_asdl::…  2733    4.99
 7 List<syntax_asdl::CompoundWord*>* Alloc<List<syntax_asdl::Comp…  1659    3.03
 8 value_asdl::value__Str* Alloc<value_asdl::value__Str, BigStr*>…  1647    3.01
 9 runtime_asdl::Piece* Alloc<runtime_asdl::Piece, BigStr*&, bool…  1498    2.74
10 List<Tuple2<BigStr*, bool>*>* Alloc<List<Tuple2<BigStr*, bool>…  1359    2.48
11 runtime_asdl::Piece* Alloc<runtime_asdl::Piece, BigStr*&, bool…  1352    2.47
12 List<int>* Alloc<List<int>>()                                    1081    1.98
13 runtime_asdl::VarSubState* Alloc<runtime_asdl::VarSubState, bo…  1002    1.83
14 List<runtime_asdl::Piece*>* Alloc<List<runtime_asdl::Piece*>>()   956    1.75
15 Dict<BigStr*, value_asdl::value_t*>* Alloc<Dict<BigStr*, value…   917    1.68
16 Dict<BigStr*, args::_Action*>* Alloc<Dict<BigStr*, args::_Acti…   906    1.66
17 args::SetToInt* Alloc<args::SetToInt, BigStr*>(BigStr*&&)         901    1.65
18 value_asdl::value__Int* Alloc<value_asdl::value__Int, int&>(in…   901    1.65
19 value_asdl::value__Str* Alloc<value_asdl::value__Str, BigStr*&…   876    1.60
20 args::SetToString* Alloc<args::SetToString, BigStr*, bool, Lis…   766    1.40
# A tibble: 5 × 3
  func_name                                                            n percent
  <chr>                                                            <int>   <dbl>
1 value_asdl::value__BuiltinProc* Alloc<value_asdl::value__Builti…     1 0.00183
2 value_asdl::value__List* Alloc<value_asdl::value__List, List<va…     1 0.00183
3 word_eval::CompletionWordEvaluator* Alloc<word_eval::Completion…     1 0.00183
4 word_eval::NormalWordEvaluator* Alloc<word_eval::NormalWordEval…     1 0.00183
5 word_eval::TildeEvaluator* Alloc<word_eval::TildeEvaluator, sta…     1 0.00183

54,728 typed allocs, including 18,999 List<T>
48.35% 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  1432       19655  68.1  
 5       4   715       20370  70.6  
 6       5   519       20889  72.4  
 7       6   581       21470  74.4  
 8       7   494       21964  76.2  
 9       8  2569       24533  85.1  
10       9  1712       26245  91.0  
11      10   184       26429  91.6  
12      11   151       26580  92.2  
13      12   157       26737  92.7  
14      13   122       26859  93.1  
15      14   105       26964  93.5  
16      15    77       27041  93.8  
# A tibble: 5 × 4
  str_len     n n_less_than percent
    <int> <int>       <int>   <dbl>
1     160     1       28836    100.
2     202     1       28837    100.
3     255     1       28838    100.
4    1024     1       28839    100.
5    4096     2       28841    100 

28,841 string allocations, total length = 149,640, total bytes = 639,937

25.48% of allocs are strings
15.73% of bytes are strings

NewSlab()
  Lengths
# A tibble: 6 × 4
  slab_len     n n_less_than percent
     <int> <int>       <int>   <dbl>
1        5 17241       17241    57.7
2        7  3241       20482    68.5
3        8  1619       22101    74.0
4       10  1157       23258    77.8
5       14   349       23607    79.0
6       15  2552       26159    87.5
# A tibble: 5 × 4
  slab_len     n n_less_than percent
     <int> <int>       <int>   <dbl>
1      127     9       29841    99.8
2      128    37       29878   100. 
3      254     1       29879   100. 
4      256     5       29884   100. 
5     1022     2       29886   100  

  Slab Types
# A tibble: 6 × 2
  func_name                                                                    n
  <chr>                                                                    <int>
1 Slab<BigStr*>* NewSlab<BigStr*>(int)                                      9883
2 Slab<int>* NewSlab<int>(int)                                              5840
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)            2447
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

29,886 slabs, total items = 307,936
26.41% 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     3           3  0.00448
 2         1 19148       19151 28.6    
 3         2  7219       26370 39.4    
 4         3  5734       32104 47.9    
 5         4  3392       35496 53.0    
 6         5  3313       38809 57.9    
 7         6  3536       42345 63.2    
 8         7  2642       44987 67.2    
 9         8  3246       48233 72.0    
10         9  1860       50093 74.8    
11        10  2028       52121 77.8    
12        11  1011       53132 79.3    
13        12   857       53989 80.6    
14        13   829       54818 81.9    
15        14   740       55558 83.0    
# A tibble: 5 × 4
  num_items     n n_less_than percent
      <int> <int>       <int>   <dbl>
1        77    15       66959    100.
2        78     8       66967    100.
3       120     2       66969    100.
4       180     1       66970    100.
5      1022     2       66972    100 

66,972 reserve() calls, total items = 622,257

Untyped: 113,180
Typed + Str + Slab: 113,455