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  6964       74792   66.1 
21      33   341       75133   66.4 
22      34    81       75214   66.5 
# A tibble: 5 × 4
  obj_len     n n_less_than percent
    <int> <int>       <int>   <dbl>
1    1024     6      113165    100.
2    1032     5      113170    100.
3    1041     1      113171    100.
4    4096     2      113173    100.
5    4113     2      113175    100 

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

    113,175 total allocations, total bytes = 4,068,583

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,726 typed allocs, including 18,999 List<T>
48.36% 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 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     3           3  0.00448
 2         1 19147       19150 28.6    
 3         2  7219       26369 39.4    
 4         3  5734       32103 47.9    
 5         4  3392       35495 53.0    
 6         5  3313       38808 57.9    
 7         6  3536       42344 63.2    
 8         7  2642       44986 67.2    
 9         8  3246       48232 72.0    
10         9  1860       50092 74.8    
11        10  2028       52120 77.8    
12        11  1011       53131 79.3    
13        12   857       53988 80.6    
14        13   829       54817 81.9    
15        14   740       55557 83.0    
# A tibble: 5 × 4
  num_items     n n_less_than percent
      <int> <int>       <int>   <dbl>
1        77    15       66958    100.
2        78     8       66966    100.
3       118     2       66968    100.
4       180     1       66969    100.
5      1022     2       66971    100 

66,971 reserve() calls, total items = 622,252

Untyped: 113,175
Typed + Str + Slab: 113,450