Percentage of allocs less than 48 bytes: 98.1

All allocations
# A tibble: 22 × 4
   obj_len     n n_less_than percent
     <int> <int>       <int>   <dbl>
 1       9    37          37  0.0595
 2      10    10          47  0.0756
 3      12     1          48  0.0772
 4      16  8975        9023 14.5   
 5      18   731        9754 15.7   
 6      19  2852       12606 20.3   
 7      20    70       12676 20.4   
 8      21   104       12780 20.5   
 9      22    82       12862 20.7   
10      23    78       12940 20.8   
11      24 21772       34712 55.8   
12      25    96       34808 56.0   
13      26   103       34911 56.1   
14      27    95       35006 56.3   
15      28    23       35029 56.3   
16      29    28       35057 56.4   
17      30    24       35081 56.4   
18      31    15       35096 56.4   
19      32  8994       44090 70.9   
20      33    12       44102 70.9   
21      34     2       44104 70.9   
22      35     8       44112 70.9   
# A tibble: 5 × 4
  obj_len     n n_less_than percent
    <int> <int>       <int>   <dbl>
1    1024     6       62183    100.
2    1032     5       62188    100.
3    1041     1       62189    100.
4    4096     2       62191    100.
5    4113     2       62193    100 

Common Sizes
# A tibble: 8 × 2
  obj_len     n
    <int> <int>
1      24 21772
2      48 16251
3      32  8994
4      16  8975
5      19  2852
6      18   731
7      40   596
8      72   561

    62,193 total allocations, total bytes = 2,018,677

Typed allocations
# A tibble: 20 × 3
   func_name                                                           n percent
   <chr>                                                           <int>   <dbl>
 1 List<BigStr*>* Alloc<List<BigStr*>>()                            4660   11.2 
 2 List<runtime_asdl::part_value_t*>* Alloc<List<runtime_asdl::pa…  4086    9.86
 3 runtime_asdl::CommandStatus* Alloc<runtime_asdl::CommandStatus…  3186    7.69
 4 value_asdl::value__Str* Alloc<value_asdl::value__Str, BigStr*>…  2227    5.37
 5 syntax_asdl::word__String* Alloc<syntax_asdl::word__String, in…  1844    4.45
 6 runtime_asdl::Piece* Alloc<runtime_asdl::Piece, BigStr*&, bool…  1814    4.38
 7 runtime_asdl::VarSubState* Alloc<runtime_asdl::VarSubState, bo…  1814    4.38
 8 value_asdl::LeftName* Alloc<value_asdl::LeftName, BigStr*&, sy…  1803    4.35
 9 syntax_asdl::loc__Arith* Alloc<syntax_asdl::loc__Arith, syntax…  1780    4.30
10 value_asdl::value__Str* Alloc<value_asdl::value__Str, BigStr*&…  1003    2.42
11 List<syntax_asdl::CompoundWord*>* Alloc<List<syntax_asdl::Comp…   981    2.37
12 List<int>* Alloc<List<int>>()                                     957    2.31
13 mylib::BufWriter* Alloc<mylib::BufWriter>()                       945    2.28
14 List<List<runtime_asdl::Piece*>*>* Alloc<List<List<runtime_asd…   932    2.25
15 List<Tuple2<runtime_asdl::span_e, int>*>* Alloc<List<Tuple2<ru…   932    2.25
16 List<mylib::BufWriter*>* Alloc<List<mylib::BufWriter*>>()         932    2.25
17 List<runtime_asdl::Piece*>* Alloc<List<runtime_asdl::Piece*>>()   932    2.25
18 Tuple2<runtime_asdl::span_e, int>* Alloc<Tuple2<runtime_asdl::…   932    2.25
19 syntax_asdl::loc__Word* Alloc<syntax_asdl::loc__Word, syntax_a…   922    2.22
20 runtime_asdl::Piece* Alloc<runtime_asdl::Piece, BigStr*, bool&…   890    2.15
# A tibble: 5 × 3
  func_name                                                            n percent
  <chr>                                                            <int>   <dbl>
