Percentage of allocs less than 48 bytes: 92.7

All allocations
# A tibble: 22 × 4
   obj_len     n n_less_than percent
     <int> <int>       <int>   <dbl>
 1       9    39          39  0.0241
 2      10     2          41  0.0253
 3      12     1          42  0.0260
 4      16 14804       14846  9.17  
 5      18   314       15160  9.37  
 6      19  2366       17526 10.8   
 7      20  3618       21144 13.1   
 8      21  4080       25224 15.6   
 9      22  1036       26260 16.2   
10      23  1026       27286 16.9   
11      24 52088       79374 49.0   
12      25  1059       80433 49.7   
13      26  5048       85481 52.8   
14      27    32       85513 52.8   
15      28    25       85538 52.9   
16      29    29       85567 52.9   
17      30    26       85593 52.9   
18      31    18       85611 52.9   
19      32 16262      101873 62.9   
20      33    10      101883 63.0   
21      34     3      101886 63.0   
22      35     9      101895 63.0   
# A tibble: 5 × 4
  obj_len     n n_less_than percent
    <int> <int>       <int>   <dbl>
1    1024     6      161836    100.
2    1032     5      161841    100.
3    1041     1      161842    100.
4    4096     2      161844    100.
5    4113     2      161846    100 

Common Sizes
# A tibble: 8 × 2
  obj_len     n
    <int> <int>
1      24 52088
2      48 46037
3      32 16262
4      16 14804
5      26  5048
6      21  4080
7      20  3618
8      19  2366

    161,846 total allocations, total bytes = 6,415,868

Typed allocations
# A tibble: 20 × 3
   func_name                                                           n percent
   <chr>                                                           <int>   <dbl>
 1 List<BigStr*>* Alloc<List<BigStr*>>()                           11091   12.3 
 2 List<runtime_asdl::part_value_t*>* Alloc<List<runtime_asdl::pa…  8010    8.85
 3 runtime_asdl::CommandStatus* Alloc<runtime_asdl::CommandStatus…  5010    5.54
 4 runtime_asdl::Piece* Alloc<runtime_asdl::Piece, BigStr*, bool&…  5003    5.53
 5 List<syntax_asdl::CompoundWord*>* Alloc<List<syntax_asdl::Comp…  4043    4.47
 6 syntax_asdl::word__String* Alloc<syntax_asdl::word__String, in…  4004    4.43
 7 List<int>* Alloc<List<int>>()                                    3022    3.34
 8 mylib::BufWriter* Alloc<mylib::BufWriter>()                      3007    3.32
 9 List<List<runtime_asdl::Piece*>*>* Alloc<List<List<runtime_asd…  3004    3.32
10 List<runtime_asdl::Piece*>* Alloc<List<runtime_asdl::Piece*>>()  3004    3.32
11 List<Tuple2<runtime_asdl::span_e, int>*>* Alloc<List<Tuple2<ru…  3002    3.32
12 List<mylib::BufWriter*>* Alloc<List<mylib::BufWriter*>>()        3002    3.32
13 Tuple2<runtime_asdl::span_e, int>* Alloc<Tuple2<runtime_asdl::…  3002    3.32
14 value_asdl::value__Str* Alloc<value_asdl::value__Str, BigStr*&…  2053    2.27
15 runtime_asdl::VarSubState* Alloc<runtime_asdl::VarSubState, bo…  2005    2.22
16 runtime_asdl::cmd_value__Argv* Alloc<runtime_asdl::cmd_value__…  2004    2.22
17 value_asdl::value__Str* Alloc<value_asdl::value__Str, BigStr*>…  2004    2.22
18 runtime_asdl::Piece* Alloc<runtime_asdl::Piece, BigStr*&, bool…  2003    2.21
19 syntax_asdl::loc__Word* Alloc<syntax_asdl::loc__Word, syntax_a…  2002    2.21
20 syntax_asdl::loc__Arith* Alloc<syntax_asdl::loc__Arith, syntax…  2000    2.21
# A tibble: 5 × 3
  func_name                                                            n percent
  <chr>                                                            <int>   <dbl>
