Percentage of allocs less than 48 bytes: 96.6

All allocations
# A tibble: 22 × 4
   obj_len     n n_less_than percent
     <int> <int>       <int>   <dbl>
 1       9    37          37  0.0592
 2      10    10          47  0.0751
 3      11  1814        1861  2.98  
 4      12     1        1862  2.98  
 5      16  8929       10791 17.3   
 6      18   729       11520 18.4   
 7      19  2852       14372 23.0   
 8      20    67       14439 23.1   
 9      21   100       14539 23.2   
10      22    82       14621 23.4   
11      23    77       14698 23.5   
12      24 21820       36518 58.4   
13      25    95       36613 58.5   
14      26   100       36713 58.7   
15      27    95       36808 58.8   
16      28    24       36832 58.9   
17      29    28       36860 58.9   
18      30    24       36884 59.0   
19      31    14       36898 59.0   
20      32  7178       44076 70.5   
21      33    12       44088 70.5   
22      34     2       44090 70.5   
# A tibble: 5 × 4
  obj_len     n n_less_than percent
    <int> <int>       <int>   <dbl>
1    1024     8       62540    100.
2    1032     6       62546    100.
3    1041     1       62547    100.
4    4096     2       62549    100.
5    4113     2       62551    100 

Common Sizes
# A tibble: 8 × 2
  obj_len     n
    <int> <int>
1      24 21820
2      48 15736
3      16  8929
4      32  7178
5      19  2852
6      11  1814
7      64  1074
8      18   729

    62,551 total allocations, total bytes = 2,006,016

Typed allocations
# A tibble: 20 × 3
   func_name                                                           n percent
   <chr>                                                           <int>   <dbl>
 1 List<BigStr*>* Alloc<List<BigStr*>>()                            4658   11.2 
 2 List<runtime_asdl::part_value_t*>* Alloc<List<runtime_asdl::pa…  4086    9.87
 3 runtime_asdl::CommandStatus* Alloc<runtime_asdl::CommandStatus…  3186    7.69
 4 value_asdl::value__Str* Alloc<value_asdl::value__Str, BigStr*>…  2227    5.38
 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*&…   997    2.41
11 List<syntax_asdl::CompoundWord*>* Alloc<List<syntax_asdl::Comp…   981    2.37
12 List<int>* Alloc<List<int>>()                                     956    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.23
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.00242
2 word_eval::CompletionWordEvaluator* Alloc<word_eval::Completion…     1 0.00242
3 word_eval::NormalWordEvaluator* Alloc<word_eval::NormalWordEval…     1 0.00242
4 word_eval::TildeEvaluator* Alloc<word_eval::TildeEvaluator, sta…     1 0.00242
5 word_parse::WordParser* Alloc<word_parse::WordParser, parse_lib…     1 0.00242

41,405 typed allocs, including 16,385 List<T>
66.19% 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   729         729    16.3
 2       2  2852        3581    79.9
 3       3    67        3648    81.4
 4       4   100        3748    83.7
 5       5    82        3830    85.5
 6       6    77        3907    87.2
 7       7   104        4011    89.5
 8       8    95        4106    91.7
 9       9   100        4206    93.9
10      10    95        4301    96.0
11      11    17        4318    96.4
12      12    28        4346    97.0
13      13    24        4370    97.5
14      14    14        4384    97.9
15      15     9        4393    98.1
16      16    12        4405    98.3
# A tibble: 5 × 4
  str_len     n n_less_than percent
    <int> <int>       <int>   <dbl>
1     134     1        4475    99.9
2     202     1        4476    99.9
3     255     1        4477    99.9
4    1024     1        4478   100. 
5    4096     2        4480   100  

4,480 string allocations, total length = 24,705, total bytes = 100,865

7.16% of allocs are strings
5.03% of bytes are strings

NewSlab()
  Lengths
# A tibble: 6 × 4
  slab_len     n n_less_than percent
     <int> <int>       <int>   <dbl>
1        5 13984       13984    83.9
2        7   525       14509    87.1
3        8    49       14558    87.4
4       10  1086       15644    93.9
5       14    78       15722    94.3
6       15    53       15775    94.7
# A tibble: 5 × 4
  slab_len     n n_less_than percent
     <int> <int>       <int>   <dbl>
1      127    11       16621    99.7
2      128    36       16657    99.9
3      254     1       16658   100. 
4      256     6       16664   100. 
5     1022     2       16666   100  

  Slab Types
# A tibble: 6 × 2
  func_name                                                                    n
  <chr>                                                                    <int>
1 Slab<BigStr*>* NewSlab<BigStr*>(int)                                      4744
2 Slab<runtime_asdl::part_value_t*>* NewSlab<runtime_asdl::part_value_t*>…  4086
3 Slab<int>* NewSlab<int>(int)                                              1623
4 Slab<syntax_asdl::CompoundWord*>* NewSlab<syntax_asdl::CompoundWord*>(i…  1422
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,666 slabs, total items = 129,305
26.64% 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.0154
 2         1 20651       20656 63.5   
 3         2  4247       24903 76.6   
 4         3  1684       26587 81.8   
 5         4  2401       28988 89.2   
 6         5  2724       31712 97.5   
 7         6   519       32231 99.1   
 8         7    25       32256 99.2   
 9         8    39       32295 99.3   
10         9    21       32316 99.4   
11        10    19       32335 99.4   
12        11    46       32381 99.6   
13        12     8       32389 99.6   
14        13     6       32395 99.6   
15        14     7       32402 99.7   
# A tibble: 5 × 4
  num_items     n n_less_than percent
      <int> <int>       <int>   <dbl>
1        63     1       32505    100.
2        64     5       32510    100.
3       111     2       32512    100.
4       179     1       32513    100.
5      1022     2       32515    100 

32,515 reserve() calls, total items = 67,168

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