Few benchmarks for predicate evaluation

Benchmarks/Benchmarks/Predicates/Predicates.swift

@@ -0,0 +1,103 @@
+//===----------------------------------------------------------------------===//
+//
+// This source file is part of the Swift.org open source project
+//
+// Copyright (c) 2022-2023 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 Benchmark
+import func Benchmark.blackHole
+import FoundationEssentials
+
+let benchmarks = {
+    Benchmark.defaultConfiguration.maxIterations = 1_000_000_000
+    Benchmark.defaultConfiguration.maxDuration = .seconds(3)
+    Benchmark.defaultConfiguration.scalingFactor = .kilo
+    Benchmark.defaultConfiguration.metrics = .arc + [.cpuTotal, .wallClock, .mallocCountTotal, .throughput] // use ARC to see traffic
+//  Benchmark.defaultConfiguration.metrics = [.cpuTotal, .wallClock, .mallocCountTotal, .throughput] // skip ARC as it has some overhead
+//  Benchmark.defaultConfiguration.metrics = .all // Use all metrics to easily see which ones are of interest for this benchmark suite
+    if #available(macOS 14, *) {
+
+        let monster = Monster(name: "Orc", level: 80, hp: 100, mana: 0, weapon: .sword(Sword(p1: 1, p2: 2, p3: 3, p4: 4, p5: 5)))
+
+        var predicateTests : [(String, Predicate<Monster>)] = []
+
+        predicateTests.append(("predicateTrivialCondition", #Predicate<Monster> { monster in
+            true
+        }))
+
+        predicateTests.append(("predicateKeypathPropertyCondition", #Predicate<Monster> { monster in
+            (monster.level == 80)
+        }))
+
+        predicateTests.append(("predicateKeypathComputedPropertyCondition", #Predicate<Monster> { monster in
+            (monster.levelComputed == 80)
+        }))
+
+        predicateTests.append(("predicateKeypathNestedComputedPropertyCondition", #Predicate<Monster> { monster in
+            (monster.weaponP1 == 1)
+        }))
+
+        predicateTests.append(("predicateThreeKeypathNestedComputedPropertyCondition", #Predicate<Monster> { monster in
+            ((monster.weaponP1 == 1) &&
+             (monster.weaponP2 == 2) &&
+             (monster.weaponP3 == 3))
+        }))
+
+    // This test disabled, as enabling it will make compilation fail due to https://github.com/apple/swift/issues/69277
+    //      predicateTests.append(("predicateFiveKeypathNestedComputedPropertyCondition", #Predicate<Monster> { monster in
+    //          ((monster.weaponP1 == 1) &&
+    //           (monster.weaponP2 == 2) &&
+    //           (monster.weaponP3 == 3) &&
+    //           (monster.weaponP4 == 4) &&
+    //           (monster.weaponP5 == 5))
+    //      }))
+
+        predicateTests.forEach { (testDescription, predicate) in
+            Benchmark(testDescription) { benchmark in
+                var matched = 0
+
+                for _ in benchmark.scaledIterations {
+                    if try predicate.evaluate(monster) {
+                        matched += 1
+                    }
+                }
+
+                guard matched == benchmark.scaledIterations.count else {
+                    fatalError("Internal error: wrong number of matched monsters")
+                }
+            }
+        }
+
+        var variadicPredicateTests : [(String, Predicate<Monster, Monster>)] = []
+        let monster2 = Monster(name: "Orc", level: 80, hp: 100, mana: 0, weapon: .sword(Sword(p1: 1, p2: 2, p3: 3, p4: 4, p5: 5)))
+
+        variadicPredicateTests.append(("predicateVariadicThreeKeypathNestedComputedPropertyCondition",
+                                       #Predicate<Monster, Monster> { monster, monster2 in
+            ((monster.weaponP1 == 1) &&
+             (monster.weaponP2 == 2) &&
+             (monster2.weaponP2 == 2))
+        }))
+
+        variadicPredicateTests.forEach { (testDescription, predicate) in
+            Benchmark(testDescription) { benchmark in
+                var matched = 0
+
+                for _ in benchmark.scaledIterations {
+                    if try predicate.evaluate(monster, monster2) {
+                        matched += 1
+                    }
+                }
+
+                guard matched == benchmark.scaledIterations.count else {
+                    fatalError("Internal error: wrong number of matched monsters")
+                }
+            }
+        }
+    }
+}

