Add a priority queue implementation built on top of Heap

Benchmarks/Benchmarks/HeapBenchmarks.swift

@@ -11,7 +11,6 @@
 
 import CollectionsBenchmark
 import PriorityQueueModule
-import CppBenchmarks
 
 extension Benchmark {
   public mutating func addHeapBenchmarks() {
@@ -33,23 +32,23 @@ extension Benchmark {
       title: "Heap<Int> insert",
       input: [Int].self
     ) { input in
-      var queue = Heap<Int>()
+      var heap = Heap<Int>()
       for i in input {
-        queue.insert(i)
+        heap.insert(i)
       }
-      precondition(queue.count == input.count)
-      blackHole(queue)
+      precondition(heap.count == input.count)
+      blackHole(heap)
     }
 
     self.add(
       title: "Heap<Int> insert(contentsOf:)",
       input: ([Int], [Int]).self
     ) { (existing, new) in
       return { timer in
-        var queue = Heap(existing)
-        queue.insert(contentsOf: new)
-        precondition(queue.count == existing.count + new.count)
-        blackHole(queue)
+        var heap = Heap(existing)
+        heap.insert(contentsOf: new)
+        precondition(heap.count == existing.count + new.count)
+        blackHole(heap)
       }
     }
 
@@ -58,14 +57,14 @@ extension Benchmark {
       input: [Int].self
     ) { input in
       return { timer in
-        var queue = Heap(input)
+        var heap = Heap(input)
         timer.measure {
-          while let max = queue.popMax() {
+          while let max = heap.popMax() {
             blackHole(max)
           }
         }
-        precondition(queue.isEmpty)
-        blackHole(queue)
+        precondition(heap.isEmpty)
+        blackHole(heap)
       }
     }
 
@@ -74,15 +73,80 @@ extension Benchmark {
       input: [Int].self
     ) { input in
       return { timer in
-        var queue = Heap(input)
+        var heap = Heap(input)
         timer.measure {
-          while let min = queue.popMin() {
+          while let min = heap.popMin() {
             blackHole(min)
           }
         }
-        precondition(queue.isEmpty)
-        blackHole(queue)
+        precondition(heap.isEmpty)
+        blackHole(heap)
       }
     }
+
+    // MARK: Small Struct Benchmarks
+
+    self.addSimple(
+      title: "Heap<Task> insert",
+      input: [Int].self
+    ) { input in
+      var heap = Heap<HeapTask>()
+      for i in input {
+        heap.insert(HeapTask(priority: i))
+      }
+      precondition(heap.count == input.count)
+      blackHole(heap)
+    }
+    self.add(
+      title: "Heap<Task> popMax",
+      input: [Int].self
+    ) { input in
+      return { timer in
+        var heap = Heap(input.map { HeapTask(priority: $0) })
+        timer.measure {
+          while let max = heap.popMax() {
+            blackHole(max)
+          }
+        }
+        precondition(heap.isEmpty)
+        blackHole(heap)
+      }
+    }
+
+    self.add(
+      title: "Heap<Task> popMin",
+      input: [Int].self
+    ) { input in
+      return { timer in
+        var heap = Heap(input.map { HeapTask(priority: $0) })
+        timer.measure {
+          while let min = heap.popMin() {
+            blackHole(min)
+          }
+        }
+        precondition(heap.isEmpty)
+        blackHole(heap)
+      }
+    }
+  }
+
+  struct HeapTask: Comparable {
+    let name: String
+    let priority: Int
+    let work: () -> Void
+
+    init(name: String = "", priority: Int, work: @escaping () -> Void = {}) {
+      self.name = name
+      self.priority = priority
+      self.work = work
+    }
+
+    static func < (lhs: Self, rhs: Self) -> Bool {
+      lhs.priority < rhs.priority
+    }
+
+    static func == (lhs: Self, rhs: Self) -> Bool {
+      lhs.priority == rhs.priority
+    }
   }
 }

Benchmarks/Benchmarks/Library.json

@@ -802,7 +802,7 @@
               ]
             }
           ]
