Skip to content

[benchmark] Expand ParseInt benchmarks #29988

New issue

Have a question about this project? Sign up for a free GitHub account to open an issue and contact its maintainers and the community.

By clicking “Sign up for GitHub”, you agree to our terms of service and privacy statement. We’ll occasionally send you account related emails.

Already on GitHub? Sign in to your account

Merged

Conversation

PatrickPijnappel
Copy link
Contributor

@PatrickPijnappel PatrickPijnappel commented Feb 21, 2020

Expands the integer parsing benchmarks to distinguish between:

  • Signed vs. unsigned: shows sign handling performance.
  • 32-bit vs. 64-bit integers: both are common parsing cases and can perform significantly different due to small vs large strings.

These are in preparation for a full rewrite of integer parsing (which I finally found some time to finish up), where performance will clearly vary along these axes.

@PatrickPijnappel
Copy link
Contributor Author

@swift-ci Please benchmark

@swift-ci
Copy link
Contributor

Performance: -O

Regression OLD NEW DELTA RATIO
DataAppendDataSmallToSmall 2720 3140 +15.4% 0.87x (?)
 
Improvement OLD NEW DELTA RATIO
FlattenListFlatMap 5768 4100 -28.9% 1.41x (?)
 
Added MIN MAX MEAN MAX_RSS
ParseInt.Int32.Binary 440 3378 1419
ParseInt.Int32.Decimal 175 175 175
ParseInt.Int32.Hex 284 1262 610
ParseInt.Int32.UncommonRadix 177 1353 569
ParseInt.Int64.Binary 375 2937 1229
ParseInt.Int64.Decimal 169 198 186
ParseInt.Int64.Hex 327 1795 830
ParseInt.Int64.UncommonRadix 250 1818 824
ParseInt.IntSmall.Binary 430 3777 1565
ParseInt.IntSmall.Decimal 259 259 259
ParseInt.IntSmall.Hex 343 1895 864
ParseInt.IntSmall.UncommonRadix 307 1994 870
ParseInt.UInt32.Binary 482 3538 1501
ParseInt.UInt32.Decimal 150 150 150
ParseInt.UInt32.Hex 282 1274 613
ParseInt.UInt32.UncommonRadix 181 1420 594
ParseInt.UInt64.Binary 418 3034 1324
ParseInt.UInt64.Decimal 213 280 235
ParseInt.UInt64.Hex 401 1683 829
ParseInt.UInt64.UncommonRadix 237 1666 720
ParseInt.UIntSmall.Binary 391 3416 1399
ParseInt.UIntSmall.Decimal 201 202 201
ParseInt.UIntSmall.Hex 296 1833 808
ParseInt.UIntSmall.UncommonRadix 244 1929 806
 
Removed MIN MAX MEAN MAX_RSS
ParseInt.Large.Binary 180 185 183
ParseInt.Large.Decimal 86 87 86
ParseInt.Large.Hex 158 158 158
ParseInt.Large.UncommonRadix 97 99 98
ParseInt.Small.Binary 307 309 308
ParseInt.Small.Decimal 209 212 210
ParseInt.Small.Hex 215 222 218
ParseInt.Small.UncommonRadix 205 221 214

Code size: -O

Regression OLD NEW DELTA RATIO
IntegerParsing.o 17880 55164 +208.5% 0.32x

Performance: -Osize

Added MIN MAX MEAN MAX_RSS
ParseInt.Int32.Binary 420 3201 1370
ParseInt.Int32.Decimal 172 182 176
ParseInt.Int32.Hex 284 1284 618
ParseInt.Int32.UncommonRadix 172 1313 553
ParseInt.Int64.Binary 341 2734 1139
ParseInt.Int64.Decimal 162 165 163
ParseInt.Int64.Hex 310 1302 645
ParseInt.Int64.UncommonRadix 177 1374 576
ParseInt.IntSmall.Binary 438 3024 1300
ParseInt.IntSmall.Decimal 269 281 274
ParseInt.IntSmall.Hex 358 1890 870
ParseInt.IntSmall.UncommonRadix 301 1977 860
ParseInt.UInt32.Binary 457 3368 1428
ParseInt.UInt32.Decimal 154 159 157
ParseInt.UInt32.Hex 288 1260 613
ParseInt.UInt32.UncommonRadix 179 1383 580
ParseInt.UInt64.Binary 364 2857 1195
ParseInt.UInt64.Decimal 169 173 171
ParseInt.UInt64.Hex 299 1299 633
ParseInt.UInt64.UncommonRadix 176 1362 571
ParseInt.UIntSmall.Binary 405 2930 1247
ParseInt.UIntSmall.Decimal 199 206 202
ParseInt.UIntSmall.Hex 318 1824 820
ParseInt.UIntSmall.UncommonRadix 271 1936 827
 
