Percentage of allocs less than 48 bytes: 97.8

All allocations
# A tibble: 22 x 4
   obj_len     n n_less_than percent
     <int> <int>       <int>   <dbl>
 1       9    37          37  0.0504
 2      10  1824        1861  2.54  
 3      12   892        2753  3.75  
 4      16  7996       10749 14.6   
 5      18  6948       17697 24.1   
 6      19  2464       20161 27.5   
 7      20    19       20180 27.5   
 8      21    57       20237 27.6   
 9      22    37       20274 27.6   
10      23    25       20299 27.7   
11      24 26295       46594 63.5   
12      25    51       46645 63.5   
13      26    51       46696 63.6   
14      27    65       46761 63.7   
15      28    27       46788 63.7   
16      29    30       46818 63.8   
17      30   914       47732 65.0   
18      31    18       47750 65.1   
19      32  7002       54752 74.6   
20      33    12       54764 74.6   
21      34     2       54766 74.6   
22      35     8       54774 74.6   
# A tibble: 5 x 4
  obj_len     n n_less_than percent
    <int> <int>       <int>   <dbl>
1     520    35       73385    100.
2    1024     8       73393    100.
3    1032     6       73399    100.
4    4096     2       73401    100.
5    4113     2       73403    100 

Common Sizes
# A tibble: 8 x 2
  obj_len     n
    <int> <int>
1      24 26295
2      48 16212
3      16  7996
4      32  7002
5      18  6948
6      19  2464
7      10  1824
8      64  1086

    73,403 total allocations, total bytes = 2,226,593

Typed allocations
# A tibble: 20 x 3
   func_name                                                           n percent
   <chr>                                                           <int>   <dbl>
 1 List<BigStr*>* Alloc<List<BigStr*>>()                            5590   12.2 
 2 List<runtime_asdl::part_value_t*>* Alloc<List<runtime_asdl::pa~  4086    8.90
 3 List<runtime_asdl::RedirValue*>* Alloc<List<runtime_asdl::Redi~  3186    6.94
 4 runtime_asdl::CommandStatus* Alloc<runtime_asdl::CommandStatus~  3186    6.94
 5 value_asdl::value__Str* Alloc<value_asdl::value__Str, BigStr*>~  2227    4.85
 6 syntax_asdl::word__String* Alloc<syntax_asdl::word__String, in~  1844    4.02
 7 runtime_asdl::VarSubState* Alloc<runtime_asdl::VarSubState, bo~  1814    3.95
 8 runtime_asdl::part_value__String* Alloc<runtime_asdl::part_val~  1814    3.95
 9 value_asdl::LeftName* Alloc<value_asdl::LeftName, BigStr*&, sy~  1803    3.93
10 syntax_asdl::loc__Arith* Alloc<syntax_asdl::loc__Arith, syntax~  1780    3.88
11 value_asdl::value__Str* Alloc<value_asdl::value__Str, BigStr*&~   997    2.17
12 List<syntax_asdl::CompoundWord*>* Alloc<List<syntax_asdl::Comp~   981    2.14
13 mylib::BufWriter* Alloc<mylib::BufWriter>()                       934    2.04
14 List<List<Tuple3<BigStr*, bool, bool>*>*>* Alloc<List<List<Tup~   932    2.03
15 List<Tuple2<runtime_asdl::span_e, int>*>* Alloc<List<Tuple2<ru~   932    2.03
16 List<Tuple3<BigStr*, bool, bool>*>* Alloc<List<Tuple3<BigStr*,~   932    2.03
17 List<mylib::BufWriter*>* Alloc<List<mylib::BufWriter*>>()         932    2.03
18 List<syntax_asdl::Redir*>* Alloc<List<syntax_asdl::Redir*>>()     932    2.03
19 Tuple2<runtime_asdl::span_e, int>* Alloc<Tuple2<runtime_asdl::~   932    2.03
20 Tuple3<BigStr*, bool, bool>* Alloc<Tuple3<BigStr*, bool, bool>~   932    2.03
# A tibble: 5 x 3
  func_name                                                            n percent
  <chr>                                                            <int>   <dbl>
1 value_asdl::value__List* Alloc<value_asdl::value__List, List<va~     1 0.00218
2 word_eval::CompletionWordEvaluator* Alloc<word_eval::Completion~     1 0.00218
3 word_eval::NormalWordEvaluator* Alloc<word_eval::NormalWordEval~     1 0.00218
4 word_eval::TildeEvaluator* Alloc<word_eval::TildeEvaluator, sta~     1 0.00218
5 word_parse::WordParser* Alloc<word_parse::WordParser, parse_lib~     1 0.00218

