[Basic] Introduce a Condition wrapper.

 - This is just so it is clear what types we want to use for synchronization at
   the layers above Basic...

Author: ddunbar

Sources/Basic/Condition.swift

@@ -0,0 +1,48 @@
+/*
+ This source file is part of the Swift.org open source project
+
+ Copyright 2016 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 Foundation
+
+// FIXME: Temporary compatibility shims.
+#if !os(macOS)
+private typealias NSCondition = Foundation.Condition
+#endif
+
+/// A simple condition wrapper.
+public struct Condition {
+    private let _condition = NSCondition()
+
+    /// Create a new condition.
+    public init() {}
+    
+    /// Wait for the condition to become available.
+    public func wait() {
+        _condition.wait()
+    }
+
+    /// Signal the availability of the condition (awake one thread waiting on
+    /// the condition).
+    public func signal() {
+        _condition.signal()
+    }
+
+    /// Broadcast the availability of the condition (awake all threads waiting
+    /// on the condition).
+    public func broadcast() {
+        _condition.broadcast()
+    }
+    
+    /// A helper method to execute the given body while condition is locked.
+    public func whileLocked<T>(_ body: @noescape () throws -> T) rethrows -> T {
+        _condition.lock()
+        defer { _condition.unlock() }
+        return try body()
+    }
+}

Sources/Basic/Lock.swift

@@ -12,8 +12,7 @@ import Foundation
 
 // FIXME: Temporary compatibility shims.
 #if !os(macOS)
-public typealias NSLock = Foundation.Lock
-public typealias NSCondition = Foundation.Condition
+private typealias NSLock = Foundation.Lock
 #endif
 
 /// A simple lock wrapper.
@@ -31,12 +30,3 @@ public struct Lock {
         return try body()
     }
 }
-
-public extension NSCondition {
-    /// A helper method to execute the given body while condition is locked.
-    public func whileLocked<T>(_ body: @noescape () throws -> T) rethrows -> T {
-        lock()
-        defer { unlock() }
-        return try body()
-    }
-}

Sources/Basic/SynchronizedQueue.swift

@@ -8,22 +8,19 @@
  See http://swift.org/CONTRIBUTORS.txt for Swift project authors
 */
 
-import Foundation
-
 /// 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]
 
     /// Condition variable to block the thread trying dequeue and queue is empty.
-    private var notEmptyCondition: NSCondition
+    private var notEmptyCondition: Condition
 
     /// Create a default instance of queue.
     public init() {
         storage = []
-        notEmptyCondition = NSCondition()
+        notEmptyCondition = Condition()
     }
 
     /// Safely enqueue an element to end of the queue and signals a thread blocked on dequeue.

Sources/Basic/Thread.swift

@@ -20,15 +20,15 @@ final public class Thread {
     private var thread: ThreadImpl!
 
     /// Condition variable to support blocking other threads using join when this thread has not finished executing.
-    private var finishedCondition: NSCondition
+    private var finishedCondition: Condition
 
     /// A boolean variable to track if this thread has finished executing its task.
     private var finished: Bool
 
     /// Creates an instance of thread class with closure to be executed when start() is called.
     public init(task: @escaping () -> Void) {
         finished = false
-        finishedCondition = NSCondition()
+        finishedCondition = Condition()
 
         // Wrap the task with condition notifying any other threads blocked due to this thread.
         // Capture self weakly to avoid reference cycle. In case Thread is deinited before the task

Tests/BasicTests/ConditionTests.swift

@@ -0,0 +1,76 @@
+/*
+ This source file is part of the Swift.org open source project
+
+ Copyright 2016 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 Basic
+
+class ConditionTests: XCTestCase {
+    func testSignal() {
+        let condition = Condition()
+        var waiting = false
+        var doneWaiting = false
+        let thread = Thread {
+            condition.whileLocked{
+                waiting = true
+                condition.wait()
+                doneWaiting = true
+            }
+        }
+        thread.start()
+        
+        // Wait for the thread to start waiting
+        while !condition.whileLocked({ waiting }) {}
+
+        // Signal and wait for the thread to complete.
+        condition.whileLocked{
+            condition.signal()
+        }
+        thread.join()
+
+        // Wait for the thread to complete.
+        XCTAssert(doneWaiting)
+    }
+
+    func testBroadcast() {
+        let condition = Condition()
+        var waiting = [false, false]
+        var doneWaiting = [false, false]
+        let threads = [0, 1].map { i -> Thread in
+            let thread = Thread {
+                condition.whileLocked{
+                    waiting[i] = true
+                    condition.wait()
+                    doneWaiting[i] = true
+                }
+            }
+            thread.start()
+            return thread
+        }
+        
+        // Wait for the thread to start waiting
+        while !(condition.whileLocked({ waiting[0] }) || condition.whileLocked({ waiting[1] })) {}
+
+        // Signal and wait for the thread to complete.
+        condition.whileLocked{
+            condition.broadcast()
+        }
+        threads.forEach{ $0.join() }
+
+        // Wait for the thread to complete.
+        XCTAssert(doneWaiting[0])
+        XCTAssert(doneWaiting[1])
+    }
+
+    static var allTests = [
+        ("testSignal", testSignal),
+        ("testBroadcast", testBroadcast),
+    ]
+}

Tests/BasicTests/SynchronizedQueueTests.swift

@@ -8,13 +8,11 @@
  See http://swift.org/CONTRIBUTORS.txt for Swift project authors
 */
 
-import Foundation
 import XCTest
 
 import Basic
 
 class SyncronizedQueueTests: XCTestCase {
-
     func testSingleProducerConsumer() {
         let queue = SynchronizedQueue<Int?>()
         let queueElements = Set(0..<10)
@@ -92,7 +90,7 @@ class SyncronizedQueueTests: XCTestCase {
 
         var consumed = Set<Int>()
 
-        let canProduceCondition = NSCondition()
+        let canProduceCondition = Condition()
         // Initially we should be able to produce.
         var canProduce = true
 

Tests/BasicTests/ThreadTests.swift

@@ -51,19 +51,19 @@ class ThreadTests: XCTestCase {
     }
 
     func testNotDeinitBeforeExecutingTask() {
-        let finishedCondition = NSCondition()
+        let finishedCondition = Condition()
         var finished = false
 
         Thread {
             finished = true
             finishedCondition.signal()
         }.start()
 
-        finishedCondition.lock()
-        while !finished {
-            finishedCondition.wait()
+        finishedCondition.whileLocked{
+            while !finished {
+                finishedCondition.wait()
+            }
         }
-        finishedCondition.unlock()
 
         XCTAssertTrue(finished)
     }

Tests/BasicTests/XCTestManifests.swift

@@ -15,6 +15,7 @@ public func allTests() -> [XCTestCaseEntry] {
     return [
         testCase(ByteStringTests.allTests),
         testCase(CollectionAlgorithmsTests.allTests),
+        testCase(ConditionTests.allTests),
         testCase(FileAccessTests.allTests),
         testCase(FileSystemTests.allTests),
         testCase(GraphAlgorithmsTests.allTests),