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.6   
 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    23       35030 56.3   
16      29    28       35058 56.4   
17      30    24       35082 56.4   
18      31    15       35097 56.4   
19      32  8994       44091 70.9   
20      33    12       44103 70.9   
21      34     2       44105 70.9   
22      35     8       44113 70.9   
# A tibble: 5 × 4
  obj_len     n n_less_than percent
    <int> <int>       <int>   <dbl>
1    1024     6       62184    100.
2    1032     5       62189    100.
3    1041     1       62190    100.
4    4096     2       62192    100.
5    4113     2       62194    100 

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

    62,194 total allocations, total bytes = 2,018,837

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,444 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      128    37       16248    99.9
2      248     1       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,484
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       121     2       31597    100.
4       180     1       31598    100.
5      1022     2       31600    100 

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

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