Removed MIN MAX MEAN MAX_RSS
ParseInt.Large.Binary 170 172 171
ParseInt.Large.Decimal 79 79 79
ParseInt.Large.Hex 153 153 153
ParseInt.Large.UncommonRadix 88 90 89
ParseInt.Small.Binary 305 309 306
ParseInt.Small.Decimal 178 179 179
ParseInt.Small.Hex 198 201 199
ParseInt.Small.UncommonRadix 189 189 189

Code size: -Osize

Regression OLD NEW DELTA RATIO
IntegerParsing.o 17142 51884 +202.7% 0.33x

Performance: -Onone

Improvement OLD NEW DELTA RATIO
DataAppendDataSmallToSmall 3160 2780 -12.0% 1.14x (?)
 
Added MIN MAX MEAN MAX_RSS
ParseInt.Int32.Binary 16816 20982 18209
ParseInt.Int32.Decimal 6851 6931 6896
ParseInt.Int32.Hex 6347 8668 7144
ParseInt.Int32.UncommonRadix 7489 10013 8354
ParseInt.Int64.Binary 17309 20406 18353
ParseInt.Int64.Decimal 5976 6026 5998
ParseInt.Int64.Hex 5417 7087 5985
ParseInt.Int64.UncommonRadix 6860 8730 7494
ParseInt.IntSmall.Binary 16796 22914 18847
ParseInt.IntSmall.Decimal 9646 9669 9660
ParseInt.IntSmall.Hex 9459 14465 11151
ParseInt.IntSmall.UncommonRadix 10386 16337 12509
ParseInt.UInt32.Binary 16275 20721 17783
ParseInt.UInt32.Decimal 6556 6651 6588
ParseInt.UInt32.Hex 6017 8321 6810
ParseInt.UInt32.UncommonRadix 7343 9853 8196
ParseInt.UInt64.Binary 16086 19539 17307
ParseInt.UInt64.Decimal 5495 5601 5559
ParseInt.UInt64.Hex 5065 6813 5652
ParseInt.UInt64.UncommonRadix 6316 8384 7017
ParseInt.UIntSmall.Binary 16995 23414 19231
ParseInt.UIntSmall.Decimal 9771 9984 9855
ParseInt.UIntSmall.Hex 9619 14896 11501
ParseInt.UIntSmall.UncommonRadix 10519 15771 12270
 
Removed MIN MAX MEAN MAX_RSS
ParseInt.Large.Binary 8817 8841 8830
ParseInt.Large.Decimal 3028 3044 3038
ParseInt.Large.Hex 2757 2766 2760
ParseInt.Large.UncommonRadix 3456 3509 3490
ParseInt.Small.Binary 17186 17508 17320
ParseInt.Small.Decimal 9717 9823 9755
ParseInt.Small.Hex 9590 9658 9620
ParseInt.Small.UncommonRadix 10556 10633 10590

Code size: -swiftlibs

Benchmark Check Report
⚠️Ⓜ️ ParseInt.UInt64.Binary has very wide range of memory used between independent, repeated measurements.
ParseInt.UInt64.Binary mem_pages [i1, i2]: min=[192, 192] 𝚫=0 R=[23, 23]
⚠️Ⓜ️ ParseInt.UInt64.Hex has very wide range of memory used between independent, repeated measurements.
ParseInt.UInt64.Hex mem_pages [i1, i2]: min=[141, 141] 𝚫=0 R=[22, 3]
⚠️Ⓜ️ ParseInt.Int64.Hex has very wide range of memory used between independent, repeated measurements.
ParseInt.Int64.Hex mem_pages [i1, i2]: min=[143, 143] 𝚫=0 R=[22, 0]
How to read the data The tables contain differences in performance which are larger than 8% and differences in code size which are larger than 1%.

