[benchmark] DictionarySwap Setup Overhead

Author: palimondo

benchmark/single-source/DictionarySwap.swift

@@ -14,67 +14,59 @@
 // rdar://problem/19804127
 import TestsUtils
 
+let size = 100
+let numberMap = Dictionary(uniqueKeysWithValues: zip(1...size, 1...size))
+let boxedNums = (1...size).lazy.map { Box($0) }
+let boxedNumMap = Dictionary(uniqueKeysWithValues: zip(boxedNums, boxedNums))
+
 let t: [BenchmarkCategory] = [.validation, .api, .Dictionary]
 
 public let DictionarySwap = [
   BenchmarkInfo(name: "DictionarySwap",
-    runFunction: run_DictionarySwap, tags: t, legacyFactor: 4),
+    runFunction: {
+      var dict = numberMap
+      var swapped = false
+      for _ in 1...$0*2500 {
+          (dict[25], dict[75]) = (dict[75]!, dict[25]!)
+          swapped = !swapped
+          CheckResults(swappedCorrectly(swapped, dict[25]!, dict[75]!))
+    }}, tags: t, legacyFactor: 4),
   BenchmarkInfo(name: "DictionarySwapOfObjects",
-    runFunction: run_DictionarySwapOfObjects, tags: t, legacyFactor: 40),
+    runFunction: {
+      var dict = boxedNumMap
+      var swapped = false
+      for _ in 1...$0*250 {
+        let b1 = Box(25)
+        let b2 = Box(75)
+        (dict[b1], dict[b2]) = (dict[b2]!, dict[b1]!)
+        swapped = !swapped
+        CheckResults(swappedCorrectly(swapped,
+          dict[Box(25)]!.value, dict[Box(75)]!.value))
+    }}, tags: t, legacyFactor: 40),
   BenchmarkInfo(name: "DictionarySwapAt",
-    runFunction: run_DictionarySwapAt, tags: t, legacyFactor: 4),
+    runFunction: {
+      var dict = numberMap
+      var swapped = false
+      for _ in 1...$0*2500 {
+        let i25 = dict.index(forKey: 25)!
+        let i75 = dict.index(forKey: 75)!
+        dict.values.swapAt(i25, i75)
+        swapped = !swapped
+        CheckResults(swappedCorrectly(swapped, dict[25]!, dict[75]!))
+    }}, tags: t, legacyFactor: 4),
   BenchmarkInfo(name: "DictionarySwapAtOfObjects",
-    runFunction: run_DictionarySwapAtOfObjects, tags: t, legacyFactor: 40),
-]
-
-@inline(never)
-public func run_DictionarySwap(_ N: Int) {
-    let size = 100
-    var dict = [Int: Int](minimumCapacity: size)
-
-    // Fill dictionary
-    for i in 1...size {
-        dict[i] = i
-    }
-    CheckResults(dict.count == size)
-
-    var swapped = false
-    for _ in 1...2500*N {
-        (dict[25], dict[75]) = (dict[75]!, dict[25]!)
+    runFunction: {
+      var dict = boxedNumMap
+      var swapped = false
+      for _ in 1...$0*250 {
+        let i25 = dict.index(forKey: Box(25))!
+        let i75 = dict.index(forKey: Box(75))!
+        dict.values.swapAt(i25, i75)
         swapped = !swapped
-        if !swappedCorrectly(swapped, dict[25]!, dict[75]!) {
-            break
-        }
-    }
-
-    CheckResults(swappedCorrectly(swapped, dict[25]!, dict[75]!))
-}
-
-@inline(never)
-public func run_DictionarySwapAt(_ N: Int) {
-  let size = 100
-  var dict = [Int: Int](minimumCapacity: size)
-
-  // Fill dictionary
-  for i in 1...size {
-    dict[i] = i
-  }
-  CheckResults(dict.count == size)
-
-  var swapped = false
-  for _ in 1...2500*N {
-    let i25 = dict.index(forKey: 25)!
-    let i75 = dict.index(forKey: 75)!
-
-    dict.values.swapAt(i25, i75)
-    swapped = !swapped
-    if !swappedCorrectly(swapped, dict[25]!, dict[75]!) {
-      break
-    }
-  }
-
-  CheckResults(swappedCorrectly(swapped, dict[25]!, dict[75]!))
-}
+        CheckResults(swappedCorrectly(swapped,
+          dict[Box(25)]!.value, dict[Box(75)]!.value))
+    }}, tags: t, legacyFactor: 40),
+]
 
 // Return true if correctly swapped, false otherwise
 func swappedCorrectly(_ swapped: Bool, _ p25: Int, _ p75: Int) -> Bool {
@@ -97,56 +89,3 @@ class Box<T : Hashable> : Hashable {
     return lhs.value == rhs.value
   }
 }
-
-@inline(never)
-public func run_DictionarySwapOfObjects(_ N: Int) {
-    let size = 100
-    var dict = Dictionary<Box<Int>, Box<Int>>(minimumCapacity: size)
-
-    // Fill dictionary
-    for i in 1...size {
-        dict[Box(i)] = Box(i)
-    }
-    CheckResults(dict.count == size)
-
-    var swapped = false
-    for _ in 1...250*N {
-        let b1 = Box(25)
-        let b2 = Box(75)
-        (dict[b1], dict[b2]) = (dict[b2]!, dict[b1]!)
-        swapped = !swapped
-        if !swappedCorrectly(swapped, dict[Box(25)]!.value, dict[Box(75)]!.value) {
-            break
-        }
-    }
-
-    CheckResults(swappedCorrectly(swapped, dict[Box(25)]!.value, dict[Box(75)]!.value))
-}
-
-@inline(never)
-public func run_DictionarySwapAtOfObjects(_ N: Int) {
-  let size = 100
-  var dict = [Box<Int>: Box<Int>](minimumCapacity: size)
-
-  // Fill dictionary
-  for i in 1...size {
-    dict[Box(i)] = Box(i)
-  }
-  CheckResults(dict.count == size)
-
-  var swapped = false
-  for _ in 1...250*N {
-    let b25 = Box(25)
-    let b75 = Box(75)
-    let i25 = dict.index(forKey: b25)!
-    let i75 = dict.index(forKey: b75)!
-
-    dict.values.swapAt(i25, i75)
-    swapped = !swapped
-    if !swappedCorrectly(swapped, dict[Box(25)]!.value, dict[Box(75)]!.value) {
-      break
-    }
-  }
-
-  CheckResults(swappedCorrectly(swapped, dict[Box(25)]!.value, dict[Box(75)]!.value))
-}