1 value_asdl::value__List* Alloc<value_asdl::value__List, List<va…     1 0.00241
2 word_eval::CompletionWordEvaluator* Alloc<word_eval::Completion…     1 0.00241
3 word_eval::NormalWordEvaluator* Alloc<word_eval::NormalWordEval…     1 0.00241
4 word_eval::TildeEvaluator* Alloc<word_eval::TildeEvaluator, sta…     1 0.00241
5 word_parse::WordParser* Alloc<word_parse::WordParser, parse_lib…     1 0.00241

41,443 typed allocs, including 16,400 List<T>
66.64% 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   731         731    16.3
 2       2  2852        3583    79.7
 3       3    70        3653    81.3
 4       4   104        3757    83.6
 5       5    82        3839    85.4
 6       6    78        3917    87.2
 7       7   105        4022    89.5
 8       8    96        4118    91.7
 9       9   103        4221    93.9
10      10    95        4316    96.1
11      11    16        4332    96.4
12      12    28        4360    97.0
13      13    24        4384    97.6
14      14    15        4399    97.9
15      15     9        4408    98.1
16      16    12        4420    98.4
# A tibble: 5 × 4
  str_len     n n_less_than percent
    <int> <int>       <int>   <dbl>
1     134     1        4488    99.9
2     202     1        4489    99.9
3     255     1        4490    99.9
4    1024     1        4491   100. 
5    4096     2        4493   100  

4,493 string allocations, total length = 24,715, total bytes = 101,096

7.22% of allocs are strings
5.01% of bytes are strings

NewSlab()
  Lengths
# A tibble: 6 × 4
  slab_len     n n_less_than percent
     <int> <int>       <int>   <dbl>
1        5 14009       14009    86.2
2        7    67       14076    86.6
3        8    61       14137    87.0
4       10  1087       15224    93.6
5       14    78       15302    94.1
6       15    57       15359    94.5
# A tibble: 5 × 4
  slab_len     n n_less_than percent
     <int> <int>       <int>   <dbl>
1      127     9       16212    99.7
2      128    37       16249   100. 
3      254     1       16250   100. 
4      256     5       16255   100. 
5     1022     2       16257   100  

  Slab Types
# A tibble: 6 × 2
  func_name                                                                    n
  <chr>                                                                    <int>
1 Slab<BigStr*>* NewSlab<BigStr*>(int)                                      4762
2 Slab<runtime_asdl::part_value_t*>* NewSlab<runtime_asdl::part_value_t*>…  4086
3 Slab<int>* NewSlab<int>(int)                                              1641
4 Slab<syntax_asdl::CompoundWord*>* NewSlab<syntax_asdl::CompoundWord*>(i…   961
5 Slab<List<runtime_asdl::Piece*>*>* NewSlab<List<runtime_asdl::Piece*>*>…   932
6 Slab<Tuple2<runtime_asdl::span_e, int>*>* NewSlab<Tuple2<runtime_asdl::…   932
# A tibble: 5 × 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,257 slabs, total items = 126,356
26.14% 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     3           3  0.00949
 2         1 20663       20666 65.4    
 3         2  4245       24911 78.8    
 4         3  1675       26586 84.1    
 5         4  2401       28987 91.7    
 6         5  2264       31251 98.9    
 7         6    60       31311 99.1    
 8         7    25       31336 99.2    
 9         8    41       31377 99.3    
10         9    22       31399 99.4    
11        10    19       31418 99.4    
12        11    47       31465 99.6    
13        12     8       31473 99.6    
14        13     6       31479 99.6    
15        14     7       31486 99.6    
# A tibble: 5 × 4
  num_items     n n_less_than percent
      <int> <int>       <int>   <dbl>
1        63     1       31591    100.
2        64     4       31595    100.
3       119     2       31597    100.
4       180     1       31598    100.
5      1022     2       31600    100 

31,600 reserve() calls, total items = 62,132

Untyped: 62,193
Typed + Str + Slab: 62,193