If you see any unexpected regressions, you should consider fixing the
regressions before you merge the PR.

Noise: Sometimes the performance results (not code size!) contain false
alarms. Unexpected regressions which are marked with '(?)' are probably noise.
If you see regressions which you cannot explain you can try to run the
benchmarks again. If regressions still show up, please consult with the
performance team (@eeckstein).

Hardware Overview
  Model Name: Mac mini
  Model Identifier: Macmini8,1
  Processor Name: Intel Core i7
  Processor Speed: 3.2 GHz
  Number of Processors: 1
  Total Number of Cores: 6
  L2 Cache (per Core): 256 KB
  L3 Cache: 12 MB
  Memory: 64 GB

@PatrickPijnappel
Copy link
Contributor Author

@swift-ci Please benchmark

Copy link
Contributor

@eeckstein eeckstein left a comment

Choose a reason for hiding this comment

The reason will be displayed to describe this comment to others. Learn more.

Is it possible to pick a few (maybe ~ 5) representative benchmarks which cover most of the scenarios?
We should avoid inflating the number of benchmarks too much, because we want to keep the total runtime of benchmarking on an acceptable level. If we add exhaustive benchmarks for each small piece of the library and the language it's just too much.

I suggest to pick a few and add the .skip tag to all others. If someone wants to run all the integer parsing benchmarks, it's still possible with the -skipTags option. See ExistentialPerformance.swift as an example.

Also, we should avoid using gyb, especially in the benchmarks. Eventually we want to convert the benchmarks to a swiftpm package, where we cannot use gyb. Beside that, gyb has other problems (e.g. it complicates debugging).

@swift-ci
Copy link
Contributor

Performance: -O

Added MIN MAX MEAN MAX_RSS
ParseInt.Int32.Binary 430 439 434
ParseInt.Int32.Decimal 173 178 175
ParseInt.Int32.Hex 240 245 242
ParseInt.Int32.UncommonRadix 173 174 174
ParseInt.Int64.Binary 365 373 369
ParseInt.Int64.Decimal 164 167 165
ParseInt.Int64.Hex 287 295 290
ParseInt.Int64.UncommonRadix 182 189 185
ParseInt.IntSmall.Binary 509 525 516
ParseInt.IntSmall.Decimal 255 260 257
ParseInt.IntSmall.Hex 314 326 319
ParseInt.IntSmall.UncommonRadix 301 310 305
ParseInt.UInt32.Binary 483 494 487
ParseInt.UInt32.Decimal 147 150 149
ParseInt.UInt32.Hex 240 241 240
ParseInt.UInt32.UncommonRadix 179 181 180
ParseInt.UInt64.Binary 374 388 381
ParseInt.UInt64.Decimal 170 173 171
ParseInt.UInt64.Hex 287 290 288
ParseInt.UInt64.UncommonRadix 179 185 182
ParseInt.UIntSmall.Binary 494 500 496
ParseInt.UIntSmall.Decimal 215 221 218
ParseInt.UIntSmall.Hex 305 317 309
ParseInt.UIntSmall.UncommonRadix 257 266 260
 
Removed MIN MAX MEAN MAX_RSS
ParseInt.Large.Binary 185 185 185
ParseInt.Large.Decimal 85 85 85
ParseInt.Large.Hex 157 158 158
ParseInt.Large.UncommonRadix 96 96 96
ParseInt.Small.Binary 304 304 304
ParseInt.Small.Decimal 207 207 207
ParseInt.Small.Hex 218 218 218
ParseInt.Small.UncommonRadix 214 214 214

Code size: -O

Regression OLD NEW DELTA RATIO
IntegerParsing.o 17880 58653 +228.0% 0.30x

Performance: -Osize

Improvement OLD NEW DELTA RATIO
DropLastCountableRange 6 5 -16.7% 1.20x (?)
UTF8Decode_InitFromBytes_ascii 216 198 -8.3% 1.09x (?)
DropFirstArray 14 13 -7.1% 1.08x (?)
 
