[benchmark] Split ParseInt into small/large & check results

Author: PatrickPijnappel

benchmark/single-source/IntegerParsing.swift

@@ -13,73 +13,151 @@
 import TestsUtils
 
 public let IntegerParsing = [
-  BenchmarkInfo(name: "ParseInt.Decimal",
-    runFunction: run_ParseIntFromDecimal,
+  BenchmarkInfo(name: "ParseInt.Small.Decimal",
+    runFunction: run_ParseIntFromSmallDecimal,
     tags: [.validation, .api],
-    setUpFunction: { blackHole(decimalStrings) }),
-  BenchmarkInfo(name: "ParseInt.Binary",
-    runFunction: run_ParseIntFromBinary,
+    setUpFunction: { blackHole(smallDecimalStrings) }),
+  BenchmarkInfo(name: "ParseInt.Small.Binary",
+    runFunction: run_ParseIntFromSmallBinary,
     tags: [.validation, .api],
-    setUpFunction: { blackHole(binaryStrings) }),
-  BenchmarkInfo(name: "ParseInt.Hex",
-    runFunction: run_ParseIntFromHex,
+    setUpFunction: { blackHole(smallBinaryStrings) }),
+  BenchmarkInfo(name: "ParseInt.Small.Hex",
+    runFunction: run_ParseIntFromSmallHex,
     tags: [.validation, .api],
-    setUpFunction: { blackHole(hexStrings) }),
-  BenchmarkInfo(name: "ParseInt.UncommonRadix",
-    runFunction: run_ParseIntFromUncommonRadix,
+    setUpFunction: { blackHole(smallHexStrings) }),
+  BenchmarkInfo(name: "ParseInt.Small.UncommonRadix",
+    runFunction: run_ParseIntFromSmallUncommonRadix,
     tags: [.validation, .api],
-    setUpFunction: { blackHole(uncommonRadixStrings) }),
+    setUpFunction: { blackHole(smallUncommonRadixStrings) }),
+  BenchmarkInfo(name: "ParseInt.Large.Decimal",
+    runFunction: run_ParseIntFromLargeDecimal,
+    tags: [.validation, .api],
+    setUpFunction: { blackHole(largeDecimalStrings) }),
+  BenchmarkInfo(name: "ParseInt.Large.Binary",
+    runFunction: run_ParseIntFromLargeBinary,
+    tags: [.validation, .api],
+    setUpFunction: { blackHole(largeBinaryStrings) }),
+  BenchmarkInfo(name: "ParseInt.Large.Hex",
+    runFunction: run_ParseIntFromLargeHex,
+    tags: [.validation, .api],
+    setUpFunction: { blackHole(largeHexStrings) }),
+  BenchmarkInfo(name: "ParseInt.Large.UncommonRadix",
+    runFunction: run_ParseIntFromLargeUncommonRadix,
+    tags: [.validation, .api],
+    setUpFunction: { blackHole(largeUncommonRadixStrings) }),
 ]
 
-private let values: [Int] = Array(-1000...1000) // Give extra weight to low ints
-  + (0..<2000).map { _ in Int.random(in: .min ... .max) }
 private let uncommonRadix: Int = 7
