Merge pull request #1840 from ahoppen/async-queue-quadratic

Fix quadratic performance issue in `AsyncQueue<Serial>`

Author: ahoppen

Sources/BuildSystemIntegration/BuildSystemMessageDependencyTracker.swift

@@ -15,7 +15,7 @@ import BuildServerProtocol
 package import LanguageServerProtocol
 import LanguageServerProtocolExtensions
 import SKLogging
-import SwiftExtensions
+package import SwiftExtensions
 #else
 import BuildServerProtocol
 import LanguageServerProtocol
@@ -82,6 +82,10 @@ package enum BuildSystemMessageDependencyTracker: QueueBasedMessageHandlerDepend
     }
   }
 
+  package func dependencies(in pendingTasks: [PendingTask<Self>]) -> [PendingTask<Self>] {
+    return pendingTasks.filter { $0.metadata.isDependency(of: self) }
+  }
+
   package init(_ request: some RequestType) {
     switch request {
     case is BuildShutdownRequest:

Sources/SourceKitLSP/MessageHandlingDependencyTracker.swift

@@ -14,7 +14,7 @@
 package import LanguageServerProtocol
 import LanguageServerProtocolExtensions
 import SKLogging
-import SwiftExtensions
+package import SwiftExtensions
 #else
 import LanguageServerProtocol
 import LanguageServerProtocolExtensions
@@ -90,6 +90,10 @@ package enum MessageHandlingDependencyTracker: QueueBasedMessageHandlerDependenc
     }
   }
 
+  package func dependencies(in pendingTasks: [PendingTask<Self>]) -> [PendingTask<Self>] {
+    return pendingTasks.filter { $0.metadata.isDependency(of: self) }
+  }
+
   package init(_ notification: some NotificationType) {
     switch notification {
     case is CancelRequestNotification:

Sources/SourceKitLSP/Swift/SyntacticTestIndex.swift

@@ -37,7 +37,6 @@ fileprivate enum TaskMetadata: DependencyTracker, Equatable {
     case (.index(_), .read):
       // We require all index tasks scheduled before the read to be finished.
       // This ensures that the index has been updated at least to the state of file at which the read was scheduled.
-      // Adding the dependency also elevates the index task's priorities.
       return true
     case (.index(let lhsUris), .index(let rhsUris)):
       // Technically, we should be able to allow simultaneous indexing of the same file. But conceptually the code
@@ -47,6 +46,10 @@ fileprivate enum TaskMetadata: DependencyTracker, Equatable {
       return !lhsUris.intersection(rhsUris).isEmpty
     }
   }
+
+  package func dependencies(in pendingTasks: [PendingTask<Self>]) -> [PendingTask<Self>] {
+    return pendingTasks.filter { $0.metadata.isDependency(of: self) }
+  }
 }
 
 /// Data from a syntactic scan of a source file for tests.

Sources/SwiftExtensions/AsyncQueue.swift

@@ -28,28 +28,31 @@ extension Task: AnyTask {
 
 /// A type that is able to track dependencies between tasks.
 package protocol DependencyTracker: Sendable {
-  /// Whether the task described by `self` needs to finish executing before
-  /// `other` can start executing.
-  func isDependency(of other: Self) -> Bool
+  /// Which tasks need to finish before a task described by `self` may start executing.
+  /// `pendingTasks` is sorted in the order in which the tasks were enqueued to `AsyncQueue`.
+  func dependencies(in pendingTasks: [PendingTask<Self>]) -> [PendingTask<Self>]
 }
 
 /// A dependency tracker where each task depends on every other, i.e. a serial
 /// queue.
 package struct Serial: DependencyTracker {
-  package func isDependency(of other: Serial) -> Bool {
-    return true
+  package func dependencies(in pendingTasks: [PendingTask<Self>]) -> [PendingTask<Self>] {
+    if let lastTask = pendingTasks.last {
+      return [lastTask]
+    }
+    return []
   }
 }
 
-private struct PendingTask<TaskMetadata: Sendable>: Sendable {
+package struct PendingTask<TaskMetadata: Sendable>: Sendable {
   /// The task that is pending.
-  let task: any AnyTask
+  fileprivate let task: any AnyTask
 
-  let metadata: TaskMetadata
+  package let metadata: TaskMetadata
 
   /// A unique value used to identify the task. This allows tasks to get
   /// removed from `pendingTasks` again after they finished executing.
-  let id: UUID
+  fileprivate let id: UUID
 }
 
 /// A list of pending tasks that can be sent across actor boundaries and is guarded by a lock.
@@ -132,7 +135,7 @@ package final class AsyncQueue<TaskMetadata: DependencyTracker>: Sendable {
     return pendingTasks.withLock { tasks in
       // Build the list of tasks that need to finished execution before this one
       // can be executed
-      let dependencies: [PendingTask] = tasks.filter { $0.metadata.isDependency(of: metadata) }
+      let dependencies = metadata.dependencies(in: tasks)
 
       // Schedule the task.
       let task = Task(priority: priority) { [pendingTasks] in