[benchmark] Add benchmarks for IndexPath's subscripts, max, min

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

benchmark/single-source/IndexPathTest.swift

@@ -0,0 +1,134 @@
+//===--- 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 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: run_IndexPathSubscriptMutation,
+    tags: tags,
+    setUpFunction: { blackHole(increasingIndexPath) }),
+  BenchmarkInfo(
+    name: "IndexPath.Subscript.Range.Mutation",
+    runFunction: run_IndexPathSubscriptRangeMutation,
+    tags: tags,
+    setUpFunction: { blackHole(increasingIndexPath) }),
+  BenchmarkInfo(
+    name: "IndexPath.Max",
+    runFunction: run_IndexPathMax,
+    tags: tags,
+    setUpFunction: {
+      blackHole(decreasingIndexPath)
+      blackHole(increasingMaxMiddleIndexPath)
+      blackHole(increasingIndexPath)
+    }),
+  BenchmarkInfo(
+    name: "IndexPath.Min",
+    runFunction: run_IndexPathMin,
+    tags: tags,
+    setUpFunction: {
+      blackHole(increasingIndexPath)
+      blackHole(increasingMinMiddleIndexPath)
+      blackHole(decreasingIndexPath)
+    }),
+]
+
+func indexPath(_ size: Int, reversed: Bool = false) -> IndexPath {
+  let indexes = Array(0..<size)
+  return IndexPath(indexes: reversed ? indexes.reversed() : indexes)
+}
+
+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,
+  indexPath: IndexPath,
+  mutate: (inout IndexPath, Int) -> Void
+) {
+  for _ in 0..<n {
+    for i in 0..<mutations {
+      var ip = indexPath
+      mutate(&ip, i)
+    }
+  }
+}
+
+@inline(never)
+public func run_IndexPathSubscriptMutation(_ n: Int) {
+  subscriptMutation(
+    n: n * 10, mutations: size, indexPath: increasingIndexPath,
+    mutate: { ip, i in
+      ip[i % 4] += 1
+    })
+}
+
+@inline(never)
+public func run_IndexPathSubscriptRangeMutation(_ n: Int) {
+  subscriptMutation(
+    n: n, mutations: size, indexPath: increasingIndexPath,
+    mutate: { ip, i in
+      ip[0..<i] += [i]
+    })
+}
+
+// Max
+
+@inline(never)
+public func run_IndexPathMax(_ n: Int) {
+  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)
+  }
+}
+
+// Min
+
+@inline(never)
+public func run_IndexPathMin(_ n: Int) {
+  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)
+  }
+}

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.

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)