[benchmark] Add RangeIteration benchmarks

Author: Max Moiseev

benchmark/CMakeLists.txt

@@ -103,6 +103,7 @@ set(SWIFT_BENCH_MODULES
     single-source/RC4
     single-source/RGBHistogram
     single-source/RangeAssignment
+    single-source/RangeIteration
     single-source/RecursiveOwnedParameter
     single-source/ReduceInto
     single-source/ReversedCollections

benchmark/single-source/RangeIteration.swift

@@ -0,0 +1,77 @@
+//===--- RangeAssignment.swift --------------------------------------------===//
+//
+// This source file is part of the Swift.org open source project
+//
+// Copyright (c) 2014 - 2017 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 RangeIteration = [
+  BenchmarkInfo(
+    name: "RangeIterationSigned",
+    runFunction: run_RangeIterationSigned,
+    tags: [.validation, .api]
+  ),
+  BenchmarkInfo(
+    name: "RangeIterationSigned64",
+    runFunction: run_RangeIterationSigned64,
+    tags: [.validation, .api]
+  ),
+  BenchmarkInfo(
+    name: "RangeIterationUnsigned",
+    runFunction: run_RangeIterationUnsigned,
+    tags: [.validation, .api]
+  ),
+]
+
+public var check: UInt64 = 0
+
+@inline(never)
+func sum(_ x: UInt64, _ y: UInt64) -> UInt64 {
+  return x &+ y
+}
+
+@inline(never)
+public func run_RangeIterationSigned(_ N: Int) {
+  let range = 0..<100000
+  check = 0
+  for _ in 1...N {
+    for e in range {
+      check = sum(check, UInt64(e))
+    }
+  }
+
+  CheckResults(check == 4999950000 * UInt64(N))
+}
+
+@inline(never)
+public func run_RangeIterationSigned64(_ N: Int) {
+  let range: CountableRange<Int64> = 0..<100000
+  check = 0
+  for _ in 1...N {
+    for e in range {
+      check = sum(check, UInt64(e))
+    }
+  }
+
+  CheckResults(check == 4999950000 * UInt64(N))
+}
+
+@inline(never)
+public func run_RangeIterationUnsigned(_ N: Int) {
+  let range: CountableRange<UInt> = 0..<100000
+  check = 0
+  for _ in 1...N {
+    for e in range {
+      check = sum(check, UInt64(e))
+    }
+  }
+
+  CheckResults(check == 4999950000 * UInt64(N))
+}

benchmark/utils/main.swift

@@ -96,6 +96,7 @@ import ProtocolDispatch2
 import RC4
 import RGBHistogram
 import RangeAssignment
+import RangeIteration
 import RecursiveOwnedParameter
 import ReduceInto
 import ReversedCollections
@@ -214,6 +215,7 @@ registerBenchmark(ProtocolDispatch2)
 registerBenchmark(RC4Test)
 registerBenchmark(RGBHistogram)
 registerBenchmark(RangeAssignment)
+registerBenchmark(RangeIteration)
 registerBenchmark(RecursiveOwnedParameter)
 registerBenchmark(ReduceInto)
 registerBenchmark(ReversedCollections)