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  7835       10960    9.68
 6      18 17141       28101   24.8 
 7      19   807       28908   25.5 
 8      20  1505       30413   26.9 
 9      21   715       31128   27.5 
10      22   519       31647   28.0 
11      23   581       32228   28.5 
12      24 30593       62821   55.5 
13      25  2569       65390   57.8 
14      26  1712       67102   59.3 
15      27   184       67286   59.5 
16      28   158       67444   59.6 
17      29   157       67601   59.7 
18      30   122       67723   59.8 
19      31   105       67828   59.9 
20      32  6963       74791   66.1 
21      33   341       75132   66.4 
22      34    81       75213   66.5 
# A tibble: 5 × 4
  obj_len     n n_less_than percent
    <int> <int>       <int>   <dbl>
1    1024     6      113164    100.
2    1032     5      113169    100.
3    1041     1      113170    100.
4    4096     2      113172    100.
5    4113     2      113174    100 

Common Sizes
# A tibble: 8 × 2
  obj_len     n
    <int> <int>
1      24 30593
2      48 22205
3      18 17141
4      16  7835
5      32  6963
6      40  4330
7      64  3617
8       9  3042

    113,174 total allocations, total bytes = 4,068,550

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*&…   875    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,725 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,639, total bytes = 639,936

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 17239       17239    57.7
2        7  3241       20480    68.5
3        8  1618       22098    73.9
4       10  1157       23255    77.8
5       14   349       23604    79.0
6       15  2552       26156    87.5
# A tibble: 5 × 4
  slab_len     n n_less_than percent
     <int> <int>       <int>   <dbl>
1      127     9       29838    99.8
2      128    37       29875   100. 
3      254     1       29876   100. 
4      256     5       29881   100. 
5     1022     2       29883   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)                                              5838
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,883 slabs, total items = 307,918
26.40% 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.00747
 2         1 19147       19152 28.6    
 3         2  7219       26371 39.4    
 4         3  5734       32105 47.9    
 5         4  3392       35497 53.0    
 6         5  3313       38810 57.9    
 7         6  3536       42346 63.2    
 8         7  2642       44988 67.2    
 9         8  3246       48234 72.0    
10         9  1860       50094 74.8    
11        10  2028       52122 77.8    
12        11  1011       53133 79.3    
13        12   857       53990 80.6    
14        13   829       54819 81.9    
15        14   740       55559 83.0    
# A tibble: 5 × 4
  num_items     n n_less_than percent
      <int> <int>       <int>   <dbl>
1        77    15       66960    100.
2        78     8       66968    100.
3       117     2       66970    100.
4       180     1       66971    100.
5      1022     2       66973    100 

66,973 reserve() calls, total items = 622,250

Untyped: 113,174
Typed + Str + Slab: 113,449