 	/// when the signal terminates.
 	private var generatorDisposable: Disposable?
 
-	/// The status of the signal.
-	///
- 	/// `status` synchronizes using Read-Copy-Update. Reads are thus wait-free,
- 	/// but writes are required not to mutate in place. This suits `Signal` as
- 	/// reads to `status` happens on the critical path of event delivery, while
- 	/// adding and removing observers or termination generally has a constant
-	/// occurrence.
-	private var status: SignalStatus<Value, Error>
-
-	/// Used to ensure that status updates are serialized.
-	private let statusLock: NSLock
+	/// The state of the signal.
+	///
+ 	/// `state` synchronizes using Read-Copy-Update. Reads on the event delivery
+	/// routine are thus wait-free. But modifications, e.g. inserting observers,
+	/// still have to be serialized, and are required not to mutate in place.
+	///
+	/// This suits `Signal` as reads to `status` happens on the critical path of
+	/// event delivery, while observers bag manipulation or termination generally
+	/// has a constant occurrence.
+	///
+	/// 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).
+	private var state: SignalState<Value, Error>
+
+	/// Used to ensure that state updates are serialized.
+	private let stateLock: NSLock
 
 	/// Used to ensure that events are serialized during delivery to observers.
 	private let sendLock: NSLock

				// occur while the `sendLock` is acquired, the observer call-out and
				// the disposal would be delegated to the current sender, or
				// occasionally one of the senders waiting on `sendLock`.
				signal.statusLock.lock()

				if case let .alive(state) = signal.status {
					// Updates to `status` are implicitly synchronized against `sendLock`.
					// So we do not need to guard it with an explicit lock.
					//
					// Specifically, senders are serialized by `sendLock`, and can react
					// to and bump the status to `terminated` only after they see the
					// status being `terminating`.
					//
					// `terminating` can happen only once in the lifetime of a `Signal`,
					// since `state` being swapped with `nil` is a point of no return.
					//
					// Even in the case that both a previous sender and its successor see
					// `terminating`, the senders are still bound to the `sendLock`. So
					// whichever sender loses the battle of acquring `sendLock` is
					// guaranteed to see a status of `terminated`, and eventually be
					// blocked.
					signal.status = .terminating(SignalState(observers: state.observers,
					                                         retaining: state.retaining,
					                                         associatedStorage: event))
					signal.statusLock.unlock()

					if signal.sendLock.try() {
						// Acquire `statusLock`. If the termination has still not yet been
						// handled, take it over and bump the status to `terminated`.
						signal.statusLock.lock()

						if case let .terminating(state) = signal.status {
							signal.status = .terminated
							signal.statusLock.unlock()

							state.sendTerminated()
						} else {
							signal.statusLock.unlock()
						}

						signal.sendLock.unlock()
						signal.swapDisposable()?.dispose()
					}
				} else {
					signal.statusLock.unlock()
				}
			} else {
				var shouldDispose = false

				// concurrent termination event that has not been caught in the main
				// protected section.
				//
				// Note that as the check happens before acquiring `stateLock`, it
				// could be a false positive, and thus a second check after the lock is
				// acquired is mandatory.
				if !shouldDispose, case .terminating = signal.state {
					signal.sendLock.lock()

					// Acquire `stateLock`. If the termination has still not yet been
					// handled, take it over and bump the status to `terminated`.
					signal.stateLock.lock()

					if case let .terminating(snapshot) = signal.state {
						signal.state = .terminated
						signal.stateLock.unlock()

						snapshot.sendTerminated()
						shouldDispose = true
					} else {
						signal.stateLock.unlock()
					}

					signal.sendLock.unlock()