45,895 typed allocs, including 20,004 List<T>
62.52% of allocs are typed

Str - NewStr() and OverAllocatedStr()
# A tibble: 16 x 4
   str_len     n n_less_than percent
     <int> <int>       <int>   <dbl>
 1       1  6948        6948    64.2
 2       2  2464        9412    87.0
 3       3    19        9431    87.1
 4       4    57        9488    87.7
 5       5    37        9525    88.0
 6       6    25        9550    88.2
 7       7    50        9600    88.7
 8       8    51        9651    89.2
 9       9    51        9702    89.6
10      10    65        9767    90.2
11      11    13        9780    90.4
12      12    30        9810    90.6
13      13   914       10724    99.1
14      14    18       10742    99.2
15      15     9       10751    99.3
16      16    12       10763    99.4
# A tibble: 5 x 4
  str_len     n n_less_than percent
    <int> <int>       <int>   <dbl>
1     134     1       10819    100.
2     137     1       10820    100.
3     196     1       10821    100.
4     255     1       10822    100.
5    4096     2       10824    100 

10,824 string allocations, total length = 38,040, total bytes = 222,048

14.75% of allocs are strings
9.97% of bytes are strings

NewSlab()
  Lengths
# A tibble: 6 x 4
  slab_len     n n_less_than percent
     <int> <int>       <int>   <dbl>
1        5 14926       14926    89.5
2        7   534       15460    92.7
3        8    56       15516    93.0
4       10   154       15670    93.9
5       14    76       15746    94.4
6       15    62       15808    94.7
# A tibble: 5 x 4
  slab_len     n n_less_than percent
     <int> <int>       <int>   <dbl>
1      127    11       16640    99.7
2      128    35       16675    99.9
3      254     1       16676   100. 
4      256     6       16682   100. 
5     1022     2       16684   100  

  Slab Types
# A tibble: 6 x 2
  func_name                                                                    n
  <chr>                                                                    <int>
1 Slab<BigStr*>* NewSlab<BigStr*>(int)                                      5700
2 Slab<runtime_asdl::part_value_t*>* NewSlab<runtime_asdl::part_value_t*>~  4086
3 Slab<syntax_asdl::CompoundWord*>* NewSlab<syntax_asdl::CompoundWord*>(i~  1422
4 Slab<List<Tuple3<BigStr*, bool, bool>*>*>* NewSlab<List<Tuple3<BigStr*,~   932
5 Slab<Tuple2<runtime_asdl::span_e, int>*>* NewSlab<Tuple2<runtime_asdl::~   932
6 Slab<Tuple3<BigStr*, bool, bool>*>* NewSlab<Tuple3<BigStr*, bool, bool>~   932
# A tibble: 5 x 2
  func_name                                                                    n
  <chr>                                                                    <int>
1 Slab<syntax_asdl::debug_frame_t*>* NewSlab<syntax_asdl::debug_frame_t*>~     1
2 Slab<syntax_asdl::loc_t*>* NewSlab<syntax_asdl::loc_t*>(int)                 1
3 Slab<value_asdl::regex_match_t*>* NewSlab<value_asdl::regex_match_t*>(i~     1
4 Slab<value_asdl::value__Dict*>* NewSlab<value_asdl::value__Dict*>(int)       1
5 Slab<vm::_AssignBuiltin*>* NewSlab<vm::_AssignBuiltin*>(int)                 1

16,684 slabs, total items = 124,203
22.73% of allocs are slabs

::reserve(int n)

  Num Items
# A tibble: 15 x 4
   num_items     n n_less_than  percent
       <int> <int>       <int>    <dbl>
 1         0     3           3  0.00923
 2         1 20661       20664 63.6    
 3         2  4253       24917 76.6    
 4         3  1684       26601 81.8    
 5         4  2404       29005 89.2    
 6         5  2722       31727 97.6    
 7         6   514       32241 99.2    
 8         7    24       32265 99.2    
 9         8    38       32303 99.4    
10         9    21       32324 99.4    
11        10    19       32343 99.5    
12        11    45       32388 99.6    
13        12     8       32396 99.6    
14        13     5       32401 99.7    
15        14     7       32408 99.7    
# A tibble: 5 x 4
  num_items     n n_less_than percent
      <int> <int>       <int>   <dbl>
1        63     1       32503    100.
2        64     5       32508    100.
3       106     2       32510    100.
4       177     1       32511    100.
5      1022     2       32513    100 

32,513 reserve() calls, total items = 66,969

Untyped: 73,403
Typed + Str + Slab: 73,403