Added MIN MAX MEAN MAX_RSS
ParseInt.Int32.Binary 410 427 418
ParseInt.Int32.Decimal 171 171 171
ParseInt.Int32.Hex 244 245 244
ParseInt.Int32.UncommonRadix 172 174 173
ParseInt.Int64.Binary 350 350 350
ParseInt.Int64.Decimal 160 162 161
ParseInt.Int64.Hex 296 296 296
ParseInt.Int64.UncommonRadix 180 182 181
ParseInt.IntSmall.Binary 508 509 508
ParseInt.IntSmall.Decimal 266 266 266
ParseInt.IntSmall.Hex 320 324 322
ParseInt.IntSmall.UncommonRadix 299 300 299
ParseInt.UInt32.Binary 466 466 466
ParseInt.UInt32.Decimal 156 156 156
ParseInt.UInt32.Hex 259 266 262
ParseInt.UInt32.UncommonRadix 188 188 188
ParseInt.UInt64.Binary 363 363 363
ParseInt.UInt64.Decimal 166 169 167
ParseInt.UInt64.Hex 286 291 288
ParseInt.UInt64.UncommonRadix 177 177 177
ParseInt.UIntSmall.Binary 484 490 486
ParseInt.UIntSmall.Decimal 249 256 252
ParseInt.UIntSmall.Hex 308 309 308
ParseInt.UIntSmall.UncommonRadix 251 253 252
 
Removed MIN MAX MEAN MAX_RSS
ParseInt.Large.Binary 172 173 173
ParseInt.Large.Decimal 80 81 80
ParseInt.Large.Hex 154 154 154
ParseInt.Large.UncommonRadix 88 91 89
ParseInt.Small.Binary 315 317 316
ParseInt.Small.Decimal 184 186 185
ParseInt.Small.Hex 200 205 203
ParseInt.Small.UncommonRadix 196 199 198

Code size: -Osize

Regression OLD NEW DELTA RATIO
IntegerParsing.o 17142 55083 +221.3% 0.31x

Performance: -Onone

Added MIN MAX MEAN MAX_RSS
ParseInt.Int32.Binary 17363 17467 17417
ParseInt.Int32.Decimal 7075 7106 7094
ParseInt.Int32.Hex 6528 6586 6557
ParseInt.Int32.UncommonRadix 7738 7797 7768
ParseInt.Int64.Binary 17747 17801 17779
ParseInt.Int64.Decimal 6048 6060 6053
ParseInt.Int64.Hex 5435 5506 5479
ParseInt.Int64.UncommonRadix 6940 6974 6955
ParseInt.IntSmall.Binary 21388 21560 21459
ParseInt.IntSmall.Decimal 10830 10949 10895
ParseInt.IntSmall.Hex 10629 10732 10690
ParseInt.IntSmall.UncommonRadix 11861 11985 11938
ParseInt.UInt32.Binary 16734 16869 16783
ParseInt.UInt32.Decimal 6709 6727 6716
ParseInt.UInt32.Hex 6161 6287 6209
ParseInt.UInt32.UncommonRadix 7469 7476 7473
ParseInt.UInt64.Binary 16480 16540 16520
ParseInt.UInt64.Decimal 5612 5678 5655
ParseInt.UInt64.Hex 5069 5175 5124
ParseInt.UInt64.UncommonRadix 6391 6489 6439
ParseInt.UIntSmall.Binary 21129 21396 21225
ParseInt.UIntSmall.Decimal 10995 11063 11033
ParseInt.UIntSmall.Hex 10745 10847 10801
ParseInt.UIntSmall.UncommonRadix 11897 11958 11936
 
Removed MIN MAX MEAN MAX_RSS
ParseInt.Large.Binary 8855 8925 8887
ParseInt.Large.Decimal 3045 3094 3062
ParseInt.Large.Hex 2727 2783 2751
ParseInt.Large.UncommonRadix 3506 3559 3527
ParseInt.Small.Binary 17272 17475 17364
ParseInt.Small.Decimal 9829 10039 9920
ParseInt.Small.Hex 9768 9869 9818
ParseInt.Small.UncommonRadix 10672 10777 10723

