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  8976        9024 14.5   
 5      18   731        9755 15.7   
 6      19  2852       12607 20.3   
 7      20    70       12677 20.4   
 8      21   104       12781 20.5   
 9      22    82       12863 20.7   
10      23    78       12941 20.8   
11      24 21772       34713 55.8   
12      25    96       34809 56.0   
13      26   103       34912 56.1   
14      27    95       35007 56.3   
15      28    24       35031 56.3   
16      29    28       35059 56.4   
17      30    24       35083 56.4   
18      31    15       35098 56.4   
19      32  8994       44092 70.9   
20      33    12       44104 70.9   
21      34     2       44106 70.9   
22      35     8       44114 70.9   
# A tibble: 5 × 4
  obj_len     n n_less_than percent
    <int> <int>       <int>   <dbl>
1    1024     6       62188    100.
2    1032     5       62193    100.
3    1041     1       62194    100.
4    4096     2       62196    100.
5    4113     2       62198    100 

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

    62,198 total allocations, total bytes = 2,018,873

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.29
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,445 typed allocs, including 16,400 List<T>
66.63% 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 14011       14011    86.2
2        7    67       14078    86.6
3        8    62       14140    87.0
4       10  1087       15227    93.6
5       14    78       15305    94.1
6       15    57       15362    94.5
# A tibble: 5 × 4
  slab_len     n n_less_than percent
     <int> <int>       <int>   <dbl>
1      127     9       16215    99.7
2      128    37       16252   100. 
3      254     1       16253   100. 
4      256     5       16258   100. 
5     1022     2       16260   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)                                              1643
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,260 slabs, total items = 126,374
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 20664       20667 65.4    
 3         2  4245       24912 78.8    
 4         3  1675       26587 84.1    
 5         4  2401       28988 91.7    
 6         5  2264       31252 98.9    
 7         6    60       31312 99.1    
 8         7    25       31337 99.2    
 9         8    41       31378 99.3    
10         9    22       31400 99.4    
11        10    19       31419 99.4    
12        11    47       31466 99.6    
13        12     8       31474 99.6    
14        13     6       31480 99.6    
15        14     7       31487 99.6    
# A tibble: 5 × 4
  num_items     n n_less_than percent
      <int> <int>       <int>   <dbl>
1        63     1       31592    100.
2        64     4       31596    100.
3       120     2       31598    100.
4       180     1       31599    100.
5      1022     2       31601    100 

31,601 reserve() calls, total items = 62,135

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