Percentage of allocs less than 32 bytes: 77.8

All allocations
# A tibble: 22 x 4
   obj_len     n n_less_than percent
     <int> <int>       <int>   <dbl>
 1       9    30          30  0.0238
 2      10  1824        1854  1.47  
 3      12   892        2746  2.18  
 4      14 17571       20317 16.1   
 5      15  2464       22781 18.1   
 6      16 10426       33207 26.3   
 7      17  1458       34665 27.5   
 8      18    29       34694 27.5   
 9      19   481       35175 27.9   
10      20    38       35213 27.9   
11      21   522       35735 28.4   
12      22    52       35787 28.4   
13      23    90       35877 28.5   
14      24 49670       85547 67.9   
15      25    34       85581 67.9   
16      26   911       86492 68.6   
17      27    21       86513 68.6   
18      28     5       86518 68.6   
19      29     9       86527 68.6   
20      31    11       86538 68.7   
21      32 11581       98119 77.8   
22      33    10       98129 77.9   
# A tibble: 5 x 4
  obj_len     n n_less_than percent
    <int> <int>       <int>   <dbl>
1     268     1      126018    100.
2     520    18      126036    100.
3    1032     6      126042    100.
4    4104     2      126044    100.
5    4109     2      126046    100 

Common Sizes
# A tibble: 8 x 2
  obj_len     n
    <int> <int>
1      24 49670
2      40 24919
3      14 17571
4      32 11581
5      16 10426
6      15  2464
7      72  2119
8      10  1824

    126,046 total allocations, total bytes = 3,388,034

Typed allocations
# A tibble: 20 x 3
   func_name                                                           n percent
   <chr>                                                           <int>   <dbl>
 1 List<Str*>* Alloc<List<Str*>>()                                  8402   11.3 
 2 List<runtime_asdl::part_value_t*>* Alloc<List<runtime_asdl::pa~  5981    8.08
 3 List<process::Process*>* Alloc<List<process::Process*>>()        3187    4.30
 4 List<process::_RedirFrame*>* Alloc<List<process::_RedirFrame*>~  3187    4.30
 5 process::_FdFrame* Alloc<process::_FdFrame>()                    3187    4.30
 6 List<runtime_asdl::RedirValue*>* Alloc<List<runtime_asdl::Redi~  3186    4.30
 7 executor::_ProcessSubFrame* Alloc<executor::_ProcessSubFrame>()  3186    4.30
 8 runtime_asdl::CommandStatus* Alloc<runtime_asdl::CommandStatus~  3186    4.30
 9 runtime_asdl::StatusArray* Alloc<runtime_asdl::StatusArray, de~  3186    4.30
10 runtime_asdl::value__Str* Alloc<runtime_asdl::value__Str, Str*~  2257    3.05
11 mylib::BufWriter* Alloc<mylib::BufWriter>()                      1866    2.52
12 List<List<Tuple3<Str*, bool, bool>*>*>* Alloc<List<List<Tuple3~  1864    2.52
13 List<Tuple2<runtime_asdl::span_e, int>*>* Alloc<List<Tuple2<ru~  1864    2.52
14 List<Tuple3<Str*, bool, bool>*>* Alloc<List<Tuple3<Str*, bool,~  1864    2.52
15 List<mylib::BufWriter*>* Alloc<List<mylib::BufWriter*>>()        1864    2.52
16 Tuple2<runtime_asdl::span_e, int>* Alloc<Tuple2<runtime_asdl::~  1864    2.52
17 Tuple3<Str*, bool, bool>* Alloc<Tuple3<Str*, bool, bool>, Str*~  1864    2.52
18 syntax_asdl::word__String* Alloc<syntax_asdl::word__String, in~  1844    2.49
19 runtime_asdl::VarSubState* Alloc<runtime_asdl::VarSubState, bo~  1814    2.45
20 runtime_asdl::part_value__String* Alloc<runtime_asdl::part_val~  1814    2.45
# A tibble: 5 x 3
  func_name                                                            n percent
  <chr>                                                            <int>   <dbl>
