[stdlib] Update reduce benchmark to compare the two forms

The ReduceInto benchmark performs three tasks using both `reduce(_:_)` and `reduce(into:_:)` so that their performance can be compared:

1. Summing an array, reducing to `Int`
2. Filtering an array, reducing to `[Int]`
3. Counting letter frequencies, reducing to `[Character: Int]`

Author: d-ronnqvist

benchmark/single-source/ReduceInto.swift

@@ -13,56 +13,83 @@
 import TestsUtils
 import Foundation
 
+// Sum
+
 @inline(never)
-public func run_ReduceIntoInt(_ N: Int) {
+public func run_SumUsingReduce(_ N: Int) {
   let numbers = [Int](0..<1000)
+  
+  var c = 0
+  for _ in 1...N*1000 {
+    c = c &+ numbers.reduce(0) { (acc: Int, num: Int) -> Int in
+      acc &+ num
+    }
+  }
+  CheckResults(c != 0)
+}
 
+@inline(never)
+public func run_SumUsingReduceInto(_ N: Int) {
+  let numbers = [Int](0..<1000)
+  
   var c = 0
-  for _ in 1...N*100 {
+  for _ in 1...N*1000 {
     c = c &+ numbers.reduce(into: 0) { (acc: inout Int, num: Int) in
       acc = acc &+ num
     }
   }
   CheckResults(c != 0)
 }
 
+// Filter
+
 @inline(never)
-public func run_ReduceIntoArray(_ N: Int) {
+public func run_FilterEvenUsingReduce(_ N: Int) {
   let numbers = [Int](0..<100)
 
   var c = 0
   for _ in 1...N*100 {
-    let a = numbers.reduce(into: []) { (acc: inout [Int], num: Int) in
-      acc.append(num)
+    let a = numbers.reduce([]) { (acc: [Int], num: Int) -> [Int] in
+      var a = acc
+      if num % 2 == 0 {
+        a.append(num)
+      }
+      return a
     }
     c = c &+ a.count
   }
   CheckResults(c != 0)
 }
 
 @inline(never)
-public func run_ReduceIntoDictionary(_ N: Int) {
+public func run_FilterEvenUsingReduceInto(_ N: Int) {
   let numbers = [Int](0..<100)
 
   var c = 0
   for _ in 1...N*100 {
-    let d = numbers.reduce(into: [:]) { (acc: inout [Int: Int], num: Int) in
-      acc[num] = num
+    let a = numbers.reduce(into: []) { (acc: inout [Int], num: Int) in
+      if num % 2 == 0 {
+        acc.append(num)
+      }
     }
-    c = c &+ d.count
+    c = c &+ a.count
   }
   CheckResults(c != 0)
 }
 
+// Frequencies
+
 @inline(never)
-public func run_MapUsingReduceInto(_ N: Int) {
-  let numbers = [Int](0..<100)
+public func run_FrequenciesUsingReduce(_ N: Int) {
+  let s = "thequickbrownfoxjumpsoverthelazydogusingasmanycharacteraspossible123456789"
 
   var c = 0
-  let f: (Int) -> Int = { $0 &+ 5 }
   for _ in 1...N*100 {
-    let a = numbers.reduce(into: []) { (acc: inout [Int], x: Int) in
-      acc.append(f(x))
+    let a = s.reduce([:]) {
+      (acc: [Character: Int], c: Character) -> [Character: Int] in
+      var d = acc
+      d[c, default: 0] += 1
+      return d
     }
     c = c &+ a.count
   }
@@ -75,7 +102,8 @@ public func run_FrequenciesUsingReduceInto(_ N: Int) {
 
   var c = 0
   for _ in 1...N*100 {
-    let a = s.reduce(into: [:]) { (acc: inout [Character: Int], c: Character) in
+    let a = s.reduce(into: [:]) {
+      (acc: inout [Character: Int], c: Character) in
       acc[c, default: 0] += 1
     }
     c = c &+ a.count

benchmark/utils/main.swift

@@ -275,6 +275,9 @@ addTo(&precommitTests, "EqualSubstringString", run_EqualSubstringString)
 addTo(&precommitTests, "EqualSubstringSubstring", run_EqualSubstringSubstring)
 addTo(&precommitTests, "EqualSubstringSubstringGenericEquatable", run_EqualSubstringSubstringGenericEquatable)
 addTo(&precommitTests, "ErrorHandling", run_ErrorHandling)
+addTo(&precommitTests, "FilterEvenUsingReduce", run_FilterEvenUsingReduce)
+addTo(&precommitTests, "FilterEvenUsingReduceInto", run_FilterEvenUsingReduceInto)
+addTo(&precommitTests, "FrequenciesUsingReduce", run_FrequenciesUsingReduce)
 addTo(&precommitTests, "FrequenciesUsingReduceInto", run_FrequenciesUsingReduceInto)
 addTo(&precommitTests, "Hanoi", run_Hanoi)
 addTo(&precommitTests, "HashTest", run_HashTest)
@@ -299,7 +302,6 @@ addTo(&precommitTests, "MapReduceSequence", run_MapReduceSequence)
 addTo(&precommitTests, "MapReduceShort", run_MapReduceShort)
 addTo(&precommitTests, "MapReduceShortString", run_MapReduceShortString)
 addTo(&precommitTests, "MapReduceString", run_MapReduceString)
-addTo(&precommitTests, "MapUsingReduceInto", run_MapUsingReduceInto)
 addTo(&precommitTests, "Memset", run_Memset)
 addTo(&precommitTests, "MonteCarloE", run_MonteCarloE)
 addTo(&precommitTests, "MonteCarloPi", run_MonteCarloPi)
@@ -390,9 +392,6 @@ addTo(&precommitTests, "RGBHistogram", run_RGBHistogram)
 addTo(&precommitTests, "RGBHistogramOfObjects", run_RGBHistogramOfObjects)
 addTo(&precommitTests, "RangeAssignment", run_RangeAssignment)
 addTo(&precommitTests, "RecursiveOwnedParameter", run_RecursiveOwnedParameter)
-addTo(&precommitTests, "ReduceIntoArray", run_ReduceIntoArray)
-addTo(&precommitTests, "ReduceIntoDictionary", run_ReduceIntoDictionary)
-addTo(&precommitTests, "ReduceIntoInt", run_ReduceIntoInt)
 addTo(&precommitTests, "ReversedArray", run_ReversedArray)
 addTo(&precommitTests, "ReversedBidirectional", run_ReversedBidirectional)
 addTo(&precommitTests, "ReversedDictionary", run_ReversedDictionary)
@@ -467,6 +466,8 @@ addTo(&precommitTests, "SuffixCountableRange", run_SuffixCountableRange)
 addTo(&precommitTests, "SuffixCountableRangeLazy", run_SuffixCountableRangeLazy)
 addTo(&precommitTests, "SuffixSequence", run_SuffixSequence)
 addTo(&precommitTests, "SuffixSequenceLazy", run_SuffixSequenceLazy)
+addTo(&precommitTests, "SumUsingReduce", run_SumUsingReduce)
+addTo(&precommitTests, "SumUsingReduceInto", run_SumUsingReduceInto)
 addTo(&precommitTests, "SuperChars", run_SuperChars)
 addTo(&precommitTests, "TwoSum", run_TwoSum)
 addTo(&precommitTests, "TypeFlood", run_TypeFlood)