-        },
+        }
       ]
     },
     {

Benchmarks/Benchmarks/PriorityQueueBenchmarks.swift

@@ -0,0 +1,121 @@
+//===----------------------------------------------------------------------===//
+//
+// This source file is part of the Swift Collections open source project
+//
+// Copyright (c) 2021 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
+//
+//===----------------------------------------------------------------------===//
+
+import CollectionsBenchmark
+import PriorityQueueModule
+
+extension Benchmark {
+  public mutating func addPriorityQueueBenchmarks() {
+    self.addSimple(
+      title: "PriorityQueue<Int, Int> insert",
+      input: [Int].self
+    ) { input in
+      var queue = PriorityQueue<Int, Int>()
+      for i in input {
+        queue.insert(i, priority: i)
+      }
+      precondition(queue.count == input.count)
+      blackHole(queue)
+    }
+
+    self.add(
+      title: "PriorityQueue<Int, Int> popMax",
+      input: [Int].self
+    ) { input in
+      return { timer in
+        var queue = PriorityQueue(input.map({ ($0, $0) }))
+        timer.measure {
+          while let max = queue.popMax() {
+            blackHole(max)
+          }
+        }
+        precondition(queue.isEmpty)
+        blackHole(queue)
+      }
+    }
+
+    self.add(
+      title: "PriorityQueue<Int, Int> popMin",
+      input: [Int].self
+    ) { input in
+      return { timer in
+        var queue = PriorityQueue(input.map({ ($0, $0) }))
+        timer.measure {
+          while let min = queue.popMin() {
+            blackHole(min)
+          }
+        }
+        precondition(queue.isEmpty)
+        blackHole(queue)
+      }
+    }
+
+    // MARK: Small Struct Benchmarks
+
+    struct Task {
+      let name: String
+      let work: () -> Void
+
+      init(name: String = "", work: @escaping () -> Void = {}) {
+        self.name = name
+        self.work = work
+      }
+    }
+
+    self.addSimple(
+      title: "PriorityQueue<Task, Int> insert",
+      input: [Int].self
+    ) { input in
+      var queue = PriorityQueue<Task, Int>()
+      for i in input {
+        queue.insert(Task(name: "Test", work: {}), priority: i)
+      }
+      precondition(queue.count == input.count)
+      blackHole(queue)
+    }
+
+    self.add(
+      title: "PriorityQueue<Task, Int> popMax",
+      input: [Int].self
+    ) { input in
+      return { timer in
+        var queue = PriorityQueue<Task, Int>(
+          input.map({ (Task(name: $0.description), $0) })
+        )
+        timer.measure {
+          while let max = queue.popMax() {
+            blackHole(max)
+          }
+        }
+        precondition(queue.isEmpty)
+        blackHole(queue)
+      }
+    }
+
+    self.add(
+      title: "PriorityQueue<Task, Int> popMin",
+      input: [Int].self
+    ) { input in
+      return { timer in
+        var queue = PriorityQueue(
+          input.map({ (Task(name: $0.description), $0) })
+        )
+        timer.measure {
+          while let min = queue.popMin() {
+            blackHole(min)
+          }
+        }
+        precondition(queue.isEmpty)
+        blackHole(queue)
+      }
+    }
+  }
+}

Benchmarks/Libraries/PriorityQueue.json

@@ -0,0 +1,64 @@
+{
+  "kind": "group",
+  "title": "Priority Queue Benchmarks",
+  "directory": "Results",
+  "contents": [
+    {
+      "kind": "group",
+      "title": "PriorityQueue Operations",
+      "contents": [
+        {
+          "kind": "chart",
+          "title": "operations",
+          "tasks": [
+            "PriorityQueue<Task, Int> insert",
+            "PriorityQueue<Task, Int> popMax",
+            "PriorityQueue<Task, Int> popMin"
+          ]
+        },
+        {
+          "kind": "chart",
+          "title": "insert",
+          "tasks": [
+            "PriorityQueue<Task, Int> insert",
+          ]
+        },
+        {
+          "kind": "chart",
+          "title": "remove",
+          "tasks": [
+            "PriorityQueue<Task, Int> popMax",
+            "PriorityQueue<Task, Int> popMin"
+          ]
+        }
+      ]
+    },
+    {
+      "kind": "group",
+      "title": "PriorityQueue vs Heap",
+      "directory": "PriorityQueue + Heap",
+      "contents": [
+        {
+          "kind": "chart",
+          "title": "insert",
+          "tasks": [
+            "PriorityQueue<Int, Int> insert",
+            "PriorityQueue<Task, Int> insert",
+            "Heap<Int> insert",
+            "Heap<Task> insert"
+          ]
+        },
+        {
+          "kind": "chart",
+          "title": "pop",
+          "tasks": [
+            "PriorityQueue<Task, Int> popMin",
+            "PriorityQueue<Task, Int> popMax",
+            "Heap<Task> popMin",
+            "Heap<Task> popMax"
+          ]
+        },
+      ]
+    }
+  ]
+}

Benchmarks/benchmark-tool/main.swift

@@ -20,6 +20,7 @@ benchmark.addDequeBenchmarks()
 benchmark.addOrderedSetBenchmarks()
 benchmark.addOrderedDictionaryBenchmarks()
 benchmark.addHeapBenchmarks()
+benchmark.addPriorityQueueBenchmarks()
 benchmark.addCppBenchmarks()
 #if os(macOS) || os(iOS) || os(watchOS) || os(tvOS)
 benchmark.addFoundationBenchmarks()