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  8993       44089 70.9   
20      33    12       44101 70.9   
21      34     2       44103 70.9   
22      35     8       44111 70.9   
# A tibble: 5 × 4
  obj_len     n n_less_than percent
    <int> <int>       <int>   <dbl>
1    1024     6       62182    100.
2    1032     5       62187    100.
3    1041     1       62188    100.
4    4096     2       62190    100.
5    4113     2       62192    100 

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

    62,192 total allocations, total bytes = 2,018,645

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*&…  1002    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,442 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     5           5  0.0158
 2         1 20663       20668 65.4   
 3         2  4245       24913 78.8   
 4         3  1675       26588 84.1   
 5         4  2401       28989 91.7   
 6         5  2264       31253 98.9   
 7         6    60       31313 99.1   
 8         7    25       31338 99.2   
 9         8    41       31379 99.3   
10         9    22       31401 99.4   
11        10    19       31420 99.4   
12        11    47       31467 99.6   
13        12     8       31475 99.6   
14        13     6       31481 99.6   
15        14     7       31488 99.6   
# A tibble: 5 × 4
  num_items     n n_less_than percent
      <int> <int>       <int>   <dbl>
1        63     1       31593    100.
2        64     4       31597    100.
3       117     2       31599    100.
4       180     1       31600    100.
5      1022     2       31602    100 

31,602 reserve() calls, total items = 62,128

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