1 util::DebugFile* Alloc<util::DebugFile, mylib::Writer*>(mylib::~     1 0.00135
2 util::NullDebugFile* Alloc<util::NullDebugFile>()                    1 0.00135
3 word_eval::NormalWordEvaluator* Alloc<word_eval::NormalWordEval~     1 0.00135
4 word_eval::TildeEvaluator* Alloc<word_eval::TildeEvaluator, sta~     1 0.00135
5 word_parse::WordParser* Alloc<word_parse::WordParser, parse_lib~     1 0.00135

74,058 typed allocs, including 34,903 List<T>
58.75% 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 17571       17571    69.8
 2       2  2464       20035    79.6
 3       3  1400       21435    85.1
 4       4  1458       22893    90.9
 5       5    29       22922    91.0
 6       6   481       23403    93.0
 7       7    38       23441    93.1
 8       8   522       23963    95.2
 9       9    52       24015    95.4
10      10    90       24105    95.7
11      11    27       24132    95.8
12      12    34       24166    96.0
13      13   911       25077    99.6
14      14    21       25098    99.7
15      15     5       25103    99.7
16      16     9       25112    99.7
# A tibble: 5 x 4
  str_len     n n_less_than percent
    <int> <int>       <int>   <dbl>
1     134     1       25172    100.
2     137     1       25173    100.
3     196     1       25174    100.
4     255     1       25175    100.
5    4096     2       25177    100 

25,177 string allocations, total length = 65,255, total bytes = 392,556

19.97% of allocs are strings
11.59% of bytes are strings

NewSlab()
  Lengths
# A tibble: 6 x 4
  slab_len     n n_less_than percent
     <int> <int>       <int>   <dbl>
1        2   390         390    1.45
2        3 23346       23736   88.5 
3        6   211       23947   89.3 
4        7  1950       25897   96.6 
5       14   165       26062   97.2 
6       15    26       26088   97.3 
# A tibble: 5 x 4
  slab_len     n n_less_than percent
     <int> <int>       <int>   <dbl>
1      120     1       26792    99.9
2      126    15       26807   100. 
3      127     1       26808   100. 
4      254     1       26809   100. 
5     1022     2       26811   100  

  Slab Types
# A tibble: 6 x 2
  func_name                                                                    n
  <chr>                                                                    <int>
1 Slab<Str*>* NewSlab<Str*>(int)                                            9402
2 Slab<runtime_asdl::part_value_t*>* NewSlab<runtime_asdl::part_value_t*>~  5981
3 Slab<syntax_asdl::CompoundWord*>* NewSlab<syntax_asdl::CompoundWord*>(i~  1885
4 Slab<List<Tuple3<Str*, bool, bool>*>*>* NewSlab<List<Tuple3<Str*, bool,~  1864
5 Slab<Tuple2<runtime_asdl::span_e, int>*>* NewSlab<Tuple2<runtime_asdl::~  1864
6 Slab<Tuple3<Str*, bool, bool>*>* NewSlab<Tuple3<Str*, bool, bool>*>(int)  1864
# A tibble: 5 x 2
  func_name                                                        n
  <chr>                                                        <int>
1 Slab<state::DebugFrame*>* NewSlab<state::DebugFrame*>(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::loc_t*>* NewSlab<syntax_asdl::loc_t*>(int)     1
5 Slab<void*>* NewSlab<void*>(int)                                 1

26,811 slabs, total items = 114,555
21.27% 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     1           1  0.00242
 2         1 24753       24754 60.0    
 3         2  3548       28302 68.5    
 4         3  2593       30895 74.8    
 5         4  2959       33854 82.0    
 6         5  3216       37070 89.8    
 7         6  2301       39371 95.4    
 8         7    81       39452 95.6    
 9         8    74       39526 95.7    
10         9    74       39600 95.9    
11        10    70       39670 96.1    
12        11    55       39725 96.2    
13        12    54       39779 96.3    
14        13    51       39830 96.5    
15        14    51       39881 96.6    
# A tibble: 5 x 4
  num_items     n n_less_than percent
      <int> <int>       <int>   <dbl>
1       113     1       41284    100.
2       114     1       41285    100.
3       115     1       41286    100.
4       204     1       41287    100.
5      1022     2       41289    100 

41,289 reserve() calls, total items = 140,829

Untyped: 126,046
Typed + Str + Slab: 126,046