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 49668       85545 67.9   
15      25    34       85579 67.9   
16      26   911       86490 68.6   
17      27    21       86511 68.6   
18      28     5       86516 68.6   
19      29     9       86525 68.6   
20      31    11       86536 68.7   
21      32 11581       98117 77.8   
22      33    10       98127 77.9   
# A tibble: 5 x 4
  obj_len     n n_less_than percent
    <int> <int>       <int>   <dbl>
1     268     1      126012    100.
2     520    18      126030    100.
3    1032     6      126036    100.
4    4104     2      126038    100.
5    4109     2      126040    100 

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

    126,040 total allocations, total bytes = 3,387,794

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,055 typed allocs, including 34,903 List<T>
58.76% 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.98% 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   387         387    1.44
2        3 23346       23733   88.5 
3        6   211       23944   89.3 
4        7  1950       25894   96.6 
5       14   165       26059   97.2 
6       15    26       26085   97.3 
# A tibble: 5 x 4
  slab_len     n n_less_than percent
     <int> <int>       <int>   <dbl>
1      120     1       26789    99.9
2      126    15       26804   100. 
3      127     1       26805   100. 
4      254     1       26806   100. 
5     1022     2       26808   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,808 slabs, total items = 114,549
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 24752       24753 60.0    
 3         2  3547       28300 68.5    
 4         3  2593       30893 74.8    
 5         4  2959       33852 82.0    
 6         5  3216       37068 89.8    
 7         6  2301       39369 95.4    
 8         7    81       39450 95.6    
 9         8    74       39524 95.7    
10         9    74       39598 95.9    
11        10    70       39668 96.1    
12        11    55       39723 96.2    
13        12    54       39777 96.3    
14        13    51       39828 96.5    
15        14    51       39879 96.6    
# A tibble: 5 x 4
  num_items     n n_less_than percent
      <int> <int>       <int>   <dbl>
1       113     1       41282    100.
2       114     1       41283    100.
3       115     1       41284    100.
4       204     1       41285    100.
5      1022     2       41287    100 

41,287 reserve() calls, total items = 140,826

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