1 value_asdl::value__Proc* Alloc<value_asdl::value__Proc, BigStr*…     1 0.00111
2 word_eval::CompletionWordEvaluator* Alloc<word_eval::Completion…     1 0.00111
3 word_eval::NormalWordEvaluator* Alloc<word_eval::NormalWordEval…     1 0.00111
4 word_eval::TildeEvaluator* Alloc<word_eval::TildeEvaluator, sta…     1 0.00111
5 word_parse::WordParser* Alloc<word_parse::WordParser, parse_lib…     1 0.00111

90,474 typed allocs, including 42,742 List<T>
55.90% of allocs are typed

Str - NewStr() and OverAllocatedStr()
# A tibble: 16 × 4
   str_len     n n_less_than percent
     <int> <int>       <int>   <dbl>
 1       1   314         314    1.67
 2       2  2366        2680   14.2 
 3       3  3618        6298   33.5 
 4       4  4080       10378   55.2 
 5       5  1036       11414   60.7 
 6       6  1026       12440   66.1 
 7       7    54       12494   66.4 
 8       8  1059       13553   72.1 
 9       9  5048       18601   98.9 
10      10    32       18633   99.1 
11      11    16       18649   99.1 
12      12    29       18678   99.3 
13      13    26       18704   99.4 
14      14    18       18722   99.5 
15      15     7       18729   99.6 
16      16    10       18739   99.6 
# A tibble: 5 × 4
  str_len     n n_less_than percent
    <int> <int>       <int>   <dbl>
1     134     1       18804    100.
2     202     1       18805    100.
3     255     1       18806    100.
4    1024     1       18807    100.
5    4096     2       18809    100 

18,809 string allocations, total length = 111,508, total bytes = 431,261

11.62% of allocs are strings
6.72% of bytes are strings

NewSlab()
  Lengths
# A tibble: 6 × 4
  slab_len     n n_less_than percent
     <int> <int>       <int>   <dbl>
1        5 37684       37684    71.7
2        7  2078       39762    75.6
3        8  1054       40816    77.7
4       10  3154       43970    83.7
5       14    78       44048    83.8
6       15  2068       46116    87.7
# A tibble: 5 × 4
  slab_len     n n_less_than percent
     <int> <int>       <int>   <dbl>
1      127     9       52518    99.9
2      128    37       52555   100. 
3      254     1       52556   100. 
4      256     5       52561   100. 
5     1022     2       52563   100  

  Slab Types
# A tibble: 6 × 2
  func_name                                                                    n
  <chr>                                                                    <int>
1 Slab<BigStr*>* NewSlab<BigStr*>(int)                                     19207
2 Slab<runtime_asdl::part_value_t*>* NewSlab<runtime_asdl::part_value_t*>…  8010
3 Slab<int>* NewSlab<int>(int)                                              7711
4 Slab<syntax_asdl::CompoundWord*>* NewSlab<syntax_asdl::CompoundWord*>(i…  4032
5 Slab<List<runtime_asdl::Piece*>*>* NewSlab<List<runtime_asdl::Piece*>*>…  3004
6 Slab<runtime_asdl::Piece*>* NewSlab<runtime_asdl::Piece*>(int)            3003
# A tibble: 5 × 2
  func_name                                                                    n
  <chr>                                                                    <int>
1 Slab<syntax_asdl::loc_t*>* NewSlab<syntax_asdl::loc_t*>(int)                 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

52,563 slabs, total items = 513,419
32.48% 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     4           4  0.00415
 2         1 47603       47607 49.4    
 3         2 14219       61826 64.2    
 4         3 11027       72853 75.6    
 5         4 12087       84940 88.2    
 6         5  4048       88988 92.4    
 7         6  2056       91044 94.5    
 8         7  1017       92061 95.6    
 9         8  2037       94098 97.7    
10         9  1014       95112 98.8    
11        10     8       95120 98.8    
12        11    46       95166 98.8    
13        12     7       95173 98.8    
14        13     5       95178 98.8    
15        14     6       95184 98.8    
# A tibble: 5 × 4
  num_items     n n_less_than percent
      <int> <int>       <int>   <dbl>
1        63     1       96295    100.
2        64     4       96299    100.
3       120     2       96301    100.
4       180     1       96302    100.
5      1022     2       96304    100 

96,304 reserve() calls, total items = 244,587

Untyped: 161,846
Typed + Str + Slab: 161,846