Code size: -swiftlibs

Benchmark Check Report
How to read the data The tables contain differences in performance which are larger than 8% and differences in code size which are larger than 1%.

If you see any unexpected regressions, you should consider fixing the
regressions before you merge the PR.

Noise: Sometimes the performance results (not code size!) contain false
alarms. Unexpected regressions which are marked with '(?)' are probably noise.
If you see regressions which you cannot explain you can try to run the
benchmarks again. If regressions still show up, please consult with the
performance team (@eeckstein).

Hardware Overview
  Model Name: Mac mini
  Model Identifier: Macmini8,1
  Processor Name: Intel Core i7
  Processor Speed: 3.2 GHz
  Number of Processors: 1
  Total Number of Cores: 6
  L2 Cache (per Core): 256 KB
  L3 Cache: 12 MB
  Memory: 64 GB

@PatrickPijnappel
Copy link
Contributor Author

@eeckstein Thanks, I added .skip to all but the key ones, which where the ones we already had. Is there some way to trigger a swift-ci benchmark on GitHub that includes skipped tests? E.g. in a pull request specifically about improving integer performance, where the detailed numbers are desirable

Good to know about the gyb usage. For this one do you want to just leave it as is for now, or delete the gyb file? (or another suggestion)

@PatrickPijnappel
Copy link
Contributor Author

@swift-ci Please benchmark

@swift-ci
Copy link
Contributor

Performance: -O

Added MIN MAX MEAN MAX_RSS
ParseInt.Int64.Binary 361 362 362
ParseInt.Int64.Decimal 166 166 166
ParseInt.Int64.Hex 301 307 303
ParseInt.Int64.UncommonRadix 184 184 184
ParseInt.IntSmall.Binary 513 513 513
ParseInt.IntSmall.Decimal 270 271 271
ParseInt.IntSmall.Hex 333 334 333
ParseInt.IntSmall.UncommonRadix 302 303 302
 
Removed MIN MAX MEAN MAX_RSS
ParseInt.Large.Binary 181 181 181
ParseInt.Large.Decimal 82 82 82
ParseInt.Large.Hex 154 154 154
ParseInt.Large.UncommonRadix 94 94 94
ParseInt.Small.Binary 298 313 305
ParseInt.Small.Decimal 205 211 209
ParseInt.Small.Hex 212 218 215
ParseInt.Small.UncommonRadix 208 216 213

Code size: -O

Regression OLD NEW DELTA RATIO
IntegerParsing.o 17880 58717 +228.4% 0.30x

Performance: -Osize

Regression OLD NEW DELTA RATIO
FlattenListFlatMap 4427 4768 +7.7% 0.93x (?)
 
Improvement OLD NEW DELTA RATIO
PrefixWhileCountableRange 17 15 -11.8% 1.13x (?)
 
Added MIN MAX MEAN MAX_RSS
ParseInt.Int64.Binary 355 362 359
ParseInt.Int64.Decimal 161 167 165
ParseInt.Int64.Hex 295 306 301
ParseInt.Int64.UncommonRadix 182 184 183
ParseInt.IntSmall.Binary 512 522 517
ParseInt.IntSmall.Decimal 276 280 278
ParseInt.IntSmall.Hex 334 344 340
ParseInt.IntSmall.UncommonRadix 300 302 301
 
Removed MIN MAX MEAN MAX_RSS
ParseInt.Large.Binary 170 170 170
ParseInt.Large.Decimal 79 79 79
ParseInt.Large.Hex 153 153 153
ParseInt.Large.UncommonRadix 88 89 88
ParseInt.Small.Binary 305 305 305
ParseInt.Small.Decimal 180 181 180
ParseInt.Small.Hex 195 195 195
ParseInt.Small.UncommonRadix 189 189 189

Code size: -Osize

Regression OLD NEW DELTA RATIO
IntegerParsing.o 17142 55211 +222.1% 0.31x

Performance: -Onone

Regression OLD NEW DELTA RATIO
ObjectiveCBridgeStubNSDateRefAccess 4154 4487 +8.0% 0.93x (?)
 
