benchmarks: extract setup code into the setUpFunction in some benchmarks where setup time is significant

Author: eeckstein

benchmark/single-source/Array2D.swift

@@ -15,18 +15,21 @@ import TestsUtils
 public let Array2D = BenchmarkInfo(
   name: "Array2D",
   runFunction: run_Array2D,
-  tags: [.validation, .api, .Array])
+  tags: [.validation, .api, .Array],
+  setUpFunction: { blackHole(inputArray) },
+  tearDownFunction: { inputArray = nil })
 
-@inline(never)
-public func run_Array2D(_ N: Int) {
+var inputArray: [[Int]]! = {
   var A: [[Int]] = []
+  A.reserveCapacity(1024)
   for _ in 0 ..< 1024 {
-    var B: [Int] = []
-    for y in 0 ..< 1024 {
-      B.append(y)
-    }
-    A.append(B)
+    A.append(Array(0 ..< 1024))
   }
+  return A
+}()
+
+@inline(never)
+func modifyArray(_ A: inout [[Int]], _ N: Int) {
   for _ in 0..<N {
     for i in 0 ..< 1024 {
       for y in 0 ..< 1024 {
@@ -36,3 +39,8 @@ public func run_Array2D(_ N: Int) {
     }
   }
 }
+
+@inline(never)
+public func run_Array2D(_ N: Int) {
+  modifyArray(&inputArray, N)
+}

benchmark/single-source/CString.swift

@@ -21,15 +21,18 @@ public let CString = [
   BenchmarkInfo(name: "CStringLongAscii", runFunction: run_CStringLongAscii, tags: [.validation, .api, .String, .bridging]),
   BenchmarkInfo(name: "CStringLongNonAscii", runFunction: run_CStringLongNonAscii, tags: [.validation, .api, .String, .bridging]),
   BenchmarkInfo(name: "CStringShortAscii", runFunction: run_CStringShortAscii, tags: [.validation, .api, .String, .bridging]),
-  BenchmarkInfo(name: "StringWithCString", runFunction: run_StringWithCString, tags: [.validation, .api, .String, .bridging]),
+  BenchmarkInfo(name: "StringWithCString2", runFunction: run_StringWithCString, tags: [.validation, .api, .String, .bridging],
+      setUpFunction: { blackHole(repeatedStr) }, tearDownFunction: { repeatedStr = nil })
 ]
 
 let ascii = "Swift is a multi-paradigm, compiled programming language created for iOS, OS X, watchOS, tvOS and Linux development by Apple Inc. Swift is designed to work with Apple's Cocoa and Cocoa Touch frameworks and the large body of existing Objective-C code written for Apple products. Swift is intended to be more resilient to erroneous code (\"safer\") than Objective-C and also more concise. It is built with the LLVM compiler framework included in Xcode 6 and later and uses the Objective-C runtime, which allows C, Objective-C, C++ and Swift code to run within a single program."
 let japanese = "日本語（にほんご、にっぽんご）は、主に日本国内や日本人同士の間で使われている言語である。"
 
+var repeatedStr: String! = String(repeating: "x", count: 100 * (1 << 16))
+
 @inline(never)
 public func run_StringWithCString(_ N: Int) {
-  let str = String(repeating: "x", count: 100 * (1 << 16))
+  let str: String = repeatedStr
   for _ in 0 ..< N {
     str.withCString { blackHole($0) }
   }

benchmark/single-source/Chars.swift

@@ -16,12 +16,10 @@ import TestsUtils
 public let Chars = BenchmarkInfo(
   name: "Chars",
   runFunction: run_Chars,
-  tags: [.validation, .api, .String])
+  tags: [.validation, .api, .String],
+  setUpFunction: { blackHole(alphabetInput) })
 
-@inline(never)
-public func run_Chars(_ N: Int) {
-  // Permute some characters.
-  let alphabet: [Character] = [
+var alphabetInput: [Character] = [
     "A", "B", "C", "D", "E", "F", "G",
     "H", "I", "J", "K", "L", "M", "N", "O", "P", "Q", "R",
     "S", "T", "U",
@@ -30,6 +28,11 @@ public func run_Chars(_ N: Int) {
     "2", "a", "t", "i", "o", "e", "q", "n", "X", "Y", "Z", "?", "m", "Z", ","
     ]
 
+@inline(never)
+public func run_Chars(_ N: Int) {
+  // Permute some characters.
+  let alphabet: [Character] = alphabetInput
+
   for _ in 0..<N {
     for firstChar in alphabet {
       for middleChar in alphabet {

benchmark/single-source/ClassArrayGetter.swift

@@ -15,7 +15,9 @@ import TestsUtils
 public let ClassArrayGetter = BenchmarkInfo(
   name: "ClassArrayGetter",
   runFunction: run_ClassArrayGetter,
-  tags: [.validation, .api, .Array])
+  tags: [.validation, .api, .Array],
+  setUpFunction: { blackHole(inputArray) },
+  tearDownFunction: { inputArray = nil })
 
 class Box {
   var v: Int
@@ -31,13 +33,18 @@ func sumArray(_ a: [Box]) -> Int {
   return s
 }
 
-public func run_ClassArrayGetter(_ N: Int) {
+var inputArray: [Box]! = {
   let aSize = 10_000
   var a: [Box] = []
   a.reserveCapacity(aSize)
   for i in 1...aSize {
     a.append(Box(v:i))
   }
+  return a
+}()
+
+public func run_ClassArrayGetter(_ N: Int) {
+  let a: [Box] = inputArray
   for _ in 1...N {
     _ = sumArray(a)
   }

benchmark/single-source/DictionaryGroup.swift

@@ -14,7 +14,9 @@ import TestsUtils
 
 public let DictionaryGroup = [
   BenchmarkInfo(name: "DictionaryGroup", runFunction: run_DictionaryGroup, tags: [.validation, .api, .Dictionary]),
-  BenchmarkInfo(name: "DictionaryGroupOfObjects", runFunction: run_DictionaryGroupOfObjects, tags: [.validation, .api, .Dictionary]),
+  BenchmarkInfo(name: "DictionaryGroupOfObjects", runFunction: run_DictionaryGroupOfObjects, tags: [.validation, .api, .Dictionary],
+    setUpFunction: { blackHole(inputObjects) },
+    tearDownFunction: { inputObjects = nil }),
 ]
 
 let count = 10_000
@@ -45,9 +47,11 @@ class Box<T : Hashable> : Hashable {
   }
 }
 
+var inputObjects: [Box<Int>]! = (0..<count).map { Box($0) }
+
 @inline(never)
 public func run_DictionaryGroupOfObjects(_ N: Int) {
-  let objects = (0..<count).map { Box($0) }
+  let objects: [Box<Int>] = inputObjects
   for _ in 1...N {
     let dict = Dictionary(grouping: objects, by: { Box($0.value % 10) })
     CheckResults(dict.count == 10)

benchmark/single-source/LazyFilter.swift

@@ -15,7 +15,8 @@
 import TestsUtils
 
 public let LazyFilter = [
-  BenchmarkInfo(name: "LazilyFilteredArrays", runFunction: run_LazilyFilteredArrays, tags: [.validation, .api, .Array]),
+  BenchmarkInfo(name: "LazilyFilteredArrays", runFunction: run_LazilyFilteredArrays, tags: [.validation, .api, .Array],
+      setUpFunction: { blackHole(filteredRange) }),
   BenchmarkInfo(name: "LazilyFilteredRange", runFunction: run_LazilyFilteredRange, tags: [.validation, .api, .Array]),
   BenchmarkInfo(
     name: "LazilyFilteredArrayContains",
@@ -36,10 +37,12 @@ public func run_LazilyFilteredRange(_ N: Int) {
   CheckResults(res == 123)
 }
 
+let filteredRange = (1..<1_000_000).map({[$0]}).lazy.filter { $0.first! % 7 == 0 }
+
 @inline(never)
 public func run_LazilyFilteredArrays(_ N: Int) {
   var res = 123
-  let c = (1..<1_000_000).map({[$0]}).lazy.filter { $0.first! % 7 == 0 }
+  let c = filteredRange
   for _ in 1...N {
     res += Array(c).count
     res -= Array(c).count

benchmark/single-source/RandomShuffle.swift

@@ -19,9 +19,13 @@ import TestsUtils
 
 public let RandomShuffle = [
   BenchmarkInfo(name: "RandomShuffleDef", runFunction: run_RandomShuffleDef,
-    tags: [.api], setUpFunction: setup_RandomShuffle),
+    tags: [.api],
+    setUpFunction: { blackHole(numbersDef) },
+    tearDownFunction: { numbersDef = nil }),
   BenchmarkInfo(name: "RandomShuffleLCG", runFunction: run_RandomShuffleLCG,
-    tags: [.api], setUpFunction: setup_RandomShuffle),
+    tags: [.api],
+    setUpFunction: { blackHole(numbersLCG) },
+    tearDownFunction: { numbersLCG = nil }),
 ]
 
 /// A linear congruential PRNG.
@@ -39,15 +43,12 @@ struct LCRNG: RandomNumberGenerator {
   }
 }
 
-var numbers = Array(0...3_000_000)
-
-@inline(never)
-func setup_RandomShuffle() {
-  _ = numbers.count
-}
+var numbersDef: [Int]! = Array(0...3_000_000)
+var numbersLCG: [Int]! = Array(0...3_000_000)
 
 @inline(never)
 public func run_RandomShuffleDef(_ N: Int) {
+  var numbers: [Int] = numbersDef
   for _ in 0 ..< N {
     numbers.shuffle()
     blackHole(numbers.first!)
@@ -56,6 +57,7 @@ public func run_RandomShuffleDef(_ N: Int) {
 
 @inline(never)
 public func run_RandomShuffleLCG(_ N: Int) {
+  var numbers: [Int] = numbersLCG
   var generator = LCRNG(seed: 0)
   for _ in 0 ..< N {
     numbers.shuffle(using: &generator)

benchmark/single-source/ReversedCollections.swift

@@ -13,58 +13,65 @@
 import TestsUtils
 
 public let ReversedCollections = [
-  BenchmarkInfo(name: "ReversedArray", runFunction: run_ReversedArray, tags: [.validation, .api, .Array]),
+  BenchmarkInfo(name: "ReversedArray2", runFunction: run_ReversedArray, tags: [.validation, .api, .Array],
+      setUpFunction: { blackHole(arrayInput) },
+      tearDownFunction: { arrayInput = nil }),
   BenchmarkInfo(name: "ReversedBidirectional", runFunction: run_ReversedBidirectional, tags: [.validation, .api]),
-  BenchmarkInfo(name: "ReversedDictionary", runFunction: run_ReversedDictionary, tags: [.validation, .api, .Dictionary]),
+  BenchmarkInfo(name: "ReversedDictionary2", runFunction: run_ReversedDictionary, tags: [.validation, .api, .Dictionary],
+      setUpFunction: { blackHole(dictionaryInput) },
+      tearDownFunction: { dictionaryInput = nil })
 ]
 
 // These benchmarks compare the performance of iteration through several
 // collection types after being reversed.
-var x = 0
 let length = 100_000
 
+var arrayInput: [Int]! = Array(repeating: 1, count: length).reversed()
+
 @inline(never)
 public func run_ReversedArray(_ N: Int) {
-  let array = Array(repeating: 1, count: length)
-  let reversedArray = array.reversed()
+  let reversedArray: [Int] = arrayInput
 
   // Iterate over the underlying type
   // ReversedRandomAccessCollection<Array<Int>>
   for _ in 1...N {
     for item in reversedArray {
-      x = item
+      blackHole(item)
     }
   }
 }
 
 @inline(never)
 public func run_ReversedBidirectional(_ N: Int) {
-  let bidirectional = AnyBidirectionalCollection(0..<length)
-  let reversedBidirectional = bidirectional.reversed()
-
   // Iterate over the underlying type
   // ReversedCollection<AnyBidirectionalCollection<Int>>
   for _ in 1...N {
+    let bidirectional = AnyBidirectionalCollection(0..<length)
+    let reversedBidirectional = bidirectional.reversed()
     for item in reversedBidirectional {
-      x = item
+      blackHole(item)
     }
   }
 }
 
-@inline(never)
-public func run_ReversedDictionary(_ N: Int) {
+var dictionaryInput: [(Int, Int)]! = {
   var dictionary = [Int: Int]()
   for k in 0..<length {
-    dictionary[k] = x
+    dictionary[k] = k
   }
-  let reversedDictionary = dictionary.reversed()
+  return dictionary.reversed()
+}()
+
+@inline(never)
+public func run_ReversedDictionary(_ N: Int) {
+  let reversedDictionary: [(Int, Int)] = dictionaryInput
 
   // Iterate over the underlying type
   // Array<(Int, Int)>
   for _ in 1...N {
     for (key, value) in reversedDictionary {
-      x = key
-      x = value
+      blackHole(key)
+      blackHole(value)
     }
   }
 }