Percentage of allocs less than 48 bytes: 96.5

All allocations
# A tibble: 22 x 4
   obj_len     n n_less_than percent
     <int> <int>       <int>   <dbl>
 1       9    37          37  0.0493
 2      10  1824        1861  2.48  
 3      12   892        2753  3.67  
 4      16  8145       10898 14.5   
 5      18  6948       17846 23.8   
 6      19  2464       20310 27.0   
 7      20    21       20331 27.1   
 8      21    59       20390 27.2   
 9      22    39       20429 27.2   
10      23    26       20455 27.2   
11      24 26622       47077 62.7   
12      25    63       47140 62.8   
13      26    60       47200 62.9   
14      27    84       47284 63.0   
15      28    27       47311 63.0   
16      29    37       47348 63.1   
17      30   911       48259 64.3   
18      31    21       48280 64.3   
19      32  7472       55752 74.2   
20      33     9       55761 74.3   
21      35    10       55771 74.3   
22      36     6       55777 74.3   
# A tibble: 5 x 4
  obj_len     n n_less_than percent
    <int> <int>       <int>   <dbl>
1     272     1       75022    99.9
2     520    49       75071   100. 
3    1032    16       75087   100. 
4    4104     2       75089   100. 
5    4113     2       75091   100  

Common Sizes
# A tibble: 8 x 2
  obj_len     n
    <int> <int>
1      24 26622
2      40 16442
3      16  8145
4      32  7472
5      18  6948
6      19  2464
7      10  1824
8      72  1698

    75,091 total allocations, total bytes = 2,195,080

Typed allocations
# A tibble: 20 x 3
   func_name                                                           n percent
   <chr>                                                           <int>   <dbl>
 1 List<Str*>* Alloc<List<Str*>>()                                  5591   12.1 
 2 List<runtime_asdl::part_value_t*>* Alloc<List<runtime_asdl::pa~  4086    8.85
 3 List<runtime_asdl::RedirValue*>* Alloc<List<runtime_asdl::Redi~  3186    6.90
 4 runtime_asdl::CommandStatus* Alloc<runtime_asdl::CommandStatus~  3186    6.90
 5 runtime_asdl::value__Str* Alloc<runtime_asdl::value__Str, Str*~  2227    4.82
 6 syntax_asdl::word__String* Alloc<syntax_asdl::word__String, in~  1844    3.99
 7 runtime_asdl::VarSubState* Alloc<runtime_asdl::VarSubState, bo~  1814    3.93
 8 runtime_asdl::part_value__String* Alloc<runtime_asdl::part_val~  1814    3.93
 9 runtime_asdl::lvalue__Named* Alloc<runtime_asdl::lvalue__Named~  1803    3.90
10 syntax_asdl::loc__Arith* Alloc<syntax_asdl::loc__Arith, syntax~  1780    3.85
11 runtime_asdl::value__Str* Alloc<runtime_asdl::value__Str, Str*~   996    2.16
12 List<syntax_asdl::CompoundWord*>* Alloc<List<syntax_asdl::Comp~   981    2.12
13 mylib::BufWriter* Alloc<mylib::BufWriter>()                       934    2.02
14 List<List<Tuple3<Str*, bool, bool>*>*>* Alloc<List<List<Tuple3~   932    2.02
15 List<Tuple2<runtime_asdl::span_e, int>*>* Alloc<List<Tuple2<ru~   932    2.02
16 List<Tuple3<Str*, bool, bool>*>* Alloc<List<Tuple3<Str*, bool,~   932    2.02
17 List<mylib::BufWriter*>* Alloc<List<mylib::BufWriter*>>()         932    2.02
18 List<syntax_asdl::Redir*>* Alloc<List<syntax_asdl::Redir*>>()     932    2.02
19 Tuple2<runtime_asdl::span_e, int>* Alloc<Tuple2<runtime_asdl::~   932    2.02
20 Tuple3<Str*, bool, bool>* Alloc<Tuple3<Str*, bool, bool>, Str*~   932    2.02
# A tibble: 5 x 3
  func_name                                                            n percent
  <chr>                                                            <int>   <dbl>
1 util::NullDebugFile* Alloc<util::NullDebugFile>()                    1 0.00217
2 word_eval::CompletionWordEvaluator* Alloc<word_eval::Completion~     1 0.00217
3 word_eval::NormalWordEvaluator* Alloc<word_eval::NormalWordEval~     1 0.00217
4 word_eval::TildeEvaluator* Alloc<word_eval::TildeEvaluator, sta~     1 0.00217
5 word_parse::WordParser* Alloc<word_parse::WordParser, parse_lib~     1 0.00217

