Merge pull request #9 from ypopovych/master

Run Loop fixes

Author: dileping

ExecutionContext/LoopSemaphore.swift

@@ -1,4 +1,4 @@
-//===--- Semaphore.swift ------------------------------------------------------===//
+//===--- LoopSemaphore.swift -----------------------------------------------===//
 //Copyright (c) 2016 Daniel Leping (dileping)
 //
 //Licensed under the Apache License, Version 2.0 (the "License");
@@ -16,41 +16,43 @@
 
 import Foundation
 
-import Dispatch
+#if !os(Linux)
+    import Dispatch
 
-public class DispatchLoopSemaphore : SemaphoreType {
-    let sema:dispatch_semaphore_t
+    public class DispatchLoopSemaphore : SemaphoreType {
+        let sema:dispatch_semaphore_t
 
-    public required convenience init() {
-        self.init(value: 0)
-    }
+        public required convenience init() {
+            self.init(value: 0)
+        }
 
-    public required init(value: Int) {
-        self.sema = dispatch_semaphore_create(value)
-    }
+        public required init(value: Int) {
+            self.sema = dispatch_semaphore_create(value)
+        }
 
-    public func wait() -> Bool {
-        return dispatch_semaphore_wait(sema, DISPATCH_TIME_FOREVER) == 0
-    }
+        public func wait() -> Bool {
+            return dispatch_semaphore_wait(sema, DISPATCH_TIME_FOREVER) == 0
+        }
 
-    public func wait(until:NSDate?) -> Bool {
-        let timeout = until?.timeIntervalSinceNow
-        return wait(timeout)
-    }
+        public func wait(until:NSDate?) -> Bool {
+            let timeout = until?.timeIntervalSinceNow
+            return wait(timeout)
+        }
 
-    public func wait(timeout: Double?) -> Bool {
-        guard let timeout = timeout else {
-            return wait()
+        public func wait(timeout: Double?) -> Bool {
+            guard let timeout = timeout else {
+                return wait()
+            }
+            let time = dispatch_time(DISPATCH_TIME_NOW, Int64(timeout * NSTimeInterval(NSEC_PER_SEC)))
+            let result = dispatch_semaphore_wait(sema, time)
+            return result == 0
         }
-        let time = dispatch_time(DISPATCH_TIME_NOW, Int64(timeout * NSTimeInterval(NSEC_PER_SEC)))
-        let result = dispatch_semaphore_wait(sema, time)
-        return result == 0
-    }
 
-    public func signal() -> Int {
-        return dispatch_semaphore_signal(sema)
+        public func signal() -> Int {
+            return dispatch_semaphore_signal(sema)
+        }
     }
-}
+#endif
 
 extension Optional {
     func getOrElse(@autoclosure f:()->Wrapped) -> Wrapped {
@@ -105,7 +107,7 @@ public class CFRunLoopSemaphore : SemaphoreType {
         while value <= 0 {
             while !self.signaled && !timedout {
                 RunLoop.runUntilOnce(RunLoop.defaultMode, until: until)
-                timedout = !until.isGreaterThan(NSDate())
+                timedout = until.timeIntervalSinceNow <= 0
             }
             if timedout {
                 break
@@ -126,4 +128,4 @@ public class CFRunLoopSemaphore : SemaphoreType {
     }
 }
 
-public typealias LoopSemaphore = CFRunLoopSemaphore
+public typealias LoopSemaphore = CFRunLoopSemaphore

ExecutionContext/PThreadExecutionContext.swift

@@ -94,23 +94,28 @@
             return try syncThroughAsync(task)
         }
     }
+
+    // This class is workaround around retain cycle in pthread run loop creation. See below in init(). Stupid ARC :(
+    private class RunLoopHolder {
+        var loop: RunLoop? = nil
+    }
 
     private class SerialContext : ExecutionContextBase, ExecutionContextType {
         private let rl:RunLoop
 
         override init() {
-            var runLoop:AnyObject?
+            let holder = RunLoopHolder()
             let sema = Semaphore()
 
-            PThread(task: {
-                runLoop = RunLoop.currentCFRunLoop()
+            PThread(task: { [unowned holder] in
+                holder.loop = RunLoop.currentRunLoop()
                 sema.signal()
                 RunLoop.run()
             }).start()
 
             sema.wait()
 
-            self.rl = RunLoop(runLoop!)
+            self.rl = holder.loop!
         }
 
         init(runLoop:RunLoop) {

ExecutionContext/RunLoop.swift

@@ -148,9 +148,9 @@ import CoreFoundation
         func signal() {
             if _source != nil {
                 CFRunLoopSourceSignal(_source)
-                for loop in info.runLoops {
-                    loop.wakeUp()
-                }
+            }
+            for loop in info.runLoops {
+                loop.wakeUp()
             }
         }
 	}
@@ -265,10 +265,6 @@ import CoreFoundation
 		static func mainRunLoop() -> RunLoop {
 			return MainRunLoop
 		}
-        
-        static func currentCFRunLoop() -> AnyObject {
-            return CFRunLoopGetCurrent()
-        }
 
 		func isCurrent() -> Bool {
 			return cfRunLoop === CFRunLoopGetCurrent()
@@ -322,7 +318,7 @@ import CoreFoundation
                 }
                 wakeUp()
             }
-		}
+        }
 
 		func addDelay(rld: RunLoopDelay, mode: NSString) {
             let crld = unsafeBitCast(rld.cfObject, CFRunLoopTimer.self)

Tests/ExecutionContext/ExecutionContextTests.swift

@@ -32,7 +32,7 @@ class ExecutionContextTests: XCTestCase {
             expectation.fulfill()
         }
 
-        self.waitForExpectationsWithTimeout(1, handler: nil)
+        self.waitForExpectationsWithTimeout(0, handler: nil)
     }
 
     func asyncTest(context:ExecutionContextType) {