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 14805       14847  9.17  
 5      18   314       15161  9.37  
 6      19  2366       17527 10.8   
 7      20  3618       21145 13.1   
 8      21  4080       25225 15.6   
 9      22  1036       26261 16.2   
10      23  1026       27287 16.9   
11      24 52088       79375 49.0   
12      25  1059       80434 49.7   
13      26  5048       85482 52.8   
14      27    32       85514 52.8   
15      28    25       85539 52.9   
16      29    29       85568 52.9   
17      30    26       85594 52.9   
18      31    18       85612 52.9   
19      32 16262      101874 62.9   
20      33    10      101884 63.0   
21      34     3      101887 63.0   
22      35     9      101896 63.0   
# A tibble: 5 × 4
  obj_len     n n_less_than percent
    <int> <int>       <int>   <dbl>
1    1024     6      161837    100.
2    1032     5      161842    100.
3    1041     1      161843    100.
4    4096     2      161845    100.
5    4113     2      161847    100 

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

    161,847 total allocations, total bytes = 6,416,028

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.21
17 value_asdl::value__Str* Alloc<value_asdl::value__Str, BigStr*>…  2004    2.21
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,475 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      128    37       52554    100.
2      248     1       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,547
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       121     2       96301    100.
4       180     1       96302    100.
5      1022     2       96304    100 

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

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