-private let decimalStrings: [String] = values.map { String($0, radix: 10) }
-private let binaryStrings: [String] = values.map { String($0, radix: 2) }
-private let hexStrings: [String] = values.map { String($0, radix: 16) }
-private let uncommonRadixStrings: [String]
-  = values.map { String($0, radix: uncommonRadix) }
+private let smallValuesSum: Int = 0
+private let largeValuesSum: Int64 = 4790606764485943206
+// Values
+private let smallValues: [Int] = Array(-1000...1000)
+private let largeValues: [Int64] = {
+  var rng = SplitMix64(seed: 42)
+  return (0..<2000).map { _ in Int64.random(in: .min ... .max, using: &rng) }
+}()
+// Strings
+private let smallDecimalStrings: [String]
+  = smallValues.map { String($0, radix: 10) }
+private let smallBinaryStrings: [String]
+  = smallValues.map { String($0, radix: 2) }
+private let smallHexStrings: [String]
+  = smallValues.map { String($0, radix: 16) }
+private let smallUncommonRadixStrings: [String]
+  = smallValues.map { String($0, radix: uncommonRadix) }
+private let largeDecimalStrings: [String]
+  = largeValues.map { String($0, radix: 10) }
+private let largeBinaryStrings: [String]
+  = largeValues.map { String($0, radix: 2) }
+private let largeHexStrings: [String]
+  = largeValues.map { String($0, radix: 16) }
+private let largeUncommonRadixStrings: [String]
+  = largeValues.map { String($0, radix: uncommonRadix) }
 
 @inline(never)
-public func run_ParseIntFromDecimal(N: Int) {
+public func run_ParseIntFromSmallDecimal(N: Int) {
   var result = 0
   for _ in 0..<N {
-    for string in decimalStrings {
+    for string in smallDecimalStrings {
       result &+= Int(string, radix: 10)!
     }
   }
-  blackHole(result)
+  CheckResults(result == smallValuesSum &* N)
 }
 
 @inline(never)
-public func run_ParseIntFromBinary(N: Int) {
+public func run_ParseIntFromSmallBinary(N: Int) {
   var result = 0
   for _ in 0..<N {
-    for string in binaryStrings {
+    for string in smallBinaryStrings {
       result &+= Int(string, radix: 2)!
     }
   }
-  blackHole(result)
+  CheckResults(result == smallValuesSum &* N)
 }
 
 @inline(never)
-public func run_ParseIntFromHex(N: Int) {
+public func run_ParseIntFromSmallHex(N: Int) {
   var result = 0
   for _ in 0..<N {
-    for string in hexStrings {
+    for string in smallHexStrings {
       result &+= Int(string, radix: 16)!
     }
   }
-  blackHole(result)
+  CheckResults(result == smallValuesSum &* N)
 }
 
 @inline(never)
-public func run_ParseIntFromUncommonRadix(N: Int) {
+public func run_ParseIntFromSmallUncommonRadix(N: Int) {
   var result = 0
   for _ in 0..<N {
-    for string in uncommonRadixStrings {
+    for string in smallUncommonRadixStrings {
       result &+= Int(string, radix: uncommonRadix)!
     }
   }
-  blackHole(result)
+  CheckResults(result == smallValuesSum &* N)
+}
+
+@inline(never)
+public func run_ParseIntFromLargeDecimal(N: Int) {
+  var result: Int64 = 0
+  for _ in 0..<N {
+    for string in largeDecimalStrings {
+      result &+= Int64(string, radix: 10)!
+    }
+  }
+  CheckResults(result == largeValuesSum &* Int64(N))
+}
+
+@inline(never)
+public func run_ParseIntFromLargeBinary(N: Int) {
+  var result: Int64 = 0
+  for _ in 0..<N {
+    for string in largeBinaryStrings {
+      result &+= Int64(string, radix: 2)!
+    }
+  }
+  CheckResults(result == largeValuesSum &* Int64(N))
+}
+
+@inline(never)
+public func run_ParseIntFromLargeHex(N: Int) {
+  var result: Int64 = 0
+  for _ in 0..<N {
+    for string in largeHexStrings {
+      result &+= Int64(string, radix: 16)!
+    }
+  }
+  CheckResults(result == largeValuesSum &* Int64(N))
+}
+
+@inline(never)
+public func run_ParseIntFromLargeUncommonRadix(N: Int) {
+  var result: Int64 = 0
+  for _ in 0..<N {
+    for string in largeUncommonRadixStrings {
+      result &+= Int64(string, radix: uncommonRadix)!
+    }
+  }
+  CheckResults(result == largeValuesSum &* Int64(N))
 }