46,177 typed allocs, including 20,129 List<T>
61.49% of allocs are typed

Str - NewStr() and OverAllocatedStr()
# A tibble: 16 x 4
   str_len     n n_less_than percent
     <int> <int>       <int>   <dbl>
 1       1  6948        6948    63.8
 2       2  2464        9412    86.4
 3       3    21        9433    86.6
 4       4    59        9492    87.1
 5       5    39        9531    87.5
 6       6    26        9557    87.7
 7       7    55        9612    88.2
 8       8    63        9675    88.8
 9       9    60        9735    89.4
10      10    84        9819    90.1
11      11    27        9846    90.4
12      12    37        9883    90.7
13      13   911       10794    99.1
14      14    21       10815    99.3
15      15     9       10824    99.4
16      16     9       10833    99.4
# A tibble: 5 x 4
  str_len     n n_less_than percent
    <int> <int>       <int>   <dbl>
1     134     1       10888    100.
2     137     1       10889    100.
3     196     1       10890    100.
4     255     1       10891    100.
5    4096     2       10893    100 

10,893 string allocations, total length = 38,646, total bytes = 223,827

14.51% of allocs are strings
10.20% of bytes are strings

NewSlab()
  Lengths
# A tibble: 6 x 4
  slab_len     n n_less_than percent
     <int> <int>       <int>   <dbl>
1        2   286         286    1.59
2        3 15061       15347   85.2 
3        6   162       15509   86.1 
4        7  1490       16999   94.3 
5        9    76       17075   94.8 
6       14   122       17197   95.4 
# A tibble: 5 x 4
  slab_len     n n_less_than percent
     <int> <int>       <int>   <dbl>
1      126    14       18010    99.9
2      127     1       18011    99.9
3      189     7       18018   100. 
4      254     1       18019   100. 
5     1022     2       18021   100  

  Slab Types
# A tibble: 6 x 2
  func_name                                                                    n
  <chr>                                                                    <int>
1 Slab<Str*>* NewSlab<Str*>(int)                                            6157
2 Slab<runtime_asdl::part_value_t*>* NewSlab<runtime_asdl::part_value_t*>~  4086
3 Slab<syntax_asdl::CompoundWord*>* NewSlab<syntax_asdl::CompoundWord*>(i~  1887
4 Slab<int>* NewSlab<int>(int)                                               934
5 Slab<List<Tuple3<Str*, bool, bool>*>*>* NewSlab<List<Tuple3<Str*, bool,~   932
6 Slab<Tuple2<runtime_asdl::span_e, int>*>* NewSlab<Tuple2<runtime_asdl::~   932
# A tibble: 5 x 2
  func_name                                                                    n
  <chr>                                                                    <int>
1 Slab<split::IfsSplitter*>* NewSlab<split::IfsSplitter*>(int)                 1
2 Slab<state::_ArgFrame*>* NewSlab<state::_ArgFrame*>(int)                     1
3 Slab<syntax_asdl::Token*>* NewSlab<syntax_asdl::Token*>(int)                 1
4 Slab<syntax_asdl::debug_frame_t*>* NewSlab<syntax_asdl::debug_frame_t*>~     1
5 Slab<syntax_asdl::loc_t*>* NewSlab<syntax_asdl::loc_t*>(int)                 1

18,021 slabs, total items = 90,538
24.00% of allocs are slabs

::reserve(int n)

  Num Items
# A tibble: 15 x 4
   num_items     n n_less_than  percent
       <int> <int>       <int>    <dbl>
 1         0     3           3  0.00915
 2         1 20765       20768 63.3    
 3         2  4297       25065 76.4    
 4         3  1786       26851 81.9    
 5         4  2414       29265 89.2    
 6         5  2734       31999 97.6    
 7         6   501       32500 99.1    
 8         7    90       32590 99.4    
 9         8    23       32613 99.4    
10         9    23       32636 99.5    
11        10    21       32657 99.6    
12        11     9       32666 99.6    
13        12     9       32675 99.6    
14        13     6       32681 99.7    
15        14     7       32688 99.7    
# A tibble: 5 x 4
  num_items     n n_less_than percent
      <int> <int>       <int>   <dbl>
1        31    35       32783    100.
2        63     7       32790    100.
3       105     2       32792    100.
4       204     1       32793    100.
5      1022     2       32795    100 

32,795 reserve() calls, total items = 67,578

Untyped: 75,091
Typed + Str + Slab: 75,091