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 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    26       85540 52.9   
16      29    29       85569 52.9   
17      30    26       85595 52.9   
18      31    18       85613 52.9   
19      32 16262      101875 62.9   
20      33    10      101885 62.9   
21      34     3      101888 63.0   
22      35     9      101897 63.0   
# A tibble: 5 × 4
  obj_len     n n_less_than percent
    <int> <int>       <int>   <dbl>
1    1024     6      161841    100.
2    1032     5      161846    100.
3    1041     1      161847    100.
4    4096     2      161849    100.
5    4113     2      161851    100 

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

    161,851 total allocations, total bytes = 6,416,064

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,476 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 37686       37686    71.7
2        7  2078       39764    75.6
3        8  1055       40819    77.7
4       10  3154       43973    83.7
5       14    78       44051    83.8
6       15  2068       46119    87.7
# A tibble: 5 × 4
  slab_len     n n_less_than percent
     <int> <int>       <int>   <dbl>
1      127     9       52521    99.9
2      128    37       52558   100. 
3      254     1       52559   100. 
4      256     5       52564   100. 
5     1022     2       52566   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)                                              7713
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,566 slabs, total items = 513,437
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 47604       47608 49.4    
 3         2 14219       61827 64.2    
 4         3 11027       72854 75.6    
 5         4 12087       84941 88.2    
 6         5  4048       88989 92.4    
 7         6  2056       91045 94.5    
 8         7  1017       92062 95.6    
 9         8  2037       94099 97.7    
10         9  1014       95113 98.8    
11        10     8       95121 98.8    
12        11    46       95167 98.8    
13        12     7       95174 98.8    
14        13     5       95179 98.8    
15        14     6       95185 98.8    
# A tibble: 5 × 4
  num_items     n n_less_than percent
      <int> <int>       <int>   <dbl>
1        63     1       96296    100.
2        64     4       96300    100.
3       120     2       96302    100.
4       180     1       96303    100.
5      1022     2       96305    100 

96,305 reserve() calls, total items = 244,588

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