Allow all termination events to be recursively sent. #137

andersio · 2016-11-30T06:02:44Z

Fixes #135 and #136.

As described in #136, and demonstrated by the test case:

A strong release atomically drops the refCount to 0. But deinitialization does not start right away.

A weak retain - the binding's observer closure in this case - manages to increment the refCount before the strong release flags the object as deallocating.

The deinitialization is thus delayed until exiting the scope of the observer closure, i.e. within the sendLock.

In the context of binding:

signal
    .take(during: target.lifetime)
    .observeValues { [weak target] value in
        target?.consume(value)
    }

             Thread 1             |            Thread 2            
----------------------------------|--------------------------------
  1. Received new `value` event.  |
                                  |
  2. Acquired `sendLock`.         |
                                  |
                                  | 3. `swift_release` on `target`.
                                  |    Decrement refCount to 0.
  4. `swift_weakLoadStrong`       |
     on `target`.                 |
     Increment refCount to 1.     |
                                  |     
  5a. Invoke `consume`.           | 5b. CAS to mark deallocating
                                  |     flag failed
                                  |
  6. `swift_release`              | (Deinit of `target` is supposed
     Decrement refCount to 0.     |  to run on this thread, but
                                  |  Thread 1 has stolen it due to
  7. CAS to mark deallocating     |  the weak retain having won the
     Flag succeeded.              |  race.)
                                  |
  8. `target` starts deinit.      |
     `Lifetime.init` sends        |
     `completed`.                 |
                                  |
  9. Upstream `take(until:)`      |
     gets `completed`, and forward|
     it to the downstream.        |
                                  |
  10. Try to acquire `sendLock`,  |
      but it is held by (2).      |
      Deadlock.                   |

So the only solution - except using a recursive lock or going asynchronous - is to handle completed like interrupted. failed do not need this behavior (yet?), but it is more convenient to implement it for all termination events. Can be reverted if this feels an unpleasant change.

andersio · 2016-11-30T07:07:55Z

~~It is probably missing a memory barrier for it to work on ARMv8. Gonna run tests on an iPhone to ensure things are right.~~

andersio · 2016-11-30T19:04:10Z

The takeaway is that up till now Swift has no memory model. So whatever synchronization we do, including pthread_mutex_*, is depending on the undefined behavior of the compiler. Well, unless the entire routine from acquiring to releasing the lock is written in C/C++, e.g. libdispatch.

~~(┛✧Д✧))┛彡┻━┻~~

~~Though in practice, the Swift compiler does not appear to reorder stuff against C function calls, and more importantly consecutive writes under -Owholemodule.~~

The rant above was a note on the previous attempt with explicit memory fences between terminationEvent and terminationState.

In the latest commit 4ea7537, these variables are packed as an immutable object before being assigned to terminationState. The states in this form are this easier to deal with in the threading design, since it is just an 8-byte reference that can now be atomically synchronized against sendLock.

If it was unpacked, acquire/release fences and trust in compiler (see the rant) would be critical to ensure terminationEvent is always written before terminationState at runtime, so that concurrent readers would see both values together.

NachoSoto · 2016-12-01T15:31:24Z

Tests/ReactiveSwiftTests/PropertySpec.swift

@@ -265,6 +265,39 @@ class PropertySpec: QuickSpec {
 				property = nil
 				expect(isEnded) == true
 			}
+
+			it("should not deadlock") {


sharplet · 2016-12-01T15:34:59Z

Sources/Signal.swift

 				// the disposal would be delegated to the current sender, or
 				// occasionally one of the senders waiting on `sendLock`.
 				if let state = signal.state.swap(nil) {
-					// Writes to `interruptedState` are implicitly synchronized. So we do
+					terminationState = SignalTerminationState(state: state,
+					                                          event: event)


Does this really need to be wrapped onto a new line?

sharplet · 2016-12-01T15:36:12Z

Sources/Signal.swift

+				//
+				// `interrupted`
+				// It is kind of a special snowflake, as it can inadvertently be sent by
+				// downstream consumers as part of the `SignalProducer` mechanics.


I think we can reword this without the "special snowflake" comment now.

andersio · 2016-12-01T16:46:42Z

It seems the Swift compiler in Linux has started to impose some resilience rules.

andersio · 2016-12-01T23:58:28Z

In 1a3cb92:

Two pieces of mutable states now become one. Swift enum is amazing. 🍰
Having states as stored properties seems a little bit faster, probably due to locality and/or less ARC calls.

Might need a little bikeshedding on the naming of the enum cases though. ~~Or maybe we should name the enum Signal🚦 (Signal.🚦 in 3.1)` instead, since Swift is an opinionated emoji language, uhuh?~~ 👻

mdiep · 2016-12-02T13:07:23Z

Sources/Signal.swift

+	case yellow(SignalTerminationSnapshot<Value, Error>)
+
+	/// The `Signal` has terminated.
+	case red


Would alive/terminating/terminated make more sense here?

mdiep · 2016-12-02T13:14:07Z

Sources/Signal.swift

+	private var status: SignalStatus<Value, Error>
+
+	/// Used to ensure that events are serialized during delivery to observers.
+	private let sendLock: NSLock


This looks like it could remain inside the init.

Having states as stored properties seems a little bit faster, probably due to improved locality and/or less ARC calls.

Edit: The difference is consistently ranging from 0% (property binding) to 9% (Signal synthetic) worse for different test cases in my benchmark runs.

mdiep · 2016-12-02T13:15:20Z

Sources/Signal.swift

+		// The generator disposable needs to be disposed of only if a `green` status
+		// is observed here, since `red` would mean it has already been disposed of,
+		// and `yellow` is impossible to be observed here.
+		if case .green = status {


This looks like it could still use the state.swap(nil), in which case status could remain part of the init.

It is now swapped out before disposal in 63a7e0d, so no check is needed.

andersio · 2016-12-05T02:18:01Z

Just in case these would be missed:

On Read-Copy-Update and the atomicity of reads to Signal.state.
#137 (comment)

On SignalState being laid out as a tagged pointer.
#137 (comment)

On why the wrapping of SignalState helps.
#137 (comment)

andersio · 2016-12-05T05:20:30Z

I have refactored the code a bit. Hope it helps the code explaining itself.

liscio · 2016-12-05T13:49:15Z

Tests/ReactiveSwiftTests/PropertySpec.swift

+				let queue: DispatchQueue
+
+				if #available(macOS 10.10, *) {
+					queue = DispatchQueue.global(qos: .userInitiated)


I think that if you want to match "high priority" you should consider using the .userInteractive QoS instead. Doubt it really matters in a synthetic benchmark/test like this, but the asymmetry stood out to me. :)

mdiep · 2016-12-05T13:40:43Z

Sources/Signal.swift

+			//
+			//   `updateLock` must be acquired.
+			//
+			// - Transit from `alive` to `terminating`.


s/Transit/Transition/

I guess this needs a rename too, hmm?
https://github.com/ReactiveCocoa/ReactiveSwift/blob/master/Sources/Atomic.swift#L27

mdiep · 2016-12-05T13:41:07Z

Sources/Signal.swift

+			//   `updateLock` must be acquired.
+			//
+			// - Extract the snapshot of a terminating signal to deliver the
+			//   termination event, and transit from `terminating` to `terminated`.


s/transit/transition/

mdiep · 2016-12-05T14:01:42Z

Sources/Signal.swift

+	/// observers.
+	fileprivate let retaining: Signal<Value, Error>?
+
+	fileprivate let associated: U


Could we split SignalStateSnapshot into 2 different classes?

private enum SignalState<Value, Error: Swift.Error> { case alive(AliveState) case terminating(TerminatingState) case terminated } private final class AliveState { let observers: Bag<Signal<Value, Error>.Observer> let retaining: Signal<Value, Error>? } private final class TerminatingState { let observers: Bag<Signal<Value, Error>.Observer> let event: Event<Value, Error> }

AFAICS the terminating state doesn't need retaining and the alive state definitely doesn't need event. This would simplify things a bit, I think.

mdiep · 2016-12-05T14:06:49Z

Sources/Signal.swift

+	///
+	/// - returns:
+	///   The state snapshot associated with a termination event, or `nil`.
+	private func shouldReallyTerminate() -> SignalStateSnapshot<Value, Error, Event<Value, Error>>? {


This function is only used like this:

if let snapshot = signal.shouldReallyTerminate() { for observer in snapshot.observers { observer.action(snapshot.associated) } }

That suggests that the code to notify observers should move into this function.

It probably also makes more sense as a block in init since it's only used there.

mdiep · 2016-12-05T14:10:52Z

Sources/Signal.swift

+	/// - note: The `updateLock` would be acquired.
+	///
+	/// - returns:
+	///   The state snapshot associated with a termination event, or `nil`.


Can you format the - returns: to match the existing ones?

- returns: The stat snapshot associated…

…t case.

andersio · 2016-12-06T13:02:34Z

Sources/Signal.swift

+/// all reference counted, and at most one no-payload case.
+private enum SignalState<Value, Error: Swift.Error> {
+	/// The `Signal` is alive.
+	case alive(AliveState<Value, Error>)


These should be less confusing once we have them nested in Swift 3.1, e.g. Signal<U, E>.State.Alive.

mdiep · 2016-12-06T20:43:27Z

It looks like this comment was missed. Can you take a look at that?

I'm starting to like the way this looks. ✨

andersio · 2016-12-06T20:57:57Z

Addressed in ~~5686227~~ b55fe6a. ☕️

mdiep · 2016-12-07T13:54:45Z

Sources/Signal.swift

+	///
+	/// As `SignalState` is a packed object reference (a tagged pointer) that is
+	/// naturally aligned, reads to are guaranteed to be atomic on all supported
+	/// hardware architectures of Swift (ARM and x86).


Do we know that this holds true for Linux as well?

The Swift ABI defines this, regardless of OSes. You would always have the lowest 2 bits available for packing on 32-bit platforms anyway, due to the 4-byte minimum alignment.

2 bits are enough for 4 with-reference cases, or 3 with-reference cases plus 2^30 ~~(or 2^30? not quite sure)~~ no-payload cases.

mdiep · 2016-12-07T13:58:01Z

This looks good to me. But since it's a very critical section of code, I'd like to get another set of eyes on it.

mdiep · 2016-12-15T01:37:35Z

Doesn't look like we'll get another review, so let's 🚢.

andersio added 2 commits November 30, 2016 01:18

Failing Test Case: Delayed Lifetime deinit deadlocking sendLock.

2d239c5

Fix #135: Allow all termination events to be recursively sent.

753fed3

andersio force-pushed the deinit-race-fix branch from 27588c4 to d034d0a Compare November 30, 2016 19:01

andersio force-pushed the deinit-race-fix branch 3 times, most recently from 610deed to 753fed3 Compare November 30, 2016 19:55

Pack the termination state to avoid explicit memory fences.

4ea7537

NachoSoto reviewed Dec 1, 2016

View reviewed changes

sharplet reviewed Dec 1, 2016

View reviewed changes

andersio force-pushed the deinit-race-fix branch from 2cd5725 to 096faaf Compare December 1, 2016 16:45

andersio force-pushed the deinit-race-fix branch from 096faaf to db9992b Compare December 1, 2016 18:46

andersio mentioned this pull request Dec 1, 2016

Signal lock elision. #129

Closed

andersio added 2 commits December 1, 2016 23:42

Fix the Linux build.

0306552

Minor formatting and documentation changes in Signal.init.

2bb7d7a

andersio force-pushed the deinit-race-fix branch 3 times, most recently from d47e3c9 to 60bbd0c Compare December 1, 2016 23:53

andersio force-pushed the deinit-race-fix branch from 60bbd0c to 8805029 Compare December 1, 2016 23:59

Introduced SignalStatus. sendLock is now stored by the class.

1a3cb92

andersio force-pushed the deinit-race-fix branch from 8805029 to 1a3cb92 Compare December 2, 2016 00:31

mdiep added this to the 1.0 milestone Dec 2, 2016

mdiep requested changes Dec 2, 2016

View reviewed changes

andersio added 2 commits December 2, 2016 17:08

Swap the generator disposable before disposing of it.

63a7e0d

Renamed SignalStatus enum cases.

dd993ba

andersio added the bug label Dec 3, 2016

andersio force-pushed the deinit-race-fix branch 3 times, most recently from 5bde9ce to 240b71b Compare December 5, 2016 01:58

Removed the behaviors of SignalStateSnapshot.

9562768

andersio force-pushed the deinit-race-fix branch from 240b71b to 9562768 Compare December 5, 2016 02:01

Refactored the signal termination logic for improved clarity.

6f630c0

andersio force-pushed the deinit-race-fix branch from b339adf to 6f630c0 Compare December 5, 2016 05:33

liscio reviewed Dec 5, 2016

View reviewed changes

mdiep requested changes Dec 5, 2016

View reviewed changes

andersio added 4 commits December 5, 2016 16:07

Break SignalStateSnapshot into AliveState and TerminatingState.

dfcd33a

Move shouldReallyTerminate into Signal.init.

2bbebc0

Match Dispatch Queue priority and QoS in the recursive completion tes…

06b731d

…t case.

Documentation proof-reading in Signal.

85f41d5

andersio force-pushed the deinit-race-fix branch from a515108 to 85f41d5 Compare December 5, 2016 15:34

andersio commented Dec 6, 2016

View reviewed changes

andersio force-pushed the deinit-race-fix branch from 752c717 to 5686227 Compare December 6, 2016 20:57

Further streamlined the signal termination logic.

b55fe6a

andersio force-pushed the deinit-race-fix branch from 5686227 to b55fe6a Compare December 6, 2016 21:58

mdiep approved these changes Dec 7, 2016

View reviewed changes

mdiep requested a review from NachoSoto December 8, 2016 02:08

andersio mentioned this pull request Dec 14, 2016

Proposal: Label the output and input ends of Signal.pipe() #153

Merged

mdiep merged commit 0f2fc54 into master Dec 15, 2016

mdiep deleted the deinit-race-fix branch December 15, 2016 01:37

andersio mentioned this pull request Apr 25, 2017

[Gardening] Use a manual allocation for Signal.state. #350

Closed

Provide feedback

Saved searches

Use saved searches to filter your results more quickly

Allow all termination events to be recursively sent. #137

Allow all termination events to be recursively sent. #137

andersio commented Nov 30, 2016 •

edited

Loading

andersio commented Nov 30, 2016 •

edited

Loading

andersio commented Nov 30, 2016 •

edited

Loading

NachoSoto Dec 1, 2016

sharplet Dec 1, 2016

andersio Dec 1, 2016

sharplet Dec 1, 2016

andersio commented Dec 1, 2016

andersio commented Dec 1, 2016 •

edited

Loading

mdiep Dec 2, 2016

andersio Dec 2, 2016

mdiep Dec 2, 2016

andersio Dec 2, 2016 •

edited

Loading

mdiep Dec 2, 2016

andersio Dec 2, 2016 •

edited

Loading

andersio Dec 2, 2016

andersio commented Dec 5, 2016

andersio commented Dec 5, 2016

liscio Dec 5, 2016 •

edited

Loading

mdiep Dec 5, 2016

andersio Dec 5, 2016

mdiep Dec 5, 2016

mdiep Dec 5, 2016

mdiep Dec 5, 2016

mdiep Dec 5, 2016

mdiep Dec 5, 2016

andersio Dec 6, 2016 •

edited

Loading

mdiep commented Dec 6, 2016

andersio commented Dec 6, 2016 •

edited

Loading

mdiep Dec 7, 2016

andersio Dec 7, 2016 •

edited

Loading

andersio Dec 7, 2016 •

edited

Loading

mdiep commented Dec 7, 2016

mdiep commented Dec 15, 2016

Allow all termination events to be recursively sent. #137

Allow all termination events to be recursively sent. #137

Conversation

andersio commented Nov 30, 2016 • edited Loading

andersio commented Nov 30, 2016 • edited Loading

andersio commented Nov 30, 2016 • edited Loading

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

andersio commented Dec 1, 2016

andersio commented Dec 1, 2016 • edited Loading

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

andersio Dec 2, 2016 • edited Loading

Choose a reason for hiding this comment

Choose a reason for hiding this comment

andersio Dec 2, 2016 • edited Loading

Choose a reason for hiding this comment

Choose a reason for hiding this comment

andersio commented Dec 5, 2016

andersio commented Dec 5, 2016

liscio Dec 5, 2016 • edited Loading

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

andersio Dec 6, 2016 • edited Loading

Choose a reason for hiding this comment

mdiep commented Dec 6, 2016

andersio commented Dec 6, 2016 • edited Loading

Choose a reason for hiding this comment

andersio Dec 7, 2016 • edited Loading

Choose a reason for hiding this comment

andersio Dec 7, 2016 • edited Loading

Choose a reason for hiding this comment

mdiep commented Dec 7, 2016

mdiep commented Dec 15, 2016

andersio commented Nov 30, 2016 •

edited

Loading

andersio commented Nov 30, 2016 •

edited

Loading

andersio commented Nov 30, 2016 •

edited

Loading

andersio commented Dec 1, 2016 •

edited

Loading

andersio Dec 2, 2016 •

edited

Loading

andersio Dec 2, 2016 •

edited

Loading

liscio Dec 5, 2016 •

edited

Loading

andersio Dec 6, 2016 •

edited

Loading

andersio commented Dec 6, 2016 •

edited

Loading

andersio Dec 7, 2016 •

edited

Loading

andersio Dec 7, 2016 •

edited

Loading