Sync with SwiftPM

Author: aciidgh

Sources/TSCBasic/SynchronizedQueue.swift

@@ -11,15 +11,27 @@
 /// This class can be used as a shared queue between multiple threads providing
 /// thread safe APIs.
 public final class SynchronizedQueue<Element> {
-    /// Storage for queued elements.
-    private var storage: [Element]
+    
+    /// Linked list node.
+    private final class Node {
+        var value: Element
+        var next: Node?
+        init(_ value: Element) {
+            self.value = value
+        }
+    }
+    
+    /// Head node of the queue.
+    private var head: Node? = nil
+    
+    /// Tail node of the queue.
+    private weak var tail: Node? = nil
 
     /// Condition variable to block the thread trying dequeue and queue is empty.
     private var notEmptyCondition: Condition
 
     /// Create a default instance of queue.
     public init() {
-        storage = []
         notEmptyCondition = Condition()
     }
 
@@ -29,7 +41,15 @@ public final class SynchronizedQueue<Element> {
     ///     - element: The element to be enqueued.
     public func enqueue(_ element: Element) {
         notEmptyCondition.whileLocked {
-            storage.append(element)
+            let node = Node(element)
+            if head == nil {
+                head = node
+            } else {
+                tail?.next = node
+            }
+            // Update the tail node.
+            tail = node
+            
             // Signal a thread blocked on dequeue.
             notEmptyCondition.signal()
         }
@@ -41,12 +61,17 @@ public final class SynchronizedQueue<Element> {
     public func dequeue() -> Element {
         return notEmptyCondition.whileLocked {
             // Wait until we have an element available in the queue.
-            while storage.isEmpty {
+            while head == nil {
                 notEmptyCondition.wait()
             }
-
-            // FIXME: This is O(n) operation, optimize.
-            return storage.removeFirst()
+            
+            // There are elements in the queue, `head` is not nil.
+            let element = head!.value
+            
+            // Remove the first node.
+            head = head!.next
+            
+            return element
         }
     }
 }

Sources/TSCUtility/StringExtensions.swift

@@ -96,9 +96,10 @@ extension String {
     }
 
     public func spm_multilineIndent(count: Int) -> String {
+        let indent = String(repeating: " ", count: count)
         return self
             .split(separator: "\n")
-            .map{ String(repeating: " ", count: count) + $0 }
+            .map { indent + $0 }
             .joined(separator: "\n")
     }
 }

Tests/TSCBasicPerformanceTests/SynchronizedQueuePerfTests.swift

@@ -0,0 +1,74 @@
+/*
+ This source file is part of the Swift.org open source project
+ 
+ Copyright (c) 2014 - 2017 Apple Inc. and the Swift project authors
+ Licensed under Apache License v2.0 with Runtime Library Exception
+ 
+ See http://swift.org/LICENSE.txt for license information
+ See http://swift.org/CONTRIBUTORS.txt for Swift project authors
+ */
+
+import XCTest
+
+import TSCBasic
+import TSCTestSupport
+
+class SynchronizedQueuePerfTests: XCTestCasePerf {
+    
+    // Mock the UnitTest struct in SwiftPM/SwiftTestTool.swift
+    struct Item {
+        let productPath: AbsolutePath
+        
+        let name: String
+        
+        let testCase: String
+        
+        var specifier: String {
+            return testCase + "/" + name
+        }
+    }
+
+    
+    func testEnqueueDequeue_10000() {
+        let queue = SynchronizedQueue<Item>()
+        let test = Item(productPath: AbsolutePath.root, name: "TestName", testCase: "TestCaseName")
+        measure {
+            let N = 10000
+            for _ in 0..<N {
+                queue.enqueue(test)
+            }
+            for _ in 0..<N {
+                let _ = queue.dequeue()
+            }
+        }
+    }
+    
+    func testEnqueueDequeue_1000() {
+        let queue = SynchronizedQueue<Item>()
+        let test = Item(productPath: AbsolutePath.root, name: "TestName", testCase: "TestCaseName")
+        measure {
+            let N = 1000
+            for _ in 0..<N {
+                queue.enqueue(test)
+            }
+            for _ in 0..<N {
+                let _ = queue.dequeue()
+            }
+        }
+    }
+    
+    func testEnqueueDequeue_100() {
+        let queue = SynchronizedQueue<Item>()
+        let test = Item(productPath: AbsolutePath.root, name: "TestName", testCase: "TestCaseName")
+        measure {
+            let N = 100
+            for _ in 0..<N {
+                queue.enqueue(test)
+            }
+            for _ in 0..<N {
+                let _ = queue.dequeue()
+            }
+        }
+    }
+    
+}