[benchmark] Add integer parsing benchmarks

Author: PatrickPijnappel

benchmark/CMakeLists.txt

@@ -92,6 +92,7 @@ set(SWIFT_BENCH_MODULES
     single-source/Hash
     single-source/Histogram
     single-source/InsertCharacter  
+    single-source/IntegerParsing
     single-source/Integrate
     single-source/IterateData
     single-source/Join

benchmark/single-source/IntegerParsing.swift

@@ -0,0 +1,85 @@
+//===--- IntegerParsing.swift -------------------------------------------===//
+//
+// This source file is part of the Swift.org open source project
+//
+// Copyright (c) 2014 - 2019 Apple Inc. and the Swift project authors
+// Licensed under Apache License v2.0 with Runtime Library Exception
+//
+// See https://swift.org/LICENSE.txt for license information
+// See https://swift.org/CONTRIBUTORS.txt for the list of Swift project authors
+//
+//===----------------------------------------------------------------------===//
+
+import TestsUtils
+
+public let IntegerParsing = [
+  BenchmarkInfo(name: "ParseIntFromDecimal",
+    runFunction: run_ParseIntFromDecimal,
+    tags: [.validation, .api],
+    setUpFunction: { blackHole(decimalStrings) }),
+  BenchmarkInfo(name: "ParseIntFromBinary",
+    runFunction: run_ParseIntFromBinary,
+    tags: [.validation, .api],
+    setUpFunction: { blackHole(binaryStrings) }),
+  BenchmarkInfo(name: "ParseIntFromHex",
+    runFunction: run_ParseIntFromHex,
+    tags: [.validation, .api],
+    setUpFunction: { blackHole(hexStrings) }),
+  BenchmarkInfo(name: "ParseIntFromUncommonRadix",
+    runFunction: run_ParseIntFromUncommonRadix,
+    tags: [.validation, .api],
+    setUpFunction: { blackHole(uncommonRadixStrings) }),
+]
+
+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) }
+
+@inline(never)
+public func run_ParseIntFromDecimal(N: Int) {
+  var result = 0
+  for _ in 0..<N {
+    for string in decimalStrings {
+      result &+= Int(string, radix: 10)!
+    }
+  }
+  blackHole(result)
+}
+
+@inline(never)
+public func run_ParseIntFromBinary(N: Int) {
+  var result = 0
+  for _ in 0..<N {
+    for string in binaryStrings {
+      result &+= Int(string, radix: 2)!
+    }
+  }
+  blackHole(result)
+}
+
+@inline(never)
+public func run_ParseIntFromHex(N: Int) {
+  var result = 0
+  for _ in 0..<N {
+    for string in hexStrings {
+      result &+= Int(string, radix: 16)!
+    }
+  }
+  blackHole(result)
+}
+
+@inline(never)
+public func run_ParseIntFromUncommonRadix(N: Int) {
+  var result = 0
+  for _ in 0..<N {
+    for string in uncommonRadixStrings {
+      result &+= Int(string, radix: uncommonRadix)!
+    }
+  }
+  blackHole(result)
+}

benchmark/utils/main.swift

@@ -80,6 +80,7 @@ import Hanoi
 import Hash
 import Histogram
 import InsertCharacter
+import IntegerParsing
 import Integrate
 import IterateData
 import Join
@@ -253,6 +254,7 @@ registerBenchmark(Hanoi)
 registerBenchmark(HashTest)
 registerBenchmark(Histogram)
 registerBenchmark(InsertCharacter)
+registerBenchmark(IntegerParsing)
 registerBenchmark(IntegrateTest)
 registerBenchmark(IterateData)
 registerBenchmark(Join)