From 71784065cb5c2d70bc1b4c23b4573db3d6290855 Mon Sep 17 00:00:00 2001
From: Micah Benn <micahbenn@users.noreply.github.com>
Date: Sun, 1 Nov 2020 08:39:51 -0600
Subject: [PATCH 1/9] Add IndexPath benchmarks

Add benchmarks for subscripts, max, min
---
 benchmark/CMakeLists.txt                    |   1 +
 benchmark/single-source/IndexPathTest.swift | 167 ++++++++++++++++++++
 benchmark/utils/TestsUtils.swift            |   2 +-
 benchmark/utils/main.swift                  |   2 +
 4 files changed, 171 insertions(+), 1 deletion(-)
 create mode 100644 benchmark/single-source/IndexPathTest.swift

diff --git a/benchmark/CMakeLists.txt b/benchmark/CMakeLists.txt
index f63860100e928..8f6ca9158bf60 100644
--- a/benchmark/CMakeLists.txt
+++ b/benchmark/CMakeLists.txt
@@ -98,6 +98,7 @@ set(SWIFT_BENCH_MODULES
     single-source/Hash
     single-source/Histogram
     single-source/HTTP2StateMachine
+    single-source/IndexPathTest
     single-source/InsertCharacter
     single-source/IntegerParsing
     single-source/Integrate
diff --git a/benchmark/single-source/IndexPathTest.swift b/benchmark/single-source/IndexPathTest.swift
new file mode 100644
index 0000000000000..f454b273cd793
--- /dev/null
+++ b/benchmark/single-source/IndexPathTest.swift
@@ -0,0 +1,167 @@
+//===--- IndexPathTest.swift -------------------------------------------===//
+//
+// This source file is part of the Swift.org open source project
+//
+// Copyright (c) 2020 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
+import Foundation
+
+let size = 200
+let tags: [BenchmarkCategory] = [.validation, .api, .IndexPath]
+
+public let IndexPathTest = [
+  BenchmarkInfo(name: "IndexPathSubscriptMutation", 
+  runFunction: { n in run_IndexPathSubscriptMutation(n * 1000, size)}, 
+  tags: tags),
+  BenchmarkInfo(name: "IndexPathSubscriptRangeMutation", 
+  runFunction: { n in run_IndexPathSubscriptRangeMutation(n * 1000, size)}, 
+  tags: tags),
+
+  BenchmarkInfo(name: "IndexPathMaxBeginning", 
+  runFunction: { n in run_IndexPathMaxBeginning(n * 1000)}, 
+  tags: tags),
+  BenchmarkInfo(name: "IndexPathMaxMiddle", 
+  runFunction: { n in run_IndexPathMaxMiddle(n * 1000)}, 
+  tags: tags),
+  BenchmarkInfo(name: "IndexPathMaxEnd", 
+  runFunction: { n in run_IndexPathMaxEnd(n * 1000)}, 
+  tags: tags),
+
+  BenchmarkInfo(name: "IndexPathMinBeginning", 
+  runFunction: { n in run_IndexPathMinBeginning(n * 1000)}, 
+  tags: tags),
+  BenchmarkInfo(name: "IndexPathMinMiddle", 
+  runFunction: { n in run_IndexPathMinMiddle(n * 1000)}, 
+  tags: tags),
+  BenchmarkInfo(name: "IndexPathMinEnd", 
+  runFunction: { n in run_IndexPathMinEnd(n * 1000)}, 
+  tags: tags),
+]
+
+@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)
+    return IndexPath(indexes: indexes)
+}
+
+// Subscript Mutations
+
+@inline(__always)
+func subscriptMutation(n: Int,  
+	mutations: Int,
+	mutate: (inout IndexPath, Int) -> ()) {
+    for _ in 0..<n {
+		  var ip = indexPath(size)
+
+		  for i in 0..<mutations {
+			  mutate(&ip, i)
+		  }
+		
+      blackHole(ip)
+	}
+}
+
+@inline(never)
+public func run_IndexPathSubscriptMutation(_ n: Int, _ count: Int) {
+  subscriptMutation(n: n, 
+  mutations: count, 
+  mutate: { ip, i in
+		ip[i % 4] += 1
+	})
+}
+
+@inline(never)
+public func run_IndexPathSubscriptRangeMutation(_ n: Int, _ count: Int) {
+  subscriptMutation(n: count, 
+  mutations: count, 
+  mutate: { ip, i in
+		ip[0..<i] += [i]
+	})
+}
+
+// Max, Min
+
+@inline(__always)
+func maxMin(n: Int, 
+  creator: () -> IndexPath, 
+  maxMinFunc: (inout IndexPath) -> Int?) {
+    for _ in 0..<n {
+      var ip = creator()
+      let found = maxMinFunc(&ip) != nil
+      blackHole(found)
+    }
+}
+
+// Max
+
+@inline(never)
+public func run_IndexPathMaxBeginning(_ n: Int) {
+  maxMin(n: n, creator: {
+    indexPath(size, reversed: true)
+  }, maxMinFunc: { ip in
+    ip.max()
+  })
+}
+
+@inline(never)
+public func run_IndexPathMaxMiddle(_ n: Int) {
+  maxMin(n: n, creator: {
+    indexPath(size, middle: size + 1)
+  }, maxMinFunc: { ip in
+    ip.max()
+  })
+}
+
+@inline(never)
+public func run_IndexPathMaxEnd(_ n: Int) {
+  maxMin(n: n, creator: {
+    indexPath(size)
+  }, maxMinFunc: { ip in
+    ip.max()
+  })
+}
+
+// Min
+
+@inline(never)
+public func run_IndexPathMinBeginning(_ n: Int) {
+  maxMin(n: n, creator: {
+   indexPath(size)
+  }, maxMinFunc: { ip in
+    ip.min()
+  })
+}
+
+@inline(never)
+public func run_IndexPathMinMiddle(_ n: Int) {
+  maxMin(n: n, creator: {
+    indexPath(size, middle: -1)
+  }, maxMinFunc: { ip in
+    ip.min()
+  })
+}
+
+@inline(never)
+public func run_IndexPathMinEnd(_ n: Int) {
+  maxMin(n: n, creator: {
+    indexPath(size, reversed: true)
+  }, maxMinFunc: { ip in
+    ip.min()
+  })
+}
\ No newline at end of file
diff --git a/benchmark/utils/TestsUtils.swift b/benchmark/utils/TestsUtils.swift
index 599c50134abe5..8365ec842a5cd 100644
--- a/benchmark/utils/TestsUtils.swift
+++ b/benchmark/utils/TestsUtils.swift
@@ -23,7 +23,7 @@ public enum BenchmarkCategory : String {
   // we know is important to measure.
   case validation
   // subsystems to validate and their subcategories.
-  case api, Array, String, Dictionary, Codable, Set, Data
+  case api, Array, String, Dictionary, Codable, Set, Data, IndexPath
   case sdk
   case runtime, refcount, metadata
   // Other general areas of compiled code validation.
diff --git a/benchmark/utils/main.swift b/benchmark/utils/main.swift
index 160c4eb50c8a3..5e96e0125102d 100644
--- a/benchmark/utils/main.swift
+++ b/benchmark/utils/main.swift
@@ -86,6 +86,7 @@ import Hanoi
 import Hash
 import Histogram
 import HTTP2StateMachine
+import IndexPathTest
 import InsertCharacter
 import IntegerParsing
 import Integrate
@@ -274,6 +275,7 @@ registerBenchmark(Hanoi)
 registerBenchmark(HashTest)
 registerBenchmark(Histogram)
 registerBenchmark(HTTP2StateMachine)
+registerBenchmark(IndexPathTest)
 registerBenchmark(InsertCharacter)
 registerBenchmark(IntegerParsing)
 registerBenchmark(IntegrateTest)

From 3d40513acb96209cc80d0cf803168c3fb56637c0 Mon Sep 17 00:00:00 2001
From: Micah Benn <micahbenn@users.noreply.github.com>
Date: Sun, 1 Nov 2020 09:07:27 -0600
Subject: [PATCH 2/9] Fix formatting

---
 benchmark/single-source/IndexPathTest.swift | 18 +++++++++---------
 1 file changed, 9 insertions(+), 9 deletions(-)

diff --git a/benchmark/single-source/IndexPathTest.swift b/benchmark/single-source/IndexPathTest.swift
index f454b273cd793..e4d2e239bc60c 100644
--- a/benchmark/single-source/IndexPathTest.swift
+++ b/benchmark/single-source/IndexPathTest.swift
@@ -63,18 +63,18 @@ func indexPath(_ size: Int,
 // Subscript Mutations
 
 @inline(__always)
-func subscriptMutation(n: Int,  
-	mutations: Int,
-	mutate: (inout IndexPath, Int) -> ()) {
+func subscriptMutation(n: Int,
+  mutations: Int,
+  mutate: (inout IndexPath, Int) -> ()) {
     for _ in 0..<n {
-		  var ip = indexPath(size)
+      var ip = indexPath(size)
+
+      for i in 0..<mutations {
+        mutate(&ip, i)
+      }
 
-		  for i in 0..<mutations {
-			  mutate(&ip, i)
-		  }
-		
       blackHole(ip)
-	}
+    }
 }
 
 @inline(never)

From e69b71f4ec8541ab7d1c3bc0b7e81cb81e86a8ea Mon Sep 17 00:00:00 2001
From: Micah Benn <micahbenn@users.noreply.github.com>
Date: Sun, 1 Nov 2020 15:07:24 -0600
Subject: [PATCH 3/9] Update per style guildelines

---
 benchmark/single-source/IndexPathTest.swift | 16 +++++-----------
 1 file changed, 5 insertions(+), 11 deletions(-)

diff --git a/benchmark/single-source/IndexPathTest.swift b/benchmark/single-source/IndexPathTest.swift
index e4d2e239bc60c..0a864bea22b57 100644
--- a/benchmark/single-source/IndexPathTest.swift
+++ b/benchmark/single-source/IndexPathTest.swift
@@ -1,4 +1,4 @@
-//===--- IndexPathTest.swift -------------------------------------------===//
+//===--- IndexPathTest.swift ----------------------------------------------===//
 //
 // This source file is part of the Swift.org open source project
 //
@@ -46,15 +46,13 @@ public let IndexPathTest = [
 ]
 
 @inline(__always)
-func indexPath(_ size: Int, 
-  reversed: Bool = false) -> IndexPath {
+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 {
+func indexPath(_ size: Int, middle: Int) -> IndexPath {
     var indexes = Array(0..<size)
     indexes.insert(middle, at: (indexes.count - 1) / 2)
     return IndexPath(indexes: indexes)
@@ -79,18 +77,14 @@ func subscriptMutation(n: Int,
 
 @inline(never)
 public func run_IndexPathSubscriptMutation(_ n: Int, _ count: Int) {
-  subscriptMutation(n: n, 
-  mutations: count, 
-  mutate: { ip, i in
+  subscriptMutation(n: n,  mutations: count, mutate: { ip, i in
 		ip[i % 4] += 1
 	})
 }
 
 @inline(never)
 public func run_IndexPathSubscriptRangeMutation(_ n: Int, _ count: Int) {
-  subscriptMutation(n: count, 
-  mutations: count, 
-  mutate: { ip, i in
+  subscriptMutation(n: count, mutations: count, mutate: { ip, i in
 		ip[0..<i] += [i]
 	})
 }

From 13a638532f248bc6e5c8e77f248c591b16af38a1 Mon Sep 17 00:00:00 2001
From: Micah Benn <micahbenn@users.noreply.github.com>
Date: Sun, 1 Nov 2020 15:25:30 -0600
Subject: [PATCH 4/9] Fix indentation, move params to new line

---
 benchmark/single-source/IndexPathTest.swift | 10 ++++++----
 1 file changed, 6 insertions(+), 4 deletions(-)

diff --git a/benchmark/single-source/IndexPathTest.swift b/benchmark/single-source/IndexPathTest.swift
index 0a864bea22b57..d467288215508 100644
--- a/benchmark/single-source/IndexPathTest.swift
+++ b/benchmark/single-source/IndexPathTest.swift
@@ -61,7 +61,8 @@ func indexPath(_ size: Int, middle: Int) -> IndexPath {
 // Subscript Mutations
 
 @inline(__always)
-func subscriptMutation(n: Int,
+func subscriptMutation(
+  n: Int,
   mutations: Int,
   mutate: (inout IndexPath, Int) -> ()) {
     for _ in 0..<n {
@@ -79,20 +80,21 @@ func subscriptMutation(n: Int,
 public func run_IndexPathSubscriptMutation(_ n: Int, _ count: Int) {
   subscriptMutation(n: n,  mutations: count, mutate: { ip, i in
 		ip[i % 4] += 1
-	})
+  })
 }
 
 @inline(never)
 public func run_IndexPathSubscriptRangeMutation(_ n: Int, _ count: Int) {
   subscriptMutation(n: count, mutations: count, mutate: { ip, i in
 		ip[0..<i] += [i]
-	})
+  })
 }
 
 // Max, Min
 
 @inline(__always)
-func maxMin(n: Int, 
+func maxMin(
+  n: Int, 
   creator: () -> IndexPath, 
   maxMinFunc: (inout IndexPath) -> Int?) {
     for _ in 0..<n {

From fe5d2762f03976b96b7e206475ce16c4f95753cc Mon Sep 17 00:00:00 2001
From: Micah Benn <micahbenn@users.noreply.github.com>
Date: Sun, 1 Nov 2020 19:20:08 -0600
Subject: [PATCH 5/9] Apply swift-format

---
 benchmark/single-source/IndexPathTest.swift | 202 +++++++++++---------
 1 file changed, 116 insertions(+), 86 deletions(-)

diff --git a/benchmark/single-source/IndexPathTest.swift b/benchmark/single-source/IndexPathTest.swift
index d467288215508..d2b4c50a98aed 100644
--- a/benchmark/single-source/IndexPathTest.swift
+++ b/benchmark/single-source/IndexPathTest.swift
@@ -10,52 +10,60 @@
 //
 //===----------------------------------------------------------------------===//
 
-import TestsUtils
 import Foundation
+import TestsUtils
 
 let size = 200
 let tags: [BenchmarkCategory] = [.validation, .api, .IndexPath]
 
 public let IndexPathTest = [
-  BenchmarkInfo(name: "IndexPathSubscriptMutation", 
-  runFunction: { n in run_IndexPathSubscriptMutation(n * 1000, size)}, 
-  tags: tags),
-  BenchmarkInfo(name: "IndexPathSubscriptRangeMutation", 
-  runFunction: { n in run_IndexPathSubscriptRangeMutation(n * 1000, size)}, 
-  tags: tags),
-
-  BenchmarkInfo(name: "IndexPathMaxBeginning", 
-  runFunction: { n in run_IndexPathMaxBeginning(n * 1000)}, 
-  tags: tags),
-  BenchmarkInfo(name: "IndexPathMaxMiddle", 
-  runFunction: { n in run_IndexPathMaxMiddle(n * 1000)}, 
-  tags: tags),
-  BenchmarkInfo(name: "IndexPathMaxEnd", 
-  runFunction: { n in run_IndexPathMaxEnd(n * 1000)}, 
-  tags: tags),
-
-  BenchmarkInfo(name: "IndexPathMinBeginning", 
-  runFunction: { n in run_IndexPathMinBeginning(n * 1000)}, 
-  tags: tags),
-  BenchmarkInfo(name: "IndexPathMinMiddle", 
-  runFunction: { n in run_IndexPathMinMiddle(n * 1000)}, 
-  tags: tags),
-  BenchmarkInfo(name: "IndexPathMinEnd", 
-  runFunction: { n in run_IndexPathMinEnd(n * 1000)}, 
-  tags: tags),
+  BenchmarkInfo(
+    name: "IndexPathSubscriptMutation",
+    runFunction: { n in run_IndexPathSubscriptMutation(n * 1000, size) },
+    tags: tags),
+  BenchmarkInfo(
+    name: "IndexPathSubscriptRangeMutation",
+    runFunction: { n in run_IndexPathSubscriptRangeMutation(n * 1000, size) },
+    tags: tags),
+
+  BenchmarkInfo(
+    name: "IndexPathMaxBeginning",
+    runFunction: { n in run_IndexPathMaxBeginning(n * 1000) },
+    tags: tags),
+  BenchmarkInfo(
+    name: "IndexPathMaxMiddle",
+    runFunction: { n in run_IndexPathMaxMiddle(n * 1000) },
+    tags: tags),
+  BenchmarkInfo(
+    name: "IndexPathMaxEnd",
+    runFunction: { n in run_IndexPathMaxEnd(n * 1000) },
+    tags: tags),
+
+  BenchmarkInfo(
+    name: "IndexPathMinBeginning",
+    runFunction: { n in run_IndexPathMinBeginning(n * 1000) },
+    tags: tags),
+  BenchmarkInfo(
+    name: "IndexPathMinMiddle",
+    runFunction: { n in run_IndexPathMinMiddle(n * 1000) },
+    tags: tags),
+  BenchmarkInfo(
+    name: "IndexPathMinEnd",
+    runFunction: { n in run_IndexPathMinEnd(n * 1000) },
+    tags: tags),
 ]
 
 @inline(__always)
 func indexPath(_ size: Int, reversed: Bool = false) -> IndexPath {
-    let indexes = Array(0..<size)
-    return IndexPath(indexes: reversed ? indexes.reversed() : indexes)
+  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)
-    return IndexPath(indexes: indexes)
+  var indexes = Array(0..<size)
+  indexes.insert(middle, at: (indexes.count - 1) / 2)
+  return IndexPath(indexes: indexes)
 }
 
 // Subscript Mutations
@@ -64,100 +72,122 @@ func indexPath(_ size: Int, middle: Int) -> IndexPath {
 func subscriptMutation(
   n: Int,
   mutations: Int,
-  mutate: (inout IndexPath, Int) -> ()) {
-    for _ in 0..<n {
-      var ip = indexPath(size)
-
-      for i in 0..<mutations {
-        mutate(&ip, i)
-      }
-
-      blackHole(ip)
+  mutate: (inout IndexPath, Int) -> Void
+) {
+  for _ in 0..<n {
+    var ip = indexPath(size)
+    for i in 0..<mutations {
+      mutate(&ip, i)
     }
+    blackHole(ip)
+  }
 }
 
 @inline(never)
 public func run_IndexPathSubscriptMutation(_ n: Int, _ count: Int) {
-  subscriptMutation(n: n,  mutations: count, mutate: { ip, i in
-		ip[i % 4] += 1
-  })
+  subscriptMutation(
+    n: n, mutations: count,
+    mutate: { ip, i in
+      ip[i % 4] += 1
+    })
 }
 
 @inline(never)
 public func run_IndexPathSubscriptRangeMutation(_ n: Int, _ count: Int) {
-  subscriptMutation(n: count, mutations: count, mutate: { ip, i in
-		ip[0..<i] += [i]
-  })
+  subscriptMutation(
+    n: count, mutations: count,
+    mutate: { ip, i in
+      ip[0..<i] += [i]
+    })
 }
 
 // Max, Min
 
 @inline(__always)
 func maxMin(
-  n: Int, 
-  creator: () -> IndexPath, 
-  maxMinFunc: (inout IndexPath) -> Int?) {
-    for _ in 0..<n {
-      var ip = creator()
-      let found = maxMinFunc(&ip) != nil
-      blackHole(found)
-    }
+  n: Int,
+  creator: () -> IndexPath,
+  maxMinFunc: (inout IndexPath) -> Int?
+) {
+  for _ in 0..<n {
+    var ip = creator()
+    let found = maxMinFunc(&ip) != nil
+    blackHole(found)
+  }
 }
 
 // Max
 
 @inline(never)
 public func run_IndexPathMaxBeginning(_ n: Int) {
-  maxMin(n: n, creator: {
-    indexPath(size, reversed: true)
-  }, maxMinFunc: { ip in
-    ip.max()
-  })
+  maxMin(
+    n: n,
+    creator: {
+      indexPath(size, reversed: true)
+    },
+    maxMinFunc: { ip in
+      ip.max()
+    })
 }
 
 @inline(never)
 public func run_IndexPathMaxMiddle(_ n: Int) {
-  maxMin(n: n, creator: {
-    indexPath(size, middle: size + 1)
-  }, maxMinFunc: { ip in
-    ip.max()
-  })
+  maxMin(
+    n: n,
+    creator: {
+      indexPath(size, middle: size + 1)
+    },
+    maxMinFunc: { ip in
+      ip.max()
+    })
 }
 
 @inline(never)
 public func run_IndexPathMaxEnd(_ n: Int) {
-  maxMin(n: n, creator: {
-    indexPath(size)
-  }, maxMinFunc: { ip in
-    ip.max()
-  })
+  maxMin(
+    n: n,
+    creator: {
+      indexPath(size)
+    },
+    maxMinFunc: { ip in
+      ip.max()
+    })
 }
 
 // Min
 
 @inline(never)
 public func run_IndexPathMinBeginning(_ n: Int) {
-  maxMin(n: n, creator: {
-   indexPath(size)
-  }, maxMinFunc: { ip in
-    ip.min()
-  })
+  maxMin(
+    n: n,
+    creator: {
+      indexPath(size)
+    },
+    maxMinFunc: { ip in
+      ip.min()
+    })
 }
 
 @inline(never)
 public func run_IndexPathMinMiddle(_ n: Int) {
-  maxMin(n: n, creator: {
-    indexPath(size, middle: -1)
-  }, maxMinFunc: { ip in
-    ip.min()
-  })
+  maxMin(
+    n: n,
+    creator: {
+      indexPath(size, middle: -1)
+    },
+    maxMinFunc: { ip in
+      ip.min()
+    })
 }
 
 @inline(never)
 public func run_IndexPathMinEnd(_ n: Int) {
-  maxMin(n: n, creator: {
-    indexPath(size, reversed: true)
-  }, maxMinFunc: { ip in
-    ip.min()
-  })
-}
\ No newline at end of file
+  maxMin(
+    n: n,
+    creator: {
+      indexPath(size, reversed: true)
+    },
+    maxMinFunc: { ip in
+      ip.min()
+    })
+}

From 55b3b34dcc24cd9a6a710fa4637c6c5f98562398 Mon Sep 17 00:00:00 2001
From: Micah Benn <micahbenn@users.noreply.github.com>
Date: Sun, 1 Nov 2020 23:05:00 -0600
Subject: [PATCH 6/9] Decrease load 16x, fix naming, fix mem usage

Fixes mem usage of run_IndexPathSubscriptRangeMutation
---
 benchmark/single-source/IndexPathTest.swift | 34 ++++++++++-----------
 1 file changed, 17 insertions(+), 17 deletions(-)

diff --git a/benchmark/single-source/IndexPathTest.swift b/benchmark/single-source/IndexPathTest.swift
index d2b4c50a98aed..815031404df2e 100644
--- a/benchmark/single-source/IndexPathTest.swift
+++ b/benchmark/single-source/IndexPathTest.swift
@@ -18,38 +18,38 @@ let tags: [BenchmarkCategory] = [.validation, .api, .IndexPath]
 
 public let IndexPathTest = [
   BenchmarkInfo(
-    name: "IndexPathSubscriptMutation",
-    runFunction: { n in run_IndexPathSubscriptMutation(n * 1000, size) },
+    name: "IndexPath.Subscript.Mutation",
+    runFunction: { n in run_IndexPathSubscriptMutation(n * 60, size) },
     tags: tags),
   BenchmarkInfo(
-    name: "IndexPathSubscriptRangeMutation",
-    runFunction: { n in run_IndexPathSubscriptRangeMutation(n * 1000, size) },
+    name: "IndexPath.Subscript.Range.Mutation",
+    runFunction: { n in run_IndexPathSubscriptRangeMutation(n * 60, size) },
     tags: tags),
 
   BenchmarkInfo(
-    name: "IndexPathMaxBeginning",
-    runFunction: { n in run_IndexPathMaxBeginning(n * 1000) },
+    name: "IndexPath.Max.Beginning",
+    runFunction: { n in run_IndexPathMaxBeginning(n * 60) },
     tags: tags),
   BenchmarkInfo(
-    name: "IndexPathMaxMiddle",
-    runFunction: { n in run_IndexPathMaxMiddle(n * 1000) },
+    name: "IndexPath.Max.Middle",
+    runFunction: { n in run_IndexPathMaxMiddle(n * 60) },
     tags: tags),
   BenchmarkInfo(
-    name: "IndexPathMaxEnd",
-    runFunction: { n in run_IndexPathMaxEnd(n * 1000) },
+    name: "IndexPath.Max.End",
+    runFunction: { n in run_IndexPathMaxEnd(n * 60) },
     tags: tags),
 
   BenchmarkInfo(
-    name: "IndexPathMinBeginning",
-    runFunction: { n in run_IndexPathMinBeginning(n * 1000) },
+    name: "IndexPath.Min.Beginning",
+    runFunction: { n in run_IndexPathMinBeginning(n * 60) },
     tags: tags),
   BenchmarkInfo(
-    name: "IndexPathMinMiddle",
-    runFunction: { n in run_IndexPathMinMiddle(n * 1000) },
+    name: "IndexPath.Min.Middle",
+    runFunction: { n in run_IndexPathMinMiddle(n * 60) },
     tags: tags),
   BenchmarkInfo(
-    name: "IndexPathMinEnd",
-    runFunction: { n in run_IndexPathMinEnd(n * 1000) },
+    name: "IndexPath.Min.End",
+    runFunction: { n in run_IndexPathMinEnd(n * 60) },
     tags: tags),
 ]
 
@@ -95,7 +95,7 @@ public func run_IndexPathSubscriptMutation(_ n: Int, _ count: Int) {
 @inline(never)
 public func run_IndexPathSubscriptRangeMutation(_ n: Int, _ count: Int) {
   subscriptMutation(
-    n: count, mutations: count,
+    n: n, mutations: count,
     mutate: { ip, i in
       ip[0..<i] += [i]
     })

From 6f103c63b258169a634188248bad03ea26ca3e00 Mon Sep 17 00:00:00 2001
From: Micah Benn <micahbenn@users.noreply.github.com>
Date: Sun, 1 Nov 2020 23:46:43 -0600
Subject: [PATCH 7/9] Pre-construct indexPath, use setUpFunction

---
 benchmark/single-source/IndexPathTest.swift | 116 ++++++++++++--------
 1 file changed, 68 insertions(+), 48 deletions(-)

diff --git a/benchmark/single-source/IndexPathTest.swift b/benchmark/single-source/IndexPathTest.swift
index 815031404df2e..645dcab355773 100644
--- a/benchmark/single-source/IndexPathTest.swift
+++ b/benchmark/single-source/IndexPathTest.swift
@@ -14,43 +14,71 @@ import Foundation
 import TestsUtils
 
 let size = 200
+let increasingIndexPath = indexPath(size)
+let decreasingIndexPath = indexPath(size, reversed: true)
+let increasingMaxMiddleIndexPath = indexPath(size, middle: size + 1)
+let increasingMinMiddleIndexPath = indexPath(size, middle: -1)
 let tags: [BenchmarkCategory] = [.validation, .api, .IndexPath]
 
 public let IndexPathTest = [
   BenchmarkInfo(
     name: "IndexPath.Subscript.Mutation",
-    runFunction: { n in run_IndexPathSubscriptMutation(n * 60, size) },
-    tags: tags),
+    runFunction: { n in
+      run_IndexPathSubscriptMutation(n * 10, size, increasingIndexPath)
+    },
+    tags: tags,
+    setUpFunction: { blackHole(increasingIndexPath) }),
   BenchmarkInfo(
     name: "IndexPath.Subscript.Range.Mutation",
-    runFunction: { n in run_IndexPathSubscriptRangeMutation(n * 60, size) },
-    tags: tags),
+    runFunction: { n in
+      run_IndexPathSubscriptRangeMutation(n, size, increasingIndexPath)
+    },
+    tags: tags,
+    setUpFunction: { blackHole(increasingIndexPath) }),
 
   BenchmarkInfo(
     name: "IndexPath.Max.Beginning",
-    runFunction: { n in run_IndexPathMaxBeginning(n * 60) },
-    tags: tags),
+    runFunction: { n in 
+      run_IndexPathMaxBeginning(n * 25, decreasingIndexPath)
+    },
+    tags: tags,
+    setUpFunction: { blackHole(decreasingIndexPath) }),
   BenchmarkInfo(
     name: "IndexPath.Max.Middle",
-    runFunction: { n in run_IndexPathMaxMiddle(n * 60) },
-    tags: tags),
+    runFunction: { n in
+      run_IndexPathMaxMiddle(n * 25, increasingMaxMiddleIndexPath)
+    },
+    tags: tags,
+    setUpFunction: { blackHole(increasingMaxMiddleIndexPath) }),
   BenchmarkInfo(
     name: "IndexPath.Max.End",
-    runFunction: { n in run_IndexPathMaxEnd(n * 60) },
-    tags: tags),
+    runFunction: { n in 
+      run_IndexPathMaxEnd(n * 25, increasingIndexPath) 
+    },
+    tags: tags,
+    setUpFunction: { blackHole(increasingIndexPath) }),
 
   BenchmarkInfo(
     name: "IndexPath.Min.Beginning",
-    runFunction: { n in run_IndexPathMinBeginning(n * 60) },
-    tags: tags),
+    runFunction: { n in 
+      run_IndexPathMinBeginning(n * 25, increasingIndexPath)
+    },
+    tags: tags,
+    setUpFunction: { blackHole(increasingIndexPath) }),
   BenchmarkInfo(
     name: "IndexPath.Min.Middle",
-    runFunction: { n in run_IndexPathMinMiddle(n * 60) },
-    tags: tags),
+    runFunction: { n in
+      run_IndexPathMinMiddle(n * 25, increasingMinMiddleIndexPath)
+    },
+    tags: tags,
+    setUpFunction: { blackHole(increasingMinMiddleIndexPath) }),
   BenchmarkInfo(
     name: "IndexPath.Min.End",
-    runFunction: { n in run_IndexPathMinEnd(n * 60) },
-    tags: tags),
+    runFunction: { n in 
+      run_IndexPathMinEnd(n * 25, decreasingIndexPath) 
+    },
+    tags: tags,
+    setUpFunction: { blackHole(decreasingIndexPath) }),
 ]
 
 @inline(__always)
@@ -72,30 +100,34 @@ func indexPath(_ size: Int, middle: Int) -> IndexPath {
 func subscriptMutation(
   n: Int,
   mutations: Int,
+  indexPath: IndexPath,
   mutate: (inout IndexPath, Int) -> Void
 ) {
   for _ in 0..<n {
-    var ip = indexPath(size)
     for i in 0..<mutations {
+      var ip = indexPath
       mutate(&ip, i)
     }
-    blackHole(ip)
   }
 }
 
 @inline(never)
-public func run_IndexPathSubscriptMutation(_ n: Int, _ count: Int) {
+public func run_IndexPathSubscriptMutation(
+  _ n: Int, _ count: Int, _ indexPath: IndexPath
+) {
   subscriptMutation(
-    n: n, mutations: count,
+    n: n, mutations: count, indexPath: indexPath,
     mutate: { ip, i in
       ip[i % 4] += 1
     })
 }
 
 @inline(never)
-public func run_IndexPathSubscriptRangeMutation(_ n: Int, _ count: Int) {
+public func run_IndexPathSubscriptRangeMutation(
+  _ n: Int, _ count: Int, _ indexPath: IndexPath
+) {
   subscriptMutation(
-    n: n, mutations: count,
+    n: n, mutations: count, indexPath: indexPath,
     mutate: { ip, i in
       ip[0..<i] += [i]
     })
@@ -106,11 +138,11 @@ public func run_IndexPathSubscriptRangeMutation(_ n: Int, _ count: Int) {
 @inline(__always)
 func maxMin(
   n: Int,
-  creator: () -> IndexPath,
+  indexPath: IndexPath,
   maxMinFunc: (inout IndexPath) -> Int?
 ) {
   for _ in 0..<n {
-    var ip = creator()
+    var ip = indexPath
     let found = maxMinFunc(&ip) != nil
     blackHole(found)
   }
@@ -119,36 +151,30 @@ func maxMin(
 // Max
 
 @inline(never)
-public func run_IndexPathMaxBeginning(_ n: Int) {
+public func run_IndexPathMaxBeginning(_ n: Int, _ indexPath: IndexPath) {
   maxMin(
     n: n,
-    creator: {
-      indexPath(size, reversed: true)
-    },
+    indexPath: indexPath,
     maxMinFunc: { ip in
       ip.max()
     })
 }
 
 @inline(never)
-public func run_IndexPathMaxMiddle(_ n: Int) {
+public func run_IndexPathMaxMiddle(_ n: Int, _ indexPath: IndexPath) {
   maxMin(
     n: n,
-    creator: {
-      indexPath(size, middle: size + 1)
-    },
+    indexPath: indexPath,
     maxMinFunc: { ip in
       ip.max()
     })
 }
 
 @inline(never)
-public func run_IndexPathMaxEnd(_ n: Int) {
+public func run_IndexPathMaxEnd(_ n: Int, _ indexPath: IndexPath) {
   maxMin(
     n: n,
-    creator: {
-      indexPath(size)
-    },
+    indexPath: indexPath,
     maxMinFunc: { ip in
       ip.max()
     })
@@ -157,36 +183,30 @@ public func run_IndexPathMaxEnd(_ n: Int) {
 // Min
 
 @inline(never)
-public func run_IndexPathMinBeginning(_ n: Int) {
+public func run_IndexPathMinBeginning(_ n: Int, _ indexPath: IndexPath) {
   maxMin(
     n: n,
-    creator: {
-      indexPath(size)
-    },
+    indexPath: indexPath,
     maxMinFunc: { ip in
       ip.min()
     })
 }
 
 @inline(never)
-public func run_IndexPathMinMiddle(_ n: Int) {
+public func run_IndexPathMinMiddle(_ n: Int, _ indexPath: IndexPath) {
   maxMin(
     n: n,
-    creator: {
-      indexPath(size, middle: -1)
-    },
+    indexPath: indexPath,
     maxMinFunc: { ip in
       ip.min()
     })
 }
 
 @inline(never)
-public func run_IndexPathMinEnd(_ n: Int) {
+public func run_IndexPathMinEnd(_ n: Int, _ indexPath: IndexPath) {
   maxMin(
     n: n,
-    creator: {
-      indexPath(size, reversed: true)
-    },
+    indexPath: indexPath,
     maxMinFunc: { ip in
       ip.min()
     })

From 477bef7dfc375ef15e4a20e63460757330f14ea7 Mon Sep 17 00:00:00 2001
From: Micah Benn <micahbenn@users.noreply.github.com>
Date: Fri, 6 Nov 2020 20:11:16 -0600
Subject: [PATCH 8/9] Condense benchmarks

---
 benchmark/single-source/IndexPathTest.swift | 139 ++++----------------
 1 file changed, 28 insertions(+), 111 deletions(-)

diff --git a/benchmark/single-source/IndexPathTest.swift b/benchmark/single-source/IndexPathTest.swift
index 645dcab355773..290886ac9fbd2 100644
--- a/benchmark/single-source/IndexPathTest.swift
+++ b/benchmark/single-source/IndexPathTest.swift
@@ -35,50 +35,14 @@ public let IndexPathTest = [
     },
     tags: tags,
     setUpFunction: { blackHole(increasingIndexPath) }),
-
-  BenchmarkInfo(
-    name: "IndexPath.Max.Beginning",
-    runFunction: { n in 
-      run_IndexPathMaxBeginning(n * 25, decreasingIndexPath)
-    },
-    tags: tags,
-    setUpFunction: { blackHole(decreasingIndexPath) }),
-  BenchmarkInfo(
-    name: "IndexPath.Max.Middle",
-    runFunction: { n in
-      run_IndexPathMaxMiddle(n * 25, increasingMaxMiddleIndexPath)
-    },
-    tags: tags,
-    setUpFunction: { blackHole(increasingMaxMiddleIndexPath) }),
   BenchmarkInfo(
-    name: "IndexPath.Max.End",
-    runFunction: { n in 
-      run_IndexPathMaxEnd(n * 25, increasingIndexPath) 
-    },
-    tags: tags,
-    setUpFunction: { blackHole(increasingIndexPath) }),
-
+    name: "IndexPath.Max",
+    runFunction: { n in run_IndexPathMax(n * 10) },
+    tags: tags),
   BenchmarkInfo(
-    name: "IndexPath.Min.Beginning",
-    runFunction: { n in 
-      run_IndexPathMinBeginning(n * 25, increasingIndexPath)
-    },
-    tags: tags,
-    setUpFunction: { blackHole(increasingIndexPath) }),
-  BenchmarkInfo(
-    name: "IndexPath.Min.Middle",
-    runFunction: { n in
-      run_IndexPathMinMiddle(n * 25, increasingMinMiddleIndexPath)
-    },
-    tags: tags,
-    setUpFunction: { blackHole(increasingMinMiddleIndexPath) }),
-  BenchmarkInfo(
-    name: "IndexPath.Min.End",
-    runFunction: { n in 
-      run_IndexPathMinEnd(n * 25, decreasingIndexPath) 
-    },
-    tags: tags,
-    setUpFunction: { blackHole(decreasingIndexPath) }),
+    name: "IndexPath.Min",
+    runFunction: { n in run_IndexPathMin(n * 10) },
+    tags: tags),
 ]
 
 @inline(__always)
@@ -133,81 +97,34 @@ public func run_IndexPathSubscriptRangeMutation(
     })
 }
 
-// Max, Min
-
-@inline(__always)
-func maxMin(
-  n: Int,
-  indexPath: IndexPath,
-  maxMinFunc: (inout IndexPath) -> Int?
-) {
-  for _ in 0..<n {
-    var ip = indexPath
-    let found = maxMinFunc(&ip) != nil
-    blackHole(found)
-  }
-}
-
 // Max
 
 @inline(never)
-public func run_IndexPathMaxBeginning(_ n: Int, _ indexPath: IndexPath) {
-  maxMin(
-    n: n,
-    indexPath: indexPath,
-    maxMinFunc: { ip in
-      ip.max()
-    })
-}
-
-@inline(never)
-public func run_IndexPathMaxMiddle(_ n: Int, _ indexPath: IndexPath) {
-  maxMin(
-    n: n,
-    indexPath: indexPath,
-    maxMinFunc: { ip in
-      ip.max()
-    })
-}
-
-@inline(never)
-public func run_IndexPathMaxEnd(_ n: Int, _ indexPath: IndexPath) {
-  maxMin(
-    n: n,
-    indexPath: indexPath,
-    maxMinFunc: { ip in
-      ip.max()
-    })
+public func run_IndexPathMax(_ n: Int) {
+  for _ in 0..<n {
+    var val: Int?
+    // Beginning max
+    val = decreasingIndexPath.max()
+    // Middle max
+    val = increasingMaxMiddleIndexPath.max()
+    // End max
+    val = increasingIndexPath.max()
+    blackHole(val)
+  }
 }
 
 // Min
 
 @inline(never)
-public func run_IndexPathMinBeginning(_ n: Int, _ indexPath: IndexPath) {
-  maxMin(
-    n: n,
-    indexPath: indexPath,
-    maxMinFunc: { ip in
-      ip.min()
-    })
-}
-
-@inline(never)
-public func run_IndexPathMinMiddle(_ n: Int, _ indexPath: IndexPath) {
-  maxMin(
-    n: n,
-    indexPath: indexPath,
-    maxMinFunc: { ip in
-      ip.min()
-    })
-}
-
-@inline(never)
-public func run_IndexPathMinEnd(_ n: Int, _ indexPath: IndexPath) {
-  maxMin(
-    n: n,
-    indexPath: indexPath,
-    maxMinFunc: { ip in
-      ip.min()
-    })
+public func run_IndexPathMin(_ n: Int) {
+  for _ in 0..<n {
+    var val: Int?
+    // Beginning min
+    val = increasingIndexPath.min()
+    // Middle min
+    val = increasingMinMiddleIndexPath.min()
+    // End min
+    val = decreasingIndexPath.min()
+    blackHole(val)
+  }
 }

From 25bd5eaed729050cc56d3192bd0ecf92bdcbc035 Mon Sep 17 00:00:00 2001
From: Micah Benn <micahbenn@users.noreply.github.com>
Date: Mon, 9 Nov 2020 17:04:59 -0600
Subject: [PATCH 9/9] Fix styling, optimize

---
 benchmark/single-source/IndexPathTest.swift | 48 +++++++++++----------
 1 file changed, 26 insertions(+), 22 deletions(-)

diff --git a/benchmark/single-source/IndexPathTest.swift b/benchmark/single-source/IndexPathTest.swift
index 290886ac9fbd2..c85d5392d3c80 100644
--- a/benchmark/single-source/IndexPathTest.swift
+++ b/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)