https://github.com/cjdb commented:

```
$ libcxx/utils/libcxx-compare-benchmarks 
build-c7df8839d8f161883e5b4c3847c3470ab8e08e64 build-size-based-vector 
libcxx/test/benchmarks/containers/sequence/vector.bench.cpp
Requirement already satisfied: numpy in 
/tmp/libcxx-compare-benchmarks-venv/lib/python3.13/site-packages (from -r 
/tmp/llvm-project/third-party/benchmark/tools/requirements.txt (line 1)) (2.3.2)
Requirement already satisfied: scipy in 
/tmp/libcxx-compare-benchmarks-venv/lib/python3.13/site-packages (from -r 
/tmp/llvm-project/third-party/benchmark/tools/requirements.txt (line 2)) 
(1.16.1)
Comparing 
build-c7df8839d8f161883e5b4c3847c3470ab8e08e64/libcxx/test/benchmarks/containers/sequence/Output/vector.bench.cpp.dir/benchmark-result.json
 to 
build-size-based-vector/libcxx/test/benchmarks/containers/sequence/Output/vector.bench.cpp.dir/benchmark-result.json
Benchmark                                                                       
                                          Time             CPU      Time Old    
  Time New       CPU Old       CPU New
------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
std::vector<int>::ctor(size)/32                                                 
                                       +0.0272         +0.0268            14    
        15            14            15
std::vector<int>::ctor(size)/1024                                               
                                       +0.0026         +0.0023            71    
        71            71            71
std::vector<int>::ctor(size)/8192                                               
                                       -0.0016         -0.0010           349    
       349           349           349
std::vector<int>::ctor(size, value_type) (cheap elements)/32                    
                                       +0.0251         +0.0252            13    
        13            13            13
std::vector<int>::ctor(size, value_type) (cheap elements)/1024                  
                                       -0.0031         -0.0036           115    
       115           115           115
std::vector<int>::ctor(size, value_type) (cheap elements)/8192                  
                                       +0.0043         +0.0043           659    
       662           658           661
std::vector<int>::ctor(Iterator, Iterator) (cheap elements)/32                  
                                       -0.0034         -0.0038            15    
        15            15            15
std::vector<int>::ctor(Iterator, Iterator) (cheap elements)/1024                
                                       -0.0036         -0.0036            75    
        74            74            74
std::vector<int>::ctor(Iterator, Iterator) (cheap elements)/8192                
                                       +0.0000         -0.0001           669    
       669           668           668
std::vector<int>::ctor(Range) (cheap elements)/32                               
                                       -0.0075         -0.0071            15    
        15            15            15
std::vector<int>::ctor(Range) (cheap elements)/1024                             
                                       +0.0010         +0.0014            75    
        75            74            75
std::vector<int>::ctor(Range) (cheap elements)/8192                             
                                       -0.0005         -0.0007           668    
       667           667           667
std::vector<int>::ctor(const&) (cheap elements)/32                              
                                       -0.0021         -0.0019            15    
        15            15            15
std::vector<int>::ctor(const&) (cheap elements)/1024                            
                                       -0.0035         -0.0030            75    
        75            75            75
std::vector<int>::ctor(const&) (cheap elements)/8192                            
                                       -0.0037         -0.0033           669    
       667           669           667
std::vector<int>::operator=(const&) (cheap elements)/32                         
                                       -0.0036         -0.0031             5    
         5             5             5
std::vector<int>::operator=(const&) (cheap elements)/1024                       
                                       -0.0014         -0.0015            41    
        41            41            41
std::vector<int>::operator=(const&) (cheap elements)/8192                       
                                       -0.0018         -0.0015           652    
       651           652           651
std::vector<int>::assign(input-iter, input-iter) (full container) (cheap 
elements)/32                                  +0.0190         +0.0191           
 24            25            24            25
std::vector<int>::assign(input-iter, input-iter) (full container) (cheap 
elements)/1024                                +0.0043         +0.0046           
656           659           655           658
std::vector<int>::assign(input-iter, input-iter) (full container) (cheap 
elements)/8192                                +0.0037         +0.0036          
5303          5322          5299          5318
std::vector<int>::insert(begin) (cheap elements)/32                             
                                       +0.0023         +0.0024             9    
         9             9             9
std::vector<int>::insert(begin) (cheap elements)/1024                           
                                       -0.0017         -0.0017            48    
        48            48            48
std::vector<int>::insert(begin) (cheap elements)/8192                           
                                       -0.0015         -0.0013           332    
       331           332           331
std::vector<int>::insert(middle) (cheap elements)/32                            
                                       -0.0033         -0.0036             9    
         9             9             9
std::vector<int>::insert(middle) (cheap elements)/1024                          
                                       -0.0040         -0.0045            28    
        28            28            28
std::vector<int>::insert(middle) (cheap elements)/8192                          
                                       -0.0014         -0.0010           169    
       169           169           169
std::vector<int>::insert(begin, input-iter, input-iter) (no realloc) (cheap 
elements)/32                               +0.0027         +0.0037          
1255          1258          1259          1263
std::vector<int>::insert(begin, input-iter, input-iter) (no realloc) (cheap 
elements)/1024                             +0.0029         +0.0048          
3834          3845          3839          3857
std::vector<int>::insert(begin, input-iter, input-iter) (no realloc) (cheap 
elements)/8192                             +0.0099         +0.0100         
21936         22153         21958         22177
std::vector<int>::insert(begin, input-iter, input-iter) (half filled) (cheap 
elements)/32                              -0.0015         -0.0011          1123 
         1122          1127          1126
std::vector<int>::insert(begin, input-iter, input-iter) (half filled) (cheap 
elements)/1024                            +0.0086         +0.0130          2172 
         2191          2184          2213
std::vector<int>::insert(begin, input-iter, input-iter) (half filled) (cheap 
elements)/8192                            +0.0210         +0.0219          9519 
         9719          9544          9752
std::vector<int>::insert(begin, input-iter, input-iter) (near full) (cheap 
elements)/32                                +0.0079         +0.0079          
1149          1158          1153          1162
std::vector<int>::insert(begin, input-iter, input-iter) (near full) (cheap 
elements)/1024                              +0.1679         +0.1659          
1878          2193          1899          2214
std::vector<int>::insert(begin, input-iter, input-iter) (near full) (cheap 
elements)/8192                              +0.3200         +0.3196          
6809          8988          6825          9007
std::vector<int>::push_back() (growing) (cheap elements)/32                     
                                       -0.0232         -0.0245            79    
        77            79            77
std::vector<int>::push_back() (growing) (cheap elements)/1024                   
                                       -0.0169         -0.0164           193    
       190           193           190
std::vector<int>::push_back() (growing) (cheap elements)/8192                   
                                       -0.0158         -0.0164          4362    
      4293          4347          4276
std::vector<int>::push_back() (with reserve) (cheap elements)/32                
                                       -0.0082         -0.0111            34    
        33            34            33
std::vector<int>::push_back() (with reserve) (cheap elements)/1024              
                                       -0.0105         -0.0128            34    
        34            34            33
std::vector<int>::push_back() (with reserve) (cheap elements)/8192              
                                       -0.0114         -0.0147            34    
        33            34            33
std::vector<int>::push_back() (many elements) (cheap elements)/32               
                                       -0.0069         -0.0073            34    
        33            34            33
std::vector<int>::push_back() (many elements) (cheap elements)/1024             
                                       -0.0099         -0.0106             1    
         1             1             1
std::vector<int>::push_back() (many elements) (cheap elements)/8192             
                                       -0.0065         -0.0062             1    
         1             1             1
std::vector<int>::erase(begin) (cheap elements)/32                              
                                       +0.0086         +0.0084            10    
        10            10            10
std::vector<int>::erase(begin) (cheap elements)/1024                            
                                       -0.0016         -0.0016            49    
        49            49            49
std::vector<int>::erase(begin) (cheap elements)/8192                            
                                       -0.0016         -0.0012           333    
       332           333           332
std::vector<int>::erase(middle) (cheap elements)/32                             
                                       -0.0058         -0.0062             8    
         8             8             8
std::vector<int>::erase(middle) (cheap elements)/1024                           
                                       -0.0533         -0.0535            31    
        29            31            29
std::vector<int>::erase(middle) (cheap elements)/8192                           
                                       -0.0013         -0.0011           171    
       171           171           171
std::vector<std::string>::ctor(size)/32                                         
                                       -0.0285         -0.0288            30    
        29            30            29
std::vector<std::string>::ctor(size)/1024                                       
                                       +0.0197         +0.0198           599    
       611           599           610
std::vector<std::string>::ctor(size)/8192                                       
                                       +0.0272         +0.0268          4857    
      4989          4853          4983
std::vector<std::string>::ctor(size, value_type) (cheap elements)/32            
                                       -0.1519         -0.1515            54    
        46            54            46
std::vector<std::string>::ctor(size, value_type) (cheap elements)/1024          
                                       +0.0076         +0.0079          1002    
      1009          1001          1009
std::vector<std::string>::ctor(size, value_type) (cheap elements)/8192          
                                       -0.0086         -0.0083          8557    
      8483          8548          8477
std::vector<std::string>::ctor(size, value_type) (expensive elements)/32        
                                       +0.0158         +0.0157          1160    
      1178          1159          1177
std::vector<std::string>::ctor(size, value_type) (expensive elements)/1024      
                                       +0.0086         +0.0088         38444    
     38777         38404         38741
std::vector<std::string>::ctor(size, value_type) (expensive elements)/8192      
                                       +0.0015         +0.0012        511106    
    511883        510649        511282
std::vector<std::string>::ctor(Iterator, Iterator) (cheap elements)/32          
                                       +0.0067         +0.0063            49    
        49            49            49
std::vector<std::string>::ctor(Iterator, Iterator) (cheap elements)/1024        
                                       +0.0052         +0.0047          1402    
      1409          1401          1408
std::vector<std::string>::ctor(Iterator, Iterator) (cheap elements)/8192        
                                       +0.0317         +0.0317         11411    
     11773         11402         11764
std::vector<std::string>::ctor(Iterator, Iterator) (expensive elements)/32      
                                       +0.0104         +0.0099          1107    
      1119          1107          1118
std::vector<std::string>::ctor(Iterator, Iterator) (expensive elements)/1024    
                                       -0.0425         -0.0422         40084    
     38379         40053         38361
std::vector<std::string>::ctor(Iterator, Iterator) (expensive elements)/8192    
                                       -0.0005         -0.0006        325009    
    324853        324743        324542
std::vector<std::string>::ctor(Range) (cheap elements)/32                       
                                       -0.0133         -0.0128            50    
        50            50            50
std::vector<std::string>::ctor(Range) (cheap elements)/1024                     
                                       -0.0044         -0.0044          1413    
      1407          1412          1406
std::vector<std::string>::ctor(Range) (cheap elements)/8192                     
                                       +0.0172         +0.0174         11468    
     11666         11458         11657
std::vector<std::string>::ctor(Range) (expensive elements)/32                   
                                       +0.0105         +0.0104          1106    
      1117          1105          1116
std::vector<std::string>::ctor(Range) (expensive elements)/1024                 
                                       -0.0227         -0.0227         39841    
     38935         39802         38899
std::vector<std::string>::ctor(Range) (expensive elements)/8192                 
                                       -0.0062         -0.0064        325031    
    323009        324784        322720
std::vector<std::string>::ctor(const&) (cheap elements)/32                      
                                       -0.0178         -0.0176            51    
        50            51            50
std::vector<std::string>::ctor(const&) (cheap elements)/1024                    
                                       +0.0119         +0.0121          1407    
      1424          1405          1422
std::vector<std::string>::ctor(const&) (cheap elements)/8192                    
                                       -0.1112         -0.1113         12700    
     11287         12692         11279
std::vector<std::string>::ctor(const&) (expensive elements)/32                  
                                       +0.0069         +0.0077          1108    
      1116          1107          1115
std::vector<std::string>::ctor(const&) (expensive elements)/1024                
                                       -0.0088         -0.0089         39814    
     39464         39784         39431
std::vector<std::string>::ctor(const&) (expensive elements)/8192                
                                       -0.0033         -0.0033        323495    
    322411        323212        322150
std::vector<std::string>::operator=(const&) (cheap elements)/32                 
                                       -0.0109         -0.0108            35    
        35            35            35
std::vector<std::string>::operator=(const&) (cheap elements)/1024               
                                       +0.0521         +0.0527          1011    
      1064          1010          1063
std::vector<std::string>::operator=(const&) (cheap elements)/8192               
                                       -0.0651         -0.0651          8866    
      8289          8861          8284
std::vector<std::string>::operator=(const&) (expensive elements)/32             
                                       +0.0264         +0.0264           209    
       215           209           215
std::vector<std::string>::operator=(const&) (expensive elements)/1024           
                                       +0.0350         +0.0338          9668    
     10006          9667          9994
std::vector<std::string>::operator=(const&) (expensive elements)/8192           
                                       -0.0374         -0.0375         82086    
     79017         82052         78973
std::vector<std::string>::assign(input-iter, input-iter) (full container) 
(cheap elements)/32                          -0.0005         -0.0006            
51            51            51            51
std::vector<std::string>::assign(input-iter, input-iter) (full container) 
(cheap elements)/1024                        -0.0553         -0.0554          
1466          1385          1465          1384
std::vector<std::string>::assign(input-iter, input-iter) (full container) 
(cheap elements)/8192                        +0.0215         +0.0216         
11451         11697         11441         11688
std::vector<std::string>::assign(input-iter, input-iter) (full container) 
(expensive elements)/32                      +0.0065         +0.0059           
241           242           241           242
std::vector<std::string>::assign(input-iter, input-iter) (full container) 
(expensive elements)/1024                    +0.0156         +0.0155         
10563         10727         10556         10719
std::vector<std::string>::assign(input-iter, input-iter) (full container) 
(expensive elements)/8192                    -0.0161         -0.0165         
87753         86339         87700         86250
std::vector<std::string>::insert(begin) (cheap elements)/32                     
                                       -0.0107         -0.0106            33    
        32            33            32
std::vector<std::string>::insert(begin) (cheap elements)/1024                   
                                       +0.0011         +0.0010          1002    
      1004          1002          1003
std::vector<std::string>::insert(begin) (cheap elements)/8192                   
                                       -0.0038         -0.0043          8433    
      8401          8430          8394
std::vector<std::string>::insert(begin) (expensive elements)/32                 
                                       +0.0130         +0.0128            48    
        49            48            49
std::vector<std::string>::insert(begin) (expensive elements)/1024               
                                       +0.0036         +0.0036          1055    
      1059          1054          1058
std::vector<std::string>::insert(begin) (expensive elements)/8192               
                                       -0.0017         -0.0012          8454    
      8439          8443          8433
std::vector<std::string>::insert(middle) (cheap elements)/32                    
                                       +0.0734         +0.0734            18    
        19            18            19
std::vector<std::string>::insert(middle) (cheap elements)/1024                  
                                       +0.0004         +0.0007           501    
       501           501           501
std::vector<std::string>::insert(middle) (cheap elements)/8192                  
                                       +0.0040         +0.0037          4195    
      4212          4193          4209
std::vector<std::string>::insert(middle) (expensive elements)/32                
                                       -0.0027         -0.0023            33    
        33            33            33
std::vector<std::string>::insert(middle) (expensive elements)/1024              
                                       +0.0062         +0.0058           517    
       520           517           520
std::vector<std::string>::insert(middle) (expensive elements)/8192              
                                       +0.0067         +0.0070          4225    
      4253          4221          4250
std::vector<std::string>::insert(begin, input-iter, input-iter) (no realloc) 
(cheap elements)/32                       +0.0151         +0.0124          1371 
         1392          1375          1392
std::vector<std::string>::insert(begin, input-iter, input-iter) (no realloc) 
(cheap elements)/1024                     +0.0130         +0.0109          4823 
         4886          4837          4890
std::vector<std::string>::insert(begin, input-iter, input-iter) (no realloc) 
(cheap elements)/8192                     +0.0118         +0.0135         29882 
        30233         29949         30352
std::vector<std::string>::insert(begin, input-iter, input-iter) (no realloc) 
(expensive elements)/32                   -0.0181         -0.0180          1966 
         1930          1983          1948
std::vector<std::string>::insert(begin, input-iter, input-iter) (no realloc) 
(expensive elements)/1024                 -0.0259         -0.0273         27109 
        26406         27280         26535
std::vector<std::string>::insert(begin, input-iter, input-iter) (no realloc) 
(expensive elements)/8192                 -0.0088         -0.0081       1032159 
      1023111       1030392       1022052
std::vector<std::string>::insert(begin, input-iter, input-iter) (half filled) 
(cheap elements)/32                      -0.0034         -0.0059          1205  
        1201          1214          1207
std::vector<std::string>::insert(begin, input-iter, input-iter) (half filled) 
(cheap elements)/1024                    -0.0031         -0.0029          3534  
        3523          3540          3529
std::vector<std::string>::insert(begin, input-iter, input-iter) (half filled) 
(cheap elements)/8192                    -0.0031         -0.0049         20811  
       20746         21001         20898
std::vector<std::string>::insert(begin, input-iter, input-iter) (half filled) 
(expensive elements)/32                  +0.0052         +0.0065          1944  
        1954          1963          1976
std::vector<std::string>::insert(begin, input-iter, input-iter) (half filled) 
(expensive elements)/1024                +0.0181         +0.0177         24967  
       25419         25074         25518
std::vector<std::string>::insert(begin, input-iter, input-iter) (half filled) 
(expensive elements)/8192                -0.0119         -0.0117       1213522  
     1199109       1212344       1198135
std::vector<std::string>::insert(begin, input-iter, input-iter) (near full) 
(cheap elements)/32                        +0.0040         +0.0031          
1273          1278          1280          1284
std::vector<std::string>::insert(begin, input-iter, input-iter) (near full) 
(cheap elements)/1024                      +0.0266         +0.0259          
5950          6108          5953          6107
std::vector<std::string>::insert(begin, input-iter, input-iter) (near full) 
(cheap elements)/8192                      -0.0106         -0.0093         
41340         40902         41333         40947
std::vector<std::string>::insert(begin, input-iter, input-iter) (near full) 
(expensive elements)/32                    -0.0033         -0.0030          
2026          2019          2033          2026
std::vector<std::string>::insert(begin, input-iter, input-iter) (near full) 
(expensive elements)/1024                  +0.0170         +0.0168         
28510         28995         28528         29008
std::vector<std::string>::insert(begin, input-iter, input-iter) (near full) 
(expensive elements)/8192                  -0.0598         -0.0599       
1436815       1350887       1435078       1349181
std::vector<std::string>::push_back() (growing) (cheap elements)/32             
                                       +0.0055         +0.0058            94    
        94            94            94
std::vector<std::string>::push_back() (growing) (cheap elements)/1024           
                                       -0.0014         -0.0019           814    
       813           813           811
std::vector<std::string>::push_back() (growing) (cheap elements)/8192           
                                       +0.0280         +0.0284         35454    
     36446         35406         36410
std::vector<std::string>::push_back() (growing) (expensive elements)/32         
                                       +0.0155         +0.0165           160    
       162           156           159
std::vector<std::string>::push_back() (growing) (expensive elements)/1024       
                                       +0.0212         +0.0212          2017    
      2059          1994          2036
std::vector<std::string>::push_back() (growing) (expensive elements)/8192       
                                       -0.0003         -0.0008         23065    
     23058         22979         22960
std::vector<std::string>::push_back() (with reserve) (cheap elements)/32        
                                       +0.0002         -0.0005            34    
        34            34            34
std::vector<std::string>::push_back() (with reserve) (cheap elements)/1024      
                                       +0.0027         +0.0023            34    
        34            34            34
std::vector<std::string>::push_back() (with reserve) (cheap elements)/8192      
                                       +0.0002         -0.0021            35    
        35            35            35
std::vector<std::string>::push_back() (with reserve) (expensive elements)/32    
                                       +0.0035         +0.0061            57    
        57            57            57
std::vector<std::string>::push_back() (with reserve) (expensive elements)/1024  
                                       -0.0048         -0.0033            55    
        55            56            56
std::vector<std::string>::push_back() (with reserve) (expensive elements)/8192  
                                       -0.0013         -0.0004            56    
        56            56            56
std::vector<std::string>::push_back() (many elements) (cheap elements)/32       
                                       -0.0109         -0.0117            35    
        35            35            35
std::vector<std::string>::push_back() (many elements) (cheap elements)/1024     
                                       -0.0141         -0.0150             2    
         2             2             2
std::vector<std::string>::push_back() (many elements) (cheap elements)/8192     
                                       -0.0204         -0.0227             1    
         1             1             1
std::vector<std::string>::push_back() (many elements) (expensive elements)/32   
                                       +0.0015         +0.0054            57    
        57            57            58
std::vector<std::string>::push_back() (many elements) (expensive elements)/1024 
                                       +0.0211         +0.0221            23    
        23            23            23
std::vector<std::string>::push_back() (many elements) (expensive elements)/8192 
                                       +0.0084         +0.0089            46    
        46            46            46
std::vector<std::string>::erase(begin) (cheap elements)/32                      
                                       +0.0123         +0.0118            33    
        33            32            33
std::vector<std::string>::erase(begin) (cheap elements)/1024                    
                                       +0.0079         +0.0085           975    
       982           974           982
std::vector<std::string>::erase(begin) (cheap elements)/8192                    
                                       +0.0065         +0.0062          8413    
      8467          8407          8460
std::vector<std::string>::erase(begin) (expensive elements)/32                  
                                       +0.0161         +0.0164            47    
        48            47            48
std::vector<std::string>::erase(begin) (expensive elements)/1024                
                                       -0.0052         -0.0050          1044    
      1038          1043          1038
std::vector<std::string>::erase(begin) (expensive elements)/8192                
                                       -0.0033         -0.0029          8427    
      8400          8420          8396
std::vector<std::string>::erase(middle) (cheap elements)/32                     
                                       -0.0100         -0.0099            18    
        17            18            17
std::vector<std::string>::erase(middle) (cheap elements)/1024                   
                                       -0.0001         +0.0001           488    
       488           488           488
std::vector<std::string>::erase(middle) (cheap elements)/8192                   
                                       -0.0005         -0.0006          4198    
      4196          4195          4192
std::vector<std::string>::erase(middle) (expensive elements)/32                 
                                       -0.0180         -0.0174            33    
        33            33            33
std::vector<std::string>::erase(middle) (expensive elements)/1024               
                                       -0.0024         -0.0028           512    
       511           512           510
std::vector<std::string>::erase(middle) (expensive elements)/8192               
                                       +0.0048         +0.0045          4231    
      4251          4228          4247
OVERALL_GEOMEAN                                                                 
                                       +0.0011         +0.0011             0    
         0             0             0
```
```
$ libcxx/utils/libcxx-compare-benchmarks 
build-c7df8839d8f161883e5b4c3847c3470ab8e08e64 build-size-based-vector 
libcxx/test/benchmarks/containers/sequence/deque.bench.cpp
Requirement already satisfied: numpy in 
/tmp/libcxx-compare-benchmarks-venv/lib/python3.13/site-packages (from -r 
/tmp/llvm-project/third-party/benchmark/tools/requirements.txt (line 1)) (2.3.2)
Requirement already satisfied: scipy in 
/tmp/libcxx-compare-benchmarks-venv/lib/python3.13/site-packages (from -r 
/tmp/llvm-project/third-party/benchmark/tools/requirements.txt (line 2)) 
(1.16.1)
Comparing 
build-c7df8839d8f161883e5b4c3847c3470ab8e08e64/libcxx/test/benchmarks/containers/sequence/Output/deque.bench.cpp.dir/benchmark-result.json
 to 
build-size-based-vector/libcxx/test/benchmarks/containers/sequence/Output/deque.bench.cpp.dir/benchmark-result.json
Benchmark                                                                       
                                     Time             CPU      Time Old      
Time New       CPU Old       CPU New
-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
std::deque<int>::ctor(size)/32                                                  
                                  -0.0239         -0.0236            64         
   62            64            62
std::deque<int>::ctor(size)/1024                                                
                                  -0.0119         -0.0126           121         
  119           121           119
std::deque<int>::ctor(size)/8192                                                
                                  -0.0059         -0.0059           663         
  659           662           658
std::deque<int>::ctor(size, value_type) (cheap elements)/32                     
                                  -0.0102         -0.0104            49         
   49            49            49
std::deque<int>::ctor(size, value_type) (cheap elements)/1024                   
                                  -0.0090         -0.0089           162         
  161           162           161
std::deque<int>::ctor(size, value_type) (cheap elements)/8192                   
                                  +0.0006         +0.0006           960         
  961           960           960
std::deque<int>::ctor(Iterator, Iterator) (cheap elements)/32                   
                                  -0.0302         -0.0298            51         
   49            51            49
std::deque<int>::ctor(Iterator, Iterator) (cheap elements)/1024                 
                                  -0.0064         -0.0063           181         
  180           181           179
std::deque<int>::ctor(Iterator, Iterator) (cheap elements)/8192                 
                                  -0.0170         -0.0155          1051         
 1033          1048          1032
std::deque<int>::ctor(Range) (cheap elements)/32                                
                                  -0.0095         -0.0095            65         
   65            65            65
std::deque<int>::ctor(Range) (cheap elements)/1024                              
                                  +0.0006         +0.0006           180         
  180           180           180
std::deque<int>::ctor(Range) (cheap elements)/8192                              
                                  -0.0184         -0.0176          1046         
 1026          1045          1026
std::deque<int>::ctor(const&) (cheap elements)/32                               
                                  -0.0166         -0.0161            82         
   81            82            81
std::deque<int>::ctor(const&) (cheap elements)/1024                             
                                  +0.0081         +0.0082           737         
  743           736           742
std::deque<int>::ctor(const&) (cheap elements)/8192                             
                                  -0.0086         -0.0078          5483         
 5435          5476          5434
std::deque<int>::operator=(const&) (cheap elements)/32                          
                                  +0.0078         +0.0076            12         
   12            12            12
std::deque<int>::operator=(const&) (cheap elements)/1024                        
                                  +0.0153         +0.0157            46         
   47            46            47
std::deque<int>::operator=(const&) (cheap elements)/8192                        
                                  +0.0035         +0.0034           684         
  686           683           686
std::deque<int>::assign(input-iter, input-iter) (full container) (cheap 
elements)/32                              +0.0241         +0.0243            26 
           26            26            26
std::deque<int>::assign(input-iter, input-iter) (full container) (cheap 
elements)/1024                            -0.0019         -0.0018           659 
          658           659           658
std::deque<int>::assign(input-iter, input-iter) (full container) (cheap 
elements)/8192                            +0.0077         +0.0079          5335 
         5377          5331          5373
std::deque<int>::insert(begin) (cheap elements)/32                              
                                  -0.0271         -0.0263            16         
   16            16            16
std::deque<int>::insert(begin) (cheap elements)/1024                            
                                  -0.0215         -0.0218            16         
   16            16            16
std::deque<int>::insert(begin) (cheap elements)/8192                            
                                  -0.0195         -0.0190            16         
   16            16            16
std::deque<int>::insert(middle) (cheap elements)/32                             
                                  +0.0161         +0.0160            37         
   37            37            37
std::deque<int>::insert(middle) (cheap elements)/1024                           
                                  -0.0018         -0.0016            63         
   63            63            63
std::deque<int>::insert(middle) (cheap elements)/8192                           
                                  +0.0007         +0.0003           241         
  241           240           240
std::deque<int>::push_back() (many elements) (cheap elements)/32                
                                  +0.0265         +0.0258            34         
   35            34            35
std::deque<int>::push_back() (many elements) (cheap elements)/1024              
                                  +0.0106         +0.0100             2         
    2             2             2
std::deque<int>::push_back() (many elements) (cheap elements)/8192              
                                  +0.0389         +0.0386             3         
    3             3             3
std::deque<int>::erase(begin) (cheap elements)/32                               
                                  -0.0398         -0.0399            18         
   17            18            17
std::deque<int>::erase(begin) (cheap elements)/1024                             
                                  -0.0267         -0.0270            18         
   18            18            18
std::deque<int>::erase(begin) (cheap elements)/8192                             
                                  +0.1073         +0.1077            18         
   20            18            20
std::deque<int>::erase(middle) (cheap elements)/32                              
                                  -0.0064         -0.0062            21         
   20            21            20
std::deque<int>::erase(middle) (cheap elements)/1024                            
                                  -0.0032         -0.0030            44         
   44            44            44
std::deque<int>::erase(middle) (cheap elements)/8192                            
                                  +0.0101         +0.0103           192         
  194           192           194
std::deque<std::string>::ctor(size)/32                                          
                                  -0.0831         -0.0828           109         
  100           109           100
std::deque<std::string>::ctor(size)/1024                                        
                                  -0.1551         -0.1548          1523         
 1287          1522          1286
std::deque<std::string>::ctor(size)/8192                                        
                                  +0.0038         -0.0039         47605         
47788         47117         46935
std::deque<std::string>::ctor(size, value_type) (cheap elements)/32             
                                  -0.0587         -0.0589           126         
  119           126           119
std::deque<std::string>::ctor(size, value_type) (cheap elements)/1024           
                                  -0.1018         -0.1020          1981         
 1779          1979          1777
std::deque<std::string>::ctor(size, value_type) (cheap elements)/8192           
                                  +0.0289         +0.0242         51041         
52518         50509         51730
std::deque<std::string>::ctor(size, value_type) (expensive elements)/32         
                                  +0.0157         +0.0152          1155         
 1173          1154          1172
std::deque<std::string>::ctor(size, value_type) (expensive elements)/1024       
                                  +0.0562         +0.0509        129484        
136767        128459        134992
std::deque<std::string>::ctor(size, value_type) (expensive elements)/8192       
                                  +0.1013         +0.1014       1458138       
1605904       1456303       1603954
std::deque<std::string>::ctor(Iterator, Iterator) (cheap elements)/32           
                                  -0.0037         -0.0039           122         
  121           122           121
std::deque<std::string>::ctor(Iterator, Iterator) (cheap elements)/1024         
                                  -0.1435         -0.1435          2128         
 1822          2126          1821
std::deque<std::string>::ctor(Iterator, Iterator) (cheap elements)/8192         
                                  -0.1078         -0.1084         17227         
15370         17216         15349
std::deque<std::string>::ctor(Iterator, Iterator) (expensive elements)/32       
                                  +0.0558         +0.0551          1127         
 1190          1126          1188
std::deque<std::string>::ctor(Iterator, Iterator) (expensive elements)/1024     
                                  +0.0315         +0.0312         40899         
42187         40864         42141
std::deque<std::string>::ctor(Iterator, Iterator) (expensive elements)/8192     
                                  +0.0492         +0.0491       1378985       
1446801       1377638       1445289
std::deque<std::string>::ctor(Range) (cheap elements)/32                        
                                  -0.0225         -0.0229           128         
  125           128           125
std::deque<std::string>::ctor(Range) (cheap elements)/1024                      
                                  -0.0900         -0.0903          2148         
 1955          2147          1953
std::deque<std::string>::ctor(Range) (cheap elements)/8192                      
                                  -0.0729         -0.0735         17528         
16251         17512         16225
std::deque<std::string>::ctor(Range) (expensive elements)/32                    
                                  +0.0472         +0.0471          1172         
 1227          1171          1226
std::deque<std::string>::ctor(Range) (expensive elements)/1024                  
                                  +0.0505         +0.0488        121795        
127940        121220        127141
std::deque<std::string>::ctor(Range) (expensive elements)/8192                  
                                  +0.0458         +0.0452       1378127       
1441236       1377209       1439413
std::deque<std::string>::ctor(const&) (cheap elements)/32                       
                                  -0.0659         -0.0660           146         
  137           146           137
std::deque<std::string>::ctor(const&) (cheap elements)/1024                     
                                  -0.1044         -0.1046          2702         
 2420          2700          2418
std::deque<std::string>::ctor(const&) (cheap elements)/8192                     
                                  -0.2204         -0.2205         21421         
16701         21402         16682
std::deque<std::string>::ctor(const&) (expensive elements)/32                   
                                  +0.0941         +0.0936          1193         
 1306          1192          1304
std::deque<std::string>::ctor(const&) (expensive elements)/1024                 
                                  +0.0196         +0.0191         41413         
42223         41372         42163
std::deque<std::string>::ctor(const&) (expensive elements)/8192                 
                                  -0.0159         -0.0161       1397071       
1374882       1395270       1372747
std::deque<std::string>::operator=(const&) (cheap elements)/32                  
                                  +0.0044         +0.0039            45         
   46            45            45
std::deque<std::string>::operator=(const&) (cheap elements)/1024                
                                  +0.0082         +0.0076          1051         
 1060          1051          1059
std::deque<std::string>::operator=(const&) (cheap elements)/8192                
                                  +0.0062         +0.0063          8440         
 8492          8432          8485
std::deque<std::string>::operator=(const&) (expensive elements)/32              
                                  -0.1223         -0.1224           276         
  242           276           242
std::deque<std::string>::operator=(const&) (expensive elements)/1024            
                                  -0.0287         -0.0287          9847         
 9565          9839          9557
std::deque<std::string>::operator=(const&) (expensive elements)/8192            
                                  -0.0287         -0.0282         83281         
80887         83182         80836
std::deque<std::string>::assign(input-iter, input-iter) (full container) (cheap 
elements)/32                      +0.0216         +0.0208            57         
   58            57            58
std::deque<std::string>::assign(input-iter, input-iter) (full container) (cheap 
elements)/1024                    -0.0313         -0.0315          1713         
 1659          1712          1658
std::deque<std::string>::assign(input-iter, input-iter) (full container) (cheap 
elements)/8192                    +0.0056         +0.0053         13346         
13420         13336         13407
std::deque<std::string>::assign(input-iter, input-iter) (full container) 
(expensive elements)/32                  -0.0090         -0.0091           252  
         249           251           249
std::deque<std::string>::assign(input-iter, input-iter) (full container) 
(expensive elements)/1024                +0.0113         +0.0113         10780  
       10902         10769         10890
std::deque<std::string>::assign(input-iter, input-iter) (full container) 
(expensive elements)/8192                -0.0085         -0.0090         90124  
       89359         90077         89268
std::deque<std::string>::insert(begin) (cheap elements)/32                      
                                  -0.0113         -0.0113            34         
   34            34            34
std::deque<std::string>::insert(begin) (cheap elements)/1024                    
                                  -0.0126         -0.0129            34         
   34            34            34
std::deque<std::string>::insert(begin) (cheap elements)/8192                    
                                  -0.0200         -0.0202            34         
   34            34            34
std::deque<std::string>::insert(begin) (expensive elements)/32                  
                                  -0.0193         -0.0195            45         
   44            45            44
std::deque<std::string>::insert(begin) (expensive elements)/1024                
                                  +0.0290         +0.0282            46         
   47            46            47
std::deque<std::string>::insert(begin) (expensive elements)/8192                
                                  +0.0049         +0.0046            46         
   47            46            47
std::deque<std::string>::insert(middle) (cheap elements)/32                     
                                  +0.0303         +0.0298            65         
   67            65            67
std::deque<std::string>::insert(middle) (cheap elements)/1024                   
                                  +0.0096         +0.0094           587         
  593           586           592
std::deque<std::string>::insert(middle) (cheap elements)/8192                   
                                  +0.0047         +0.0038          4424         
 4445          4422          4439
std::deque<std::string>::insert(middle) (expensive elements)/32                 
                                  -0.0055         -0.0059            80         
   80            80            80
std::deque<std::string>::insert(middle) (expensive elements)/1024               
                                  +0.0005         -0.0000           606         
  607           606           606
std::deque<std::string>::insert(middle) (expensive elements)/8192               
                                  +0.0022         +0.0019          4424         
 4434          4422          4430
std::deque<std::string>::push_back() (many elements) (cheap elements)/32        
                                  +0.0066         +0.0055            36         
   37            36            37
std::deque<std::string>::push_back() (many elements) (cheap elements)/1024      
                                  -0.0170         -0.0176             5         
    5             5             5
std::deque<std::string>::push_back() (many elements) (cheap elements)/8192      
                                  -0.0237         -0.0240             4         
    4             4             4
std::deque<std::string>::push_back() (many elements) (expensive elements)/32    
                                  -0.0085         -0.0077            59         
   59            60            59
std::deque<std::string>::push_back() (many elements) (expensive elements)/1024  
                                  +0.0025         +0.0056            25         
   25            25            25
std::deque<std::string>::push_back() (many elements) (expensive elements)/8192  
                                  +0.0107         +0.0099            24         
   24            24            24
std::deque<std::string>::erase(begin) (cheap elements)/32                       
                                  -0.0131         -0.0132            23         
   22            23            22
std::deque<std::string>::erase(begin) (cheap elements)/1024                     
                                  +0.0160         +0.0155            23         
   24            23            24
std::deque<std::string>::erase(begin) (cheap elements)/8192                     
                                  +0.0169         +0.0165            23         
   23            23            23
std::deque<std::string>::erase(begin) (expensive elements)/32                   
                                  -0.0049         -0.0051            37         
   37            37            37
std::deque<std::string>::erase(begin) (expensive elements)/1024                 
                                  -0.0210         -0.0213            40         
   39            40            39
std::deque<std::string>::erase(begin) (expensive elements)/8192                 
                                  -0.0066         -0.0067            40         
   40            40            40
std::deque<std::string>::erase(middle) (cheap elements)/32                      
                                  +0.0029         +0.0025            48         
   48            48            48
std::deque<std::string>::erase(middle) (cheap elements)/1024                    
                                  -0.0048         -0.0049           557         
  554           556           554
std::deque<std::string>::erase(middle) (cheap elements)/8192                    
                                  +0.0080         +0.0075          4297         
 4331          4294          4326
std::deque<std::string>::erase(middle) (expensive elements)/32                  
                                  -0.0025         -0.0028            59         
   59            59            59
std::deque<std::string>::erase(middle) (expensive elements)/1024                
                                  -0.0025         -0.0025           569         
  567           568           567
std::deque<std::string>::erase(middle) (expensive elements)/8192                
                                  +0.0228         +0.0225          4310         
 4408          4307          4404
OVERALL_GEOMEAN
```

https://github.com/llvm/llvm-project/pull/139632
_______________________________________________
lldb-commits mailing list
lldb-commits@lists.llvm.org
https://lists.llvm.org/cgi-bin/mailman/listinfo/lldb-commits

Reply via email to