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 16261      101872 62.9   
20      33    10      101882 63.0   
21      34     3      101885 63.0   
22      35     9      101894 63.0   
# A tibble: 5 × 4
  obj_len     n n_less_than percent
    <int> <int>       <int>   <dbl>
1    1024     6      161835    100.
2    1032     5      161840    100.
3    1041     1      161841    100.
4    4096     2      161843    100.
5    4113     2      161845    100 

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

    161,845 total allocations, total bytes = 6,415,828

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*&…  2052    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,473 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     9           9  0.00934
 2         1 47603       47612 49.4    
 3         2 14219       61831 64.2    
 4         3 11027       72858 75.7    
 5         4 12087       84945 88.2    
 6         5  4048       88993 92.4    
 7         6  2056       91049 94.5    
 8         7  1017       92066 95.6    
 9         8  2037       94103 97.7    
10         9  1014       95117 98.8    
11        10     8       95125 98.8    
12        11    46       95171 98.8    
13        12     7       95178 98.8    
14        13     5       95183 98.8    
15        14     6       95189 98.8    
# A tibble: 5 × 4
  num_items     n n_less_than percent
      <int> <int>       <int>   <dbl>
1        63     1       96300    100.
2        64     4       96304    100.
3       117     2       96306    100.
4       180     1       96307    100.
5      1022     2       96309    100 

96,309 reserve() calls, total items = 244,581

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