Benchmarks/Benchmarks/Predicates/PredicatesTypes.swift

@@ -0,0 +1,110 @@
+//===----------------------------------------------------------------------===//
+//
+// This source file is part of the Swift.org open source project
+//
+// Copyright (c) 2022-2023 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
+//
+//===----------------------------------------------------------------------===//
+
+struct Mace {
+    let p1: Int
+    let p2: Int
+    let p3: Int
+    let p4: Int
+    let p5: Int
+}
+
+struct Sword {
+    let p1: Int
+    let p2: Int
+    let p3: Int
+    let p4: Int
+    let p5: Int
+}
+
+struct Lightsaber {
+    let p1: Int
+    let p2: Int
+    let p3: Int
+    let p4: Int
+    let p5: Int
+}
+
+enum Weapon {
+    case mace(Mace)
+    case sword(Sword)
+    case lightsaber(Lightsaber)
+
+    var p1: Int {
+        switch self {
+        case let .mace(mace):
+            mace.p1
+        case let .sword(sword):
+            sword.p1
+        case let .lightsaber(lighsaber):
+            lighsaber.p1
+        }
+    }
+
+    var p2: Int {
+        switch self {
+        case let .mace(mace):
+            mace.p2
+        case let .sword(sword):
+            sword.p2
+        case let .lightsaber(lighsaber):
+            lighsaber.p2
+        }
+    }
+
+    var p3: Int {
+        switch self {
+        case let .mace(mace):
+            mace.p3
+        case let .sword(sword):
+            sword.p3
+        case let .lightsaber(lighsaber):
+            lighsaber.p3
+        }
+    }
+
+    var p4: Int {
+        switch self {
+        case let .mace(mace):
+            mace.p4
+        case let .sword(sword):
+            sword.p4
+        case let .lightsaber(lighsaber):
+            lighsaber.p4
+        }
+    }
+
+    var p5: Int {
+        switch self {
+        case let .mace(mace):
+            mace.p5
+        case let .sword(sword):
+            sword.p5
+        case let .lightsaber(lighsaber):
+            lighsaber.p5
+        }
+    }
+}
+
+struct Monster {
+    let name: String
+    var level: Int
+    var hp: Int
+    var mana: Int
+    var weapon: Weapon?
+    var levelComputed: Int { level }
+    var weaponP1: Int? { weapon?.p1 }
+    var weaponP2: Int? { weapon?.p2 }
+    var weaponP3: Int? { weapon?.p3 }
+    var weaponP4: Int? { weapon?.p4 }
+    var weaponP5: Int? { weapon?.p5 }
+}

Benchmarks/Package.swift

@@ -0,0 +1,25 @@
+// swift-tools-version: 5.9
+
+import PackageDescription
+
+let package = Package(
+    name: "benchmarks",
+    platforms: [.macOS("13.3"), .iOS("16.4"), .tvOS("16.4"), .watchOS("9.4")], // Should match parent project
+    dependencies: [
+        .package(path: "../"),
+        .package(url: "https://github.com/ordo-one/package-benchmark.git", from: "1.11.1"),
+    ],
+    targets: [
+        .executableTarget(
+            name: "PredicateBenchmarks",
+            dependencies: [
+                .product(name: "FoundationEssentials", package: "swift-foundation"),
+                .product(name: "Benchmark", package: "package-benchmark"),
+            ],
+            path: "Benchmarks/Predicates",
+            plugins: [
+                .plugin(name: "BenchmarkPlugin", package: "package-benchmark")
+            ]
+        ),
+    ]
+)