Fix styling, optimize

Author: micahbenn

benchmark/single-source/IndexPathTest.swift

@@ -23,35 +23,39 @@ let tags: [BenchmarkCategory] = [.validation, .api, .IndexPath]
 public let IndexPathTest = [
   BenchmarkInfo(
     name: "IndexPath.Subscript.Mutation",
-    runFunction: { n in
-      run_IndexPathSubscriptMutation(n * 10, size, increasingIndexPath)
-    },
+    runFunction: run_IndexPathSubscriptMutation,
     tags: tags,
     setUpFunction: { blackHole(increasingIndexPath) }),
   BenchmarkInfo(
     name: "IndexPath.Subscript.Range.Mutation",
-    runFunction: { n in
-      run_IndexPathSubscriptRangeMutation(n, size, increasingIndexPath)
-    },
+    runFunction: run_IndexPathSubscriptRangeMutation,
     tags: tags,
     setUpFunction: { blackHole(increasingIndexPath) }),
   BenchmarkInfo(
     name: "IndexPath.Max",
-    runFunction: { n in run_IndexPathMax(n * 10) },
-    tags: tags),
+    runFunction: run_IndexPathMax,
+    tags: tags,
+    setUpFunction: {
+      blackHole(decreasingIndexPath)
+      blackHole(increasingMaxMiddleIndexPath)
+      blackHole(increasingIndexPath)
+    }),
   BenchmarkInfo(
     name: "IndexPath.Min",
-    runFunction: { n in run_IndexPathMin(n * 10) },
-    tags: tags),
+    runFunction: run_IndexPathMin,
+    tags: tags,
+    setUpFunction: {
+      blackHole(increasingIndexPath)
+      blackHole(increasingMinMiddleIndexPath)
+      blackHole(decreasingIndexPath)
+    }),
 ]
 
-@inline(__always)
 func indexPath(_ size: Int, reversed: Bool = false) -> IndexPath {
   let indexes = Array(0..<size)
   return IndexPath(indexes: reversed ? indexes.reversed() : indexes)
 }
 
-@inline(__always)
 func indexPath(_ size: Int, middle: Int) -> IndexPath {
   var indexes = Array(0..<size)
   indexes.insert(middle, at: (indexes.count - 1) / 2)
@@ -76,22 +80,18 @@ func subscriptMutation(
 }
 
 @inline(never)
-public func run_IndexPathSubscriptMutation(
-  _ n: Int, _ count: Int, _ indexPath: IndexPath
-) {
+public func run_IndexPathSubscriptMutation(_ n: Int) {
   subscriptMutation(
-    n: n, mutations: count, indexPath: indexPath,
+    n: n * 10, mutations: size, indexPath: increasingIndexPath,
     mutate: { ip, i in
       ip[i % 4] += 1
     })
 }
 
 @inline(never)
-public func run_IndexPathSubscriptRangeMutation(
-  _ n: Int, _ count: Int, _ indexPath: IndexPath
-) {
+public func run_IndexPathSubscriptRangeMutation(_ n: Int) {
   subscriptMutation(
-    n: n, mutations: count, indexPath: indexPath,
+    n: n, mutations: size, indexPath: increasingIndexPath,
     mutate: { ip, i in
       ip[0..<i] += [i]
     })
@@ -101,12 +101,14 @@ public func run_IndexPathSubscriptRangeMutation(
 
 @inline(never)
 public func run_IndexPathMax(_ n: Int) {
-  for _ in 0..<n {
+  for _ in 0..<n * 10 {
     var val: Int?
     // Beginning max
     val = decreasingIndexPath.max()
+    blackHole(val)
     // Middle max
     val = increasingMaxMiddleIndexPath.max()
+    blackHole(val)
     // End max
     val = increasingIndexPath.max()
     blackHole(val)
@@ -117,12 +119,14 @@ public func run_IndexPathMax(_ n: Int) {
 
 @inline(never)
 public func run_IndexPathMin(_ n: Int) {
-  for _ in 0..<n {
+  for _ in 0..<n * 10 {
     var val: Int?
     // Beginning min
     val = increasingIndexPath.min()
+    blackHole(val)
     // Middle min
     val = increasingMinMiddleIndexPath.min()
+    blackHole(val)
     // End min
     val = decreasingIndexPath.min()
     blackHole(val)