Added MIN MAX MEAN MAX_RSS
ParseInt.Int64.Binary 17794 17867 17822
ParseInt.Int64.Decimal 6042 6205 6133
ParseInt.Int64.Hex 5595 5685 5635
ParseInt.Int64.UncommonRadix 7153 7178 7164
ParseInt.IntSmall.Binary 21788 21848 21825
ParseInt.IntSmall.Decimal 11077 11103 11093
ParseInt.IntSmall.Hex 10857 11018 10940
ParseInt.IntSmall.UncommonRadix 12057 12187 12139
 
Removed MIN MAX MEAN MAX_RSS
ParseInt.Large.Binary 8859 8892 8876
ParseInt.Large.Decimal 2991 3061 3021
ParseInt.Large.Hex 2761 2805 2785
ParseInt.Large.UncommonRadix 3443 3550 3507
ParseInt.Small.Binary 17148 17177 17159
ParseInt.Small.Decimal 9625 9677 9644
ParseInt.Small.Hex 9475 9540 9506
ParseInt.Small.UncommonRadix 10491 10582 10535

Code size: -swiftlibs

Benchmark Check Report
How to read the data The tables contain differences in performance which are larger than 8% and differences in code size which are larger than 1%.

If you see any unexpected regressions, you should consider fixing the
regressions before you merge the PR.

Noise: Sometimes the performance results (not code size!) contain false
alarms. Unexpected regressions which are marked with '(?)' are probably noise.
If you see regressions which you cannot explain you can try to run the
benchmarks again. If regressions still show up, please consult with the
performance team (@eeckstein).

Hardware Overview
  Model Name: Mac mini
  Model Identifier: Macmini8,1
  Processor Name: Intel Core i7
  Processor Speed: 3.2 GHz
  Number of Processors: 1
  Total Number of Cores: 6
  L2 Cache (per Core): 256 KB
  L3 Cache: 12 MB
  Memory: 64 GB

@eeckstein
Copy link
Contributor

Is there some way to trigger a swift-ci benchmark on GitHub that includes skipped tests?

Unfortunately no. But you can run benchmark/scripts/run_smoke_bench locally on your machine. You'll need to modify run_smoke_bench to pass the right options to the benchmark executable.

For this one do you want to just leave it as is for now, or delete the gyb file?

My preference is to not add the gyb file.

@compnerd
Copy link
Member

There has been an effort to de-gyb, so it would certainly be preferable to not introduce new gyb based sources.

@PatrickPijnappel PatrickPijnappel changed the title [benchmark] Expand ParseInt benchmarks and use gyb [benchmark] Expand ParseInt benchmarks Feb 21, 2020
@PatrickPijnappel
Copy link
Contributor Author

@eeckstein @compnerd 👍 I've removed the gyb file.

Let me know if you think we should try to generalize the test implementation functions as well.

@PatrickPijnappel PatrickPijnappel force-pushed the expand-parse-int-benchmarks branch from fb91091 to c73b4ee Compare February 21, 2020 23:07
@PatrickPijnappel
Copy link
Contributor Author

I'm also now skipping all but five specific tests, that should be representative both of the different code paths and fairly common real-world use cases.

Copy link
Contributor

@eeckstein eeckstein left a comment

Choose a reason for hiding this comment

The reason will be displayed to describe this comment to others. Learn more.

Thanks!

@PatrickPijnappel
Copy link
Contributor Author

@swift-ci Please smoke test

@PatrickPijnappel
Copy link
Contributor Author

@swift-ci Please benchmark

@swift-ci
Copy link
Contributor

Performance: -O

Improvement OLD NEW DELTA RATIO
FlattenListLoop 3175 2775 -12.6% 1.14x (?)
 
Added MIN MAX MEAN MAX_RSS
ParseInt.Int64.Hex 306 307 306
ParseInt.IntSmall.Decimal 262 263 262
ParseInt.IntSmall.UncommonRadix 342 368 356
ParseInt.UInt32.Hex 288 324 301
ParseInt.UIntSmall.Binary 498 552 519
 
Removed MIN MAX MEAN MAX_RSS
ParseInt.Large.Binary 174 174 174
ParseInt.Large.Decimal 79 79 79
ParseInt.Large.Hex 146 148 147
ParseInt.Large.UncommonRadix 88 91 90
ParseInt.Small.Binary 290 290 290
ParseInt.Small.Decimal 188 193 191
ParseInt.Small.Hex 200 200 200
ParseInt.Small.UncommonRadix 193 193 193

Code size: -O

Regression OLD NEW DELTA RATIO
IntegerParsing.o 17880 58733 +228.5% 0.30x

Performance: -Osize

Regression OLD NEW DELTA RATIO
Set.subtracting.Empty.Box 7 8 +14.3% 0.88x (?)
ParseFloat.Float.Exp 9 10 +11.1% 0.90x (?)
ObjectiveCBridgeStubFromNSStringRef 86 93 +8.1% 0.92x (?)
PrefixCountableRangeLazy 13 14 +7.7% 0.93x (?)
 
Improvement OLD NEW DELTA RATIO
DropFirstArray 14 13 -7.1% 1.08x (?)
 
Added MIN MAX MEAN MAX_RSS
ParseInt.Int64.Hex 299 311 303
ParseInt.IntSmall.Decimal 269 270 270
ParseInt.IntSmall.UncommonRadix 297 303 301
ParseInt.UInt32.Hex 250 257 254
ParseInt.UIntSmall.Binary 509 519 514
 
Removed MIN MAX MEAN MAX_RSS
ParseInt.Large.Binary 172 172 172
ParseInt.Large.Decimal 79 79 79
ParseInt.Large.Hex 151 153 152
ParseInt.Large.UncommonRadix 88 91 89
ParseInt.Small.Binary 309 313 310
ParseInt.Small.Decimal 186 190 187
ParseInt.Small.Hex 197 200 199
ParseInt.Small.UncommonRadix 200 201 200

Code size: -Osize

Regression OLD NEW DELTA RATIO
IntegerParsing.o 17070 55195 +223.3% 0.31x

Performance: -Onone

Added MIN MAX MEAN MAX_RSS
ParseInt.Int64.Hex 5478 5495 5486
ParseInt.IntSmall.Decimal 10790 10883 10832
ParseInt.IntSmall.UncommonRadix 11684 12022 11827
ParseInt.UInt32.Hex 6104 6163 6132
ParseInt.UIntSmall.Binary 20999 21151 21070
 
Removed MIN MAX MEAN MAX_RSS
ParseInt.Large.Binary 8895 8953 8926
ParseInt.Large.Decimal 3030 3085 3050
ParseInt.Large.Hex 2752 2784 2763
ParseInt.Large.UncommonRadix 3501 3554 3520
ParseInt.Small.Binary 17021 17224 17105
ParseInt.Small.Decimal 9641 9734 9688
ParseInt.Small.Hex 9586 9673 9632
ParseInt.Small.UncommonRadix 10636 10755 10683

Code size: -swiftlibs

Benchmark Check Report
How to read the data The tables contain differences in performance which are larger than 8% and differences in code size which are larger than 1%.

If you see any unexpected regressions, you should consider fixing the
regressions before you merge the PR.

Noise: Sometimes the performance results (not code size!) contain false
alarms. Unexpected regressions which are marked with '(?)' are probably noise.
If you see regressions which you cannot explain you can try to run the
benchmarks again. If regressions still show up, please consult with the
performance team (@eeckstein).

Hardware Overview
  Model Name: Mac mini
  Model Identifier: Macmini8,1
  Processor Name: Intel Core i7
  Processor Speed: 3.2 GHz
  Number of Processors: 1
  Total Number of Cores: 6
  L2 Cache (per Core): 256 KB
  L3 Cache: 12 MB
  Memory: 64 GB

@PatrickPijnappel PatrickPijnappel merged commit 965f7e2 into swiftlang:master Feb 26, 2020
@PatrickPijnappel PatrickPijnappel deleted the expand-parse-int-benchmarks branch February 26, 2020 06:29
Sign up for free to join this conversation on GitHub. Already have an account? Sign in to comment
Labels
None yet
Projects
None yet
Development

Successfully merging this pull request may close these issues.

4 participants