Percentage of allocs less than 32 bytes: 77.9

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 10387       33168 26.3   
 7      17  1458       34626 27.5   
 8      18    29       34655 27.5   
 9      19   481       35136 27.9   
10      20    38       35174 27.9   
11      21   523       35697 28.4   
12      22    46       35743 28.4   
13      23    94       35837 28.5   
14      24 49613       85450 67.9   
15      25    32       85482 67.9   
16      26   911       86393 68.6   
17      27    21       86414 68.6   
18      28     5       86419 68.6   
19      29     9       86428 68.6   
20      31    11       86439 68.7   
21      32 11582       98021 77.9   
22      33     7       98028 77.9   
# A tibble: 5 x 4
  obj_len     n n_less_than percent
    <int> <int>       <int>   <dbl>
1     264   121      125874    100.
2     520    18      125892    100.
3    1032     6      125898    100.
4    4104     2      125900    100.
5    4109     2      125902    100 

Common Sizes
# A tibble: 8 x 2
  obj_len     n
    <int> <int>
1      24 49613
2      40 24879
3      14 17571
4      32 11582
5      16 10387
6      15  2464
7      72  2110
8      10  1824

    125,902 total allocations, total bytes = 3,384,731

Typed allocations
# A tibble: 20 x 3
   func_name                                                           n percent
   <chr>                                                           <int>   <dbl>
 1 List<Str*>* Alloc<List<Str*>>()                                  8402   11.4 
 2 List<runtime_asdl::part_value_t*>* Alloc<List<runtime_asdl::pa~  5981    8.09
 3 List<process::Process*>* Alloc<List<process::Process*>>()        3187    4.31
 4 List<process::_RedirFrame*>* Alloc<List<process::_RedirFrame*>~  3187    4.31
 5 process::_FdFrame* Alloc<process::_FdFrame>()                    3187    4.31
 6 List<runtime_asdl::RedirValue*>* Alloc<List<runtime_asdl::Redi~  3186    4.31
 7 executor::_ProcessSubFrame* Alloc<executor::_ProcessSubFrame>()  3186    4.31
 8 runtime_asdl::CommandStatus* Alloc<runtime_asdl::CommandStatus~  3186    4.31
 9 runtime_asdl::StatusArray* Alloc<runtime_asdl::StatusArray, de~  3186    4.31
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

73,970 typed allocs, including 34,869 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.1
 6       6   481       23403    93.0
 7       7    38       23441    93.1
 8       8   523       23964    95.2
 9       9    46       24010    95.4
10      10    94       24104    95.7
11      11    27       24131    95.9
12      12    32       24163    96.0
13      13   911       25074    99.6
14      14    21       25095    99.7
15      15     5       25100    99.7
16      16     9       25109    99.7
# A tibble: 5 x 4
  str_len     n n_less_than percent
    <int> <int>       <int>   <dbl>
1     113     1       25170    100.
2     134     1       25171    100.
3     137     1       25172    100.
4     196     1       25173    100.
5    4096     2       25175    100 

25,175 string allocations, total length = 65,146, total bytes = 392,421

20.00% 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   372         372    1.39
2        3 23313       23685   88.5 
3        6   214       23899   89.3 
4        7  1945       25844   96.6 
5       14   162       26006   97.2 
6       15    25       26031   97.3 
# A tibble: 5 x 4
  slab_len     n n_less_than percent
     <int> <int>       <int>   <dbl>
1      120     1       26738    99.9
2      126    15       26753   100. 
3      127     1       26754   100. 
4      254     1       26755   100. 
5     1022     2       26757   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,757 slabs, total items = 114,628
21.25% 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.00243
 2         1 24724       24725 60.0    
 3         2  3531       28256 68.6    
 4         3  2588       30844 74.9    
 5         4  2953       33797 82.1    
 6         5  3211       37008 89.9    
 7         6  2298       39306 95.4    
 8         7    80       39386 95.6    
 9         8    72       39458 95.8    
10         9    72       39530 96.0    
11        10    68       39598 96.2    
12        11    53       39651 96.3    
13        12    52       39703 96.4    
14        13    50       39753 96.5    
15        14    50       39803 96.7    
# A tibble: 5 x 4
  num_items     n n_less_than percent
      <int> <int>       <int>   <dbl>
1       111     1       41177    100.
2       112     1       41178    100.
3       113     1       41179    100.
4       198     1       41180    100.
5      1022     2       41182    100 

41,182 reserve() calls, total items = 137,781

Untyped: 125,902
Typed + Str + Slab: 125,902