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.0259
 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.8   
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 62.9   
21      34     3      101885 62.9   
22      35     9      101894 62.9   
# A tibble: 5 × 4
  obj_len     n n_less_than percent
    <int> <int>       <int>   <dbl>
1    4100     1      161863    100.
2    4104     1      161864    100.
3    4113     2      161866    100.
4    8192     1      161867    100.
5    8200     1      161868    100 

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

    161,868 total allocations, total bytes = 6,448,668

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,472 typed allocs, including 42,742 List<T>
55.89% 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.69% 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  2080       39764    75.6
3        8  1054       40818    77.6
4       10  3154       43972    83.6
5       14    78       44050    83.8
6       15  2070       46120    87.7
# A tibble: 5 × 4
  slab_len     n n_less_than percent
     <int> <int>       <int>   <dbl>
1      512     1       52581    100.
2     1022     2       52583    100.
3     1023     2       52585    100.
4     1024     1       52586    100.
5     2048     1       52587    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)                                              7727
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,587 slabs, total items = 521,563
32.49% 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.6    
 5         4 12087       84945 88.2    
 6         5  4048       88993 92.4    
 7         6  2057       91050 94.5    
 8         7  1017       92067 95.6    
 9         8  2038       94105 97.7    
10         9  1014       95119 98.8    
11        10     8       95127 98.8    
12        11    46       95173 98.8    
13        12     7       95180 98.8    
14        13     5       95185 98.8    
15        14     6       95191 98.8    
# A tibble: 5 × 4
  num_items     n n_less_than percent
      <int> <int>       <int>   <dbl>
1       128     1       96312    100.
2       180     1       96313    100.
3       256     1       96314    100.
4       512     1       96315    100.
5      1022     2       96317    100 

96,317 reserve() calls, total items = 245,603

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