Fix potential deadlocks when resuming a continuation while holding a lock (#303)

* Fix potential deadlocks in zip

* Fix debounce

* Fix combineLatest

* Fix Channel

* Fix buffer
This commit is contained in:
Franz Busch authored and GitHub committed 2023-11-17 16:20:14 +00:00
1 parent 5bbdcc1d37
commit da4e36f865
6 files changed
+550 -473

No files matched your search

@@ -18,34 +18,47 @@ final class BoundedBufferStorage<Base: AsyncSequence>: Sendable where Base: Send
func next() async -> Result<Base.Element, Error>? {
return await withTaskCancellationHandler {
let (shouldSuspend, result) = self.stateMachine.withCriticalRegion { stateMachine -> (Bool, Result<Base.Element, Error>?) in
let action: BoundedBufferStateMachine<Base>.NextAction? = self.stateMachine.withCriticalRegion { stateMachine in
let action = stateMachine.next()
switch action {
case .startTask(let base):
self.startTask(stateMachine: &stateMachine, base: base)
return (true, nil)
return nil
case .suspend:
return (true, nil)
case .returnResult(let producerContinuation, let result):
producerContinuation?.resume()
return (false, result)
return action
case .returnResult:
return action
}
}
if !shouldSuspend {
return result
switch action {
case .startTask:
// We are handling the startTask in the lock already because we want to avoid
// other inputs interleaving while starting the task
fatalError("Internal inconsistency")
case .suspend:
break
case .returnResult(let producerContinuation, let result):
producerContinuation?.resume()
return result
case .none:
break
}
return await withUnsafeContinuation { (continuation: UnsafeContinuation<Result<Base.Element, Error>?, Never>) in
self.stateMachine.withCriticalRegion { stateMachine in
let action = stateMachine.nextSuspended(continuation: continuation)
switch action {
case .none:
break
case .returnResult(let producerContinuation, let result):
producerContinuation?.resume()
continuation.resume(returning: result)
}
let action = self.stateMachine.withCriticalRegion { stateMachine in
stateMachine.nextSuspended(continuation: continuation)
}
switch action {
case .none:
break
case .returnResult(let producerContinuation, let result):
producerContinuation?.resume()
continuation.resume(returning: result)
}
}
} onCancel: {
@@ -68,15 +81,15 @@ final class BoundedBufferStorage<Base: AsyncSequence>: Sendable where Base: Send
if shouldSuspend {
await withUnsafeContinuation { (continuation: UnsafeContinuation<Void, Never>) in
self.stateMachine.withCriticalRegion { stateMachine in
let action = stateMachine.producerSuspended(continuation: continuation)
let action = self.stateMachine.withCriticalRegion { stateMachine in
stateMachine.producerSuspended(continuation: continuation)
}
switch action {
case .none:
break
case .resumeProducer:
continuation.resume()
}
switch action {
case .none:
break
case .resumeProducer:
continuation.resume()
}
}
}
@@ -86,35 +99,35 @@ final class BoundedBufferStorage<Base: AsyncSequence>: Sendable where Base: Send
break loop
}
self.stateMachine.withCriticalRegion { stateMachine in
let action = stateMachine.elementProduced(element: element)
switch action {
case .none:
break
case .resumeConsumer(let continuation, let result):
continuation.resume(returning: result)
}
let action = self.stateMachine.withCriticalRegion { stateMachine in
stateMachine.elementProduced(element: element)
}
switch action {
case .none:
break
case .resumeConsumer(let continuation, let result):
continuation.resume(returning: result)
}
}
self.stateMachine.withCriticalRegion { stateMachine in
let action = stateMachine.finish(error: nil)
switch action {
case .none:
break
case .resumeConsumer(let continuation):
continuation?.resume(returning: nil)
}
let action = self.stateMachine.withCriticalRegion { stateMachine in
stateMachine.finish(error: nil)
}
switch action {
case .none:
break
case .resumeConsumer(let continuation):
continuation?.resume(returning: nil)
}
} catch {
self.stateMachine.withCriticalRegion { stateMachine in
let action = stateMachine.finish(error: error)
switch action {
case .none:
break
case .resumeConsumer(let continuation):
continuation?.resume(returning: .failure(error))
}
let action = self.stateMachine.withCriticalRegion { stateMachine in
stateMachine.finish(error: error)
}
switch action {
case .none:
break
case .resumeConsumer(let continuation):
continuation?.resume(returning: .failure(error))
}
}
}
@@ -123,16 +136,16 @@ final class BoundedBufferStorage<Base: AsyncSequence>: Sendable where Base: Send
}
func interrupted() {
self.stateMachine.withCriticalRegion { stateMachine in
let action = stateMachine.interrupted()
switch action {
case .none:
break
case .resumeProducerAndConsumer(let task, let producerContinuation, let consumerContinuation):
task.cancel()
producerContinuation?.resume()
consumerContinuation?.resume(returning: nil)
}
let action = self.stateMachine.withCriticalRegion { stateMachine in
stateMachine.interrupted()
}
switch action {
case .none:
break
case .resumeProducerAndConsumer(let task, let producerContinuation, let consumerContinuation):
task.cancel()
producerContinuation?.resume()
consumerContinuation?.resume(returning: nil)
}
}
@@ -19,32 +19,41 @@ final class UnboundedBufferStorage<Base: AsyncSequence>: Sendable where Base: Se
func next() async -> Result<Base.Element, Error>? {
return await withTaskCancellationHandler {
let (shouldSuspend, result) = self.stateMachine.withCriticalRegion { stateMachine -> (Bool, Result<Base.Element, Error>?) in
let action: UnboundedBufferStateMachine<Base>.NextAction? = self.stateMachine.withCriticalRegion { stateMachine in
let action = stateMachine.next()
switch action {
case .startTask(let base):
self.startTask(stateMachine: &stateMachine, base: base)
return (true, nil)
return nil
case .suspend:
return (true, nil)
case .returnResult(let result):
return (false, result)
return action
case .returnResult:
return action
}
}
if !shouldSuspend {
return result
switch action {
case .startTask:
// We are handling the startTask in the lock already because we want to avoid
// other inputs interleaving while starting the task
fatalError("Internal inconsistency")
case .suspend:
break
case .returnResult(let result):
return result
case .none:
break
}
return await withUnsafeContinuation { (continuation: UnsafeContinuation<Result<Base.Element, Error>?, Never>) in
self.stateMachine.withCriticalRegion { stateMachine in
let action = stateMachine.nextSuspended(continuation: continuation)
switch action {
case .none:
break
case .resumeConsumer(let result):
continuation.resume(returning: result)
}
let action = self.stateMachine.withCriticalRegion { stateMachine in
stateMachine.nextSuspended(continuation: continuation)
}
switch action {
case .none:
break
case .resumeConsumer(let result):
continuation.resume(returning: result)
}
}
} onCancel: {
@@ -59,35 +68,35 @@ final class UnboundedBufferStorage<Base: AsyncSequence>: Sendable where Base: Se
let task = Task {
do {
for try await element in base {
self.stateMachine.withCriticalRegion { stateMachine in
let action = stateMachine.elementProduced(element: element)
switch action {
case .none:
break
case .resumeConsumer(let continuation, let result):
continuation.resume(returning: result)
}
let action = self.stateMachine.withCriticalRegion { stateMachine in
stateMachine.elementProduced(element: element)
}
switch action {
case .none:
break
case .resumeConsumer(let continuation, let result):
continuation.resume(returning: result)
}
}
self.stateMachine.withCriticalRegion { stateMachine in
let action = stateMachine.finish(error: nil)
switch action {
case .none:
break
case .resumeConsumer(let continuation):
continuation?.resume(returning: nil)
}
let action = self.stateMachine.withCriticalRegion { stateMachine in
stateMachine.finish(error: nil)
}
switch action {
case .none:
break
case .resumeConsumer(let continuation):
continuation?.resume(returning: nil)
}
} catch {
self.stateMachine.withCriticalRegion { stateMachine in
let action = stateMachine.finish(error: error)
switch action {
case .none:
break
case .resumeConsumer(let continuation):
continuation?.resume(returning: .failure(error))
}
let action = self.stateMachine.withCriticalRegion { stateMachine in
stateMachine.finish(error: error)
}
switch action {
case .none:
break
case .resumeConsumer(let continuation):
continuation?.resume(returning: .failure(error))
}
}
}
@@ -96,15 +105,15 @@ final class UnboundedBufferStorage<Base: AsyncSequence>: Sendable where Base: Se
}
func interrupted() {
self.stateMachine.withCriticalRegion { stateMachine in
let action = stateMachine.interrupted()
switch action {
case .none:
break
case .resumeConsumer(let task, let continuation):
task.cancel()
continuation?.resume(returning: nil)
}
let action = self.stateMachine.withCriticalRegion { stateMachine in
stateMachine.interrupted()
}
switch action {
case .none:
break
case .resumeConsumer(let task, let continuation):
task.cancel()
continuation?.resume(returning: nil)
}
}
@@ -25,21 +25,17 @@ struct ChannelStorage<Element: Sendable, Failure: Error>: Sendable {
func send(element: Element) async {
// check if a suspension is needed
let shouldExit = self.stateMachine.withCriticalRegion { stateMachine -> Bool in
let action = stateMachine.send()
switch action {
case .suspend:
// the element has not been delivered because no consumer available, we must suspend
return false
case .resumeConsumer(let continuation):
continuation?.resume(returning: element)
return true
}
let action = self.stateMachine.withCriticalRegion { stateMachine in
stateMachine.send()
}
if shouldExit {
return
switch action {
case .suspend:
break
case .resumeConsumer(let continuation):
continuation?.resume(returning: element)
return
}
let producerID = self.generateId()
@@ -47,103 +43,100 @@ struct ChannelStorage<Element: Sendable, Failure: Error>: Sendable {
await withTaskCancellationHandler {
// a suspension is needed
await withUnsafeContinuation { (continuation: UnsafeContinuation<Void, Never>) in
self.stateMachine.withCriticalRegion { stateMachine in
let action = stateMachine.sendSuspended(continuation: continuation, element: element, producerID: producerID)
switch action {
case .none:
break
case .resumeProducer:
continuation.resume()
case .resumeProducerAndConsumer(let consumerContinuation):
continuation.resume()
consumerContinuation?.resume(returning: element)
}
let action = self.stateMachine.withCriticalRegion { stateMachine in
stateMachine.sendSuspended(continuation: continuation, element: element, producerID: producerID)
}
}
} onCancel: {
self.stateMachine.withCriticalRegion { stateMachine in
let action = stateMachine.sendCancelled(producerID: producerID)
switch action {
case .none:
break
case .resumeProducer(let continuation):
continuation?.resume()
case .resumeProducer:
continuation.resume()
case .resumeProducerAndConsumer(let consumerContinuation):
continuation.resume()
consumerContinuation?.resume(returning: element)
}
}
} onCancel: {
let action = self.stateMachine.withCriticalRegion { stateMachine in
stateMachine.sendCancelled(producerID: producerID)
}
switch action {
case .none:
break
case .resumeProducer(let continuation):
continuation?.resume()
}
}
}
func finish(error: Failure? = nil) {
self.stateMachine.withCriticalRegion { stateMachine in
let action = stateMachine.finish(error: error)
let action = self.stateMachine.withCriticalRegion { stateMachine in
stateMachine.finish(error: error)
}
switch action {
case .none:
break
case .resumeProducersAndConsumers(let producerContinuations, let consumerContinuations):
producerContinuations.forEach { $0?.resume() }
if let error {
consumerContinuations.forEach { $0?.resume(throwing: error) }
} else {
consumerContinuations.forEach { $0?.resume(returning: nil) }
}
}
switch action {
case .none:
break
case .resumeProducersAndConsumers(let producerContinuations, let consumerContinuations):
producerContinuations.forEach { $0?.resume() }
if let error {
consumerContinuations.forEach { $0?.resume(throwing: error) }
} else {
consumerContinuations.forEach { $0?.resume(returning: nil) }
}
}
}
func next() async throws -> Element? {
let (shouldExit, result) = self.stateMachine.withCriticalRegion { stateMachine -> (Bool, Result<Element?, Error>?) in
let action = stateMachine.next()
switch action {
case .suspend:
return (false, nil)
case .resumeProducer(let producerContinuation, let result):
producerContinuation?.resume()
return (true, result)
}
let action = self.stateMachine.withCriticalRegion { stateMachine in
stateMachine.next()
}
if shouldExit {
return try result?._rethrowGet()
switch action {
case .suspend:
break
case .resumeProducer(let producerContinuation, let result):
producerContinuation?.resume()
return try result._rethrowGet()
}
let consumerID = self.generateId()
return try await withTaskCancellationHandler {
try await withUnsafeThrowingContinuation { (continuation: UnsafeContinuation<Element?, any Error>) in
self.stateMachine.withCriticalRegion { stateMachine in
let action = stateMachine.nextSuspended(
let action = self.stateMachine.withCriticalRegion { stateMachine in
stateMachine.nextSuspended(
continuation: continuation,
consumerID: consumerID
)
switch action {
case .none:
break
case .resumeConsumer(let element):
continuation.resume(returning: element)
case .resumeConsumerWithError(let error):
continuation.resume(throwing: error)
case .resumeProducerAndConsumer(let producerContinuation, let element):
producerContinuation?.resume()
continuation.resume(returning: element)
}
}
}
} onCancel: {
self.stateMachine.withCriticalRegion { stateMachine in
let action = stateMachine.nextCancelled(consumerID: consumerID)
switch action {
case .none:
break
case .resumeConsumer(let continuation):
continuation?.resume(returning: nil)
case .resumeConsumer(let element):
continuation.resume(returning: element)
case .resumeConsumerWithError(let error):
continuation.resume(throwing: error)
case .resumeProducerAndConsumer(let producerContinuation, let element):
producerContinuation?.resume()
continuation.resume(returning: element)
}
}
} onCancel: {
let action = self.stateMachine.withCriticalRegion { stateMachine in
stateMachine.nextCancelled(consumerID: consumerID)
}
switch action {
case .none:
break
case .resumeConsumer(let continuation):
continuation?.resume(returning: nil)
}
}
}
}
@@ -48,7 +48,7 @@ final class CombineLatestStorage<
func next() async rethrows -> (Base1.Element, Base2.Element, Base3.Element?)? {
try await withTaskCancellationHandler {
let result = await withUnsafeContinuation { continuation in
self.stateMachine.withCriticalRegion { stateMachine in
let action: StateMachine.NextAction? = self.stateMachine.withCriticalRegion { stateMachine in
let action = stateMachine.next(for: continuation)
switch action {
case .startTask(let base1, let base2, let base3):
@@ -60,45 +60,65 @@ final class CombineLatestStorage<
base3: base3,
downstreamContinuation: continuation
)
return nil
case .resumeContinuation(let downstreamContinuation, let result):
downstreamContinuation.resume(returning: result)
case .resumeContinuation:
return action
case .resumeUpstreamContinuations(let upstreamContinuations):
// bases can be iterated over for 1 iteration so their next value can be retrieved
upstreamContinuations.forEach { $0.resume() }
case .resumeUpstreamContinuations:
return action
case .resumeDownstreamContinuationWithNil(let continuation):
// the async sequence is already finished, immediately resuming
continuation.resume(returning: .success(nil))
case .resumeDownstreamContinuationWithNil:
return action
}
}
switch action {
case .startTask:
// We are handling the startTask in the lock already because we want to avoid
// other inputs interleaving while starting the task
fatalError("Internal inconsistency")
case .resumeContinuation(let downstreamContinuation, let result):
downstreamContinuation.resume(returning: result)
case .resumeUpstreamContinuations(let upstreamContinuations):
// bases can be iterated over for 1 iteration so their next value can be retrieved
upstreamContinuations.forEach { $0.resume() }
case .resumeDownstreamContinuationWithNil(let continuation):
// the async sequence is already finished, immediately resuming
continuation.resume(returning: .success(nil))
case .none:
break
}
}
return try result._rethrowGet()
} onCancel: {
self.stateMachine.withCriticalRegion { stateMachine in
let action = stateMachine.cancelled()
let action = self.stateMachine.withCriticalRegion { stateMachine in
stateMachine.cancelled()
}
switch action {
case .resumeDownstreamContinuationWithNilAndCancelTaskAndUpstreamContinuations(
let downstreamContinuation,
let task,
let upstreamContinuations
):
upstreamContinuations.forEach { $0.resume(throwing: CancellationError()) }
task.cancel()
switch action {
case .resumeDownstreamContinuationWithNilAndCancelTaskAndUpstreamContinuations(
let downstreamContinuation,
let task,
let upstreamContinuations
):
upstreamContinuations.forEach { $0.resume(throwing: CancellationError()) }
task.cancel()
downstreamContinuation.resume(returning: .success(nil))
downstreamContinuation.resume(returning: .success(nil))
case .cancelTaskAndUpstreamContinuations(let task, let upstreamContinuations):
upstreamContinuations.forEach { $0.resume(throwing: CancellationError()) }
task.cancel()
case .cancelTaskAndUpstreamContinuations(let task, let upstreamContinuations):
upstreamContinuations.forEach { $0.resume(throwing: CancellationError()) }
task.cancel()
case .none:
break
}
case .none:
break
}
}
}
@@ -124,33 +144,33 @@ final class CombineLatestStorage<
// element from upstream. This continuation is only resumed
// if the downstream consumer called `next` to signal his demand.
try await withUnsafeThrowingContinuation { continuation in
self.stateMachine.withCriticalRegion { stateMachine in
let action = stateMachine.childTaskSuspended(baseIndex: 0, continuation: continuation)
let action = self.stateMachine.withCriticalRegion { stateMachine in
stateMachine.childTaskSuspended(baseIndex: 0, continuation: continuation)
}
switch action {
case .resumeContinuation(let upstreamContinuation):
upstreamContinuation.resume()
switch action {
case .resumeContinuation(let upstreamContinuation):
upstreamContinuation.resume()
case .resumeContinuationWithError(let upstreamContinuation, let error):
upstreamContinuation.resume(throwing: error)
case .resumeContinuationWithError(let upstreamContinuation, let error):
upstreamContinuation.resume(throwing: error)
case .none:
break
}
case .none:
break
}
}
if let element1 = try await base1Iterator.next() {
self.stateMachine.withCriticalRegion { stateMachine in
let action = stateMachine.elementProduced((element1, nil, nil))
let action = self.stateMachine.withCriticalRegion { stateMachine in
stateMachine.elementProduced((element1, nil, nil))
}
switch action {
case .resumeContinuation(let downstreamContinuation, let result):
downstreamContinuation.resume(returning: result)
switch action {
case .resumeContinuation(let downstreamContinuation, let result):
downstreamContinuation.resume(returning: result)
case .none:
break
}
case .none:
break
}
} else {
let action = self.stateMachine.withCriticalRegion { stateMachine in
@@ -191,33 +211,33 @@ final class CombineLatestStorage<
// element from upstream. This continuation is only resumed
// if the downstream consumer called `next` to signal his demand.
try await withUnsafeThrowingContinuation { continuation in
self.stateMachine.withCriticalRegion { stateMachine in
let action = stateMachine.childTaskSuspended(baseIndex: 1, continuation: continuation)
let action = self.stateMachine.withCriticalRegion { stateMachine in
stateMachine.childTaskSuspended(baseIndex: 1, continuation: continuation)
}
switch action {
case .resumeContinuation(let upstreamContinuation):
upstreamContinuation.resume()
switch action {
case .resumeContinuation(let upstreamContinuation):
upstreamContinuation.resume()
case .resumeContinuationWithError(let upstreamContinuation, let error):
upstreamContinuation.resume(throwing: error)
case .resumeContinuationWithError(let upstreamContinuation, let error):
upstreamContinuation.resume(throwing: error)
case .none:
break
}
case .none:
break
}
}
if let element2 = try await base1Iterator.next() {
self.stateMachine.withCriticalRegion { stateMachine in
let action = stateMachine.elementProduced((nil, element2, nil))
let action = self.stateMachine.withCriticalRegion { stateMachine in
stateMachine.elementProduced((nil, element2, nil))
}
switch action {
case .resumeContinuation(let downstreamContinuation, let result):
downstreamContinuation.resume(returning: result)
switch action {
case .resumeContinuation(let downstreamContinuation, let result):
downstreamContinuation.resume(returning: result)
case .none:
break
}
case .none:
break
}
} else {
let action = self.stateMachine.withCriticalRegion { stateMachine in
@@ -259,33 +279,33 @@ final class CombineLatestStorage<
// element from upstream. This continuation is only resumed
// if the downstream consumer called `next` to signal his demand.
try await withUnsafeThrowingContinuation { continuation in
self.stateMachine.withCriticalRegion { stateMachine in
let action = stateMachine.childTaskSuspended(baseIndex: 2, continuation: continuation)
let action = self.stateMachine.withCriticalRegion { stateMachine in
stateMachine.childTaskSuspended(baseIndex: 2, continuation: continuation)
}
switch action {
case .resumeContinuation(let upstreamContinuation):
upstreamContinuation.resume()
switch action {
case .resumeContinuation(let upstreamContinuation):
upstreamContinuation.resume()
case .resumeContinuationWithError(let upstreamContinuation, let error):
upstreamContinuation.resume(throwing: error)
case .resumeContinuationWithError(let upstreamContinuation, let error):
upstreamContinuation.resume(throwing: error)
case .none:
break
}
case .none:
break
}
}
if let element3 = try await base1Iterator.next() {
self.stateMachine.withCriticalRegion { stateMachine in
let action = stateMachine.elementProduced((nil, nil, element3))
let action = self.stateMachine.withCriticalRegion { stateMachine in
stateMachine.elementProduced((nil, nil, element3))
}
switch action {
case .resumeContinuation(let downstreamContinuation, let result):
downstreamContinuation.resume(returning: result)
switch action {
case .resumeContinuation(let downstreamContinuation, let result):
downstreamContinuation.resume(returning: result)
case .none:
break
}
case .none:
break
}
} else {
let action = self.stateMachine.withCriticalRegion { stateMachine in
@@ -323,28 +343,29 @@ final class CombineLatestStorage<
do {
try await group.next()
} catch {
// One of the upstream sequences threw an error
self.stateMachine.withCriticalRegion { stateMachine in
let action = stateMachine.upstreamThrew(error)
switch action {
case .cancelTaskAndUpstreamContinuations(let task, let upstreamContinuations):
upstreamContinuations.forEach { $0.resume(throwing: CancellationError()) }
task.cancel()
case .resumeContinuationWithErrorAndCancelTaskAndUpstreamContinuations(
let downstreamContinuation,
let error,
let task,
let upstreamContinuations
):
upstreamContinuations.forEach { $0.resume(throwing: CancellationError()) }
task.cancel()
downstreamContinuation.resume(returning: .failure(error))
case .none:
break
}
}
// One of the upstream sequences threw an error
let action = self.stateMachine.withCriticalRegion { stateMachine in
stateMachine.upstreamThrew(error)
}
group.cancelAll()
switch action {
case .cancelTaskAndUpstreamContinuations(let task, let upstreamContinuations):
upstreamContinuations.forEach { $0.resume(throwing: CancellationError()) }
task.cancel()
case .resumeContinuationWithErrorAndCancelTaskAndUpstreamContinuations(
let downstreamContinuation,
let error,
let task,
let upstreamContinuations
):
upstreamContinuations.forEach { $0.resume(throwing: CancellationError()) }
task.cancel()
downstreamContinuation.resume(returning: .failure(error))
case .none:
break
}
group.cancelAll()
}
}
}
@@ -55,36 +55,59 @@ final class DebounceStorage<Base: AsyncSequence & Sendable, C: Clock>: Sendable
// We always suspend since we can never return an element right away
let result: Result<Element?, Error> = await withUnsafeContinuation { continuation in
self.stateMachine.withCriticalRegion {
let action = $0.next(for: continuation)
let action: DebounceStateMachine<Base, C>.NextAction? = self.stateMachine.withCriticalRegion {
let action = $0.next(for: continuation)
switch action {
case .startTask(let base):
self.startTask(
stateMachine: &$0,
base: base,
downstreamContinuation: continuation
)
switch action {
case .startTask(let base):
self.startTask(
stateMachine: &$0,
base: base,
downstreamContinuation: continuation
)
return nil
case .resumeUpstreamContinuation(let upstreamContinuation):
// This is signalling the upstream task that is consuming the upstream
// sequence to signal demand.
upstreamContinuation?.resume(returning: ())
case .resumeUpstreamContinuation:
return action
case .resumeUpstreamAndClockContinuation(let upstreamContinuation, let clockContinuation, let deadline):
// This is signalling the upstream task that is consuming the upstream
// sequence to signal demand and start the clock task.
upstreamContinuation?.resume(returning: ())
clockContinuation?.resume(returning: deadline)
case .resumeUpstreamAndClockContinuation:
return action
case .resumeDownstreamContinuationWithNil(let continuation):
continuation.resume(returning: .success(nil))
case .resumeDownstreamContinuationWithNil:
return action
case .resumeDownstreamContinuationWithError(let continuation, let error):
continuation.resume(returning: .failure(error))
}
case .resumeDownstreamContinuationWithError:
return action
}
}
}
switch action {
case .startTask:
// We are handling the startTask in the lock already because we want to avoid
// other inputs interleaving while starting the task
fatalError("Internal inconsistency")
case .resumeUpstreamContinuation(let upstreamContinuation):
// This is signalling the upstream task that is consuming the upstream
// sequence to signal demand.
upstreamContinuation?.resume(returning: ())
case .resumeUpstreamAndClockContinuation(let upstreamContinuation, let clockContinuation, let deadline):
// This is signalling the upstream task that is consuming the upstream
// sequence to signal demand and start the clock task.
upstreamContinuation?.resume(returning: ())
clockContinuation?.resume(returning: deadline)
case .resumeDownstreamContinuationWithNil(let continuation):
continuation.resume(returning: .success(nil))
case .resumeDownstreamContinuationWithError(let continuation, let error):
continuation.resume(returning: .failure(error))
case .none:
break
}
}
return try result._rethrowGet()
} onCancel: {
@@ -258,37 +281,38 @@ final class DebounceStorage<Base: AsyncSequence & Sendable, C: Clock>: Sendable
do {
try await group.next()
} catch {
// One of the upstream sequences threw an error
self.stateMachine.withCriticalRegion { stateMachine in
let action = stateMachine.upstreamThrew(error)
switch action {
case .resumeContinuationWithErrorAndCancelTaskAndUpstreamContinuation(
let downstreamContinuation,
let error,
let task,
let upstreamContinuation,
let clockContinuation
):
upstreamContinuation?.resume(throwing: CancellationError())
clockContinuation?.resume(throwing: CancellationError())
task.cancel()
downstreamContinuation.resume(returning: .failure(error))
case .cancelTaskAndClockContinuation(
let task,
let clockContinuation
):
clockContinuation?.resume(throwing: CancellationError())
task.cancel()
case .none:
break
}
// One of the upstream sequences threw an error
let action = self.stateMachine.withCriticalRegion { stateMachine in
stateMachine.upstreamThrew(error)
}
group.cancelAll()
switch action {
case .resumeContinuationWithErrorAndCancelTaskAndUpstreamContinuation(
let downstreamContinuation,
let error,
let task,
let upstreamContinuation,
let clockContinuation
):
upstreamContinuation?.resume(throwing: CancellationError())
clockContinuation?.resume(throwing: CancellationError())
task.cancel()
downstreamContinuation.resume(returning: .failure(error))
case .cancelTaskAndClockContinuation(
let task,
let clockContinuation
):
clockContinuation?.resume(throwing: CancellationError())
task.cancel()
case .none:
break
}
}
group.cancelAll()
}
}
}
+154 -137
View File
@@ -39,7 +39,7 @@ final class ZipStorage<Base1: AsyncSequence, Base2: AsyncSequence, Base3: AsyncS
func next() async rethrows -> (Base1.Element, Base2.Element, Base3.Element?)? {
try await withTaskCancellationHandler {
let result = await withUnsafeContinuation { continuation in
self.stateMachine.withCriticalRegion { stateMachine in
let action: StateMachine.NextAction? = self.stateMachine.withCriticalRegion { stateMachine in
let action = stateMachine.next(for: continuation)
switch action {
case .startTask(let base1, let base2, let base3):
@@ -51,42 +51,59 @@ final class ZipStorage<Base1: AsyncSequence, Base2: AsyncSequence, Base3: AsyncS
base3: base3,
downstreamContinuation: continuation
)
return nil
case .resumeUpstreamContinuations(let upstreamContinuations):
// bases can be iterated over for 1 iteration so their next value can be retrieved
upstreamContinuations.forEach { $0.resume() }
case .resumeUpstreamContinuations:
return action
case .resumeDownstreamContinuationWithNil(let continuation):
// the async sequence is already finished, immediately resuming
continuation.resume(returning: .success(nil))
case .resumeDownstreamContinuationWithNil:
return action
}
}
switch action {
case .startTask:
// We are handling the startTask in the lock already because we want to avoid
// other inputs interleaving while starting the task
fatalError("Internal inconsistency")
case .resumeUpstreamContinuations(let upstreamContinuations):
// bases can be iterated over for 1 iteration so their next value can be retrieved
upstreamContinuations.forEach { $0.resume() }
case .resumeDownstreamContinuationWithNil(let continuation):
// the async sequence is already finished, immediately resuming
continuation.resume(returning: .success(nil))
case .none:
break
}
}
return try result._rethrowGet()
} onCancel: {
self.stateMachine.withCriticalRegion { stateMachine in
let action = stateMachine.cancelled()
let action = self.stateMachine.withCriticalRegion { stateMachine in
stateMachine.cancelled()
}
switch action {
case .resumeDownstreamContinuationWithNilAndCancelTaskAndUpstreamContinuations(
let downstreamContinuation,
let task,
let upstreamContinuations
):
upstreamContinuations.forEach { $0.resume(throwing: CancellationError()) }
task.cancel()
switch action {
case .resumeDownstreamContinuationWithNilAndCancelTaskAndUpstreamContinuations(
let downstreamContinuation,
let task,
let upstreamContinuations
):
upstreamContinuations.forEach { $0.resume(throwing: CancellationError()) }
task.cancel()
downstreamContinuation.resume(returning: .success(nil))
downstreamContinuation.resume(returning: .success(nil))
case .cancelTaskAndUpstreamContinuations(let task, let upstreamContinuations):
upstreamContinuations.forEach { $0.resume(throwing: CancellationError()) }
task.cancel()
case .cancelTaskAndUpstreamContinuations(let task, let upstreamContinuations):
upstreamContinuations.forEach { $0.resume(throwing: CancellationError()) }
task.cancel()
case .none:
break
}
case .none:
break
}
}
}
@@ -112,53 +129,53 @@ final class ZipStorage<Base1: AsyncSequence, Base2: AsyncSequence, Base3: AsyncS
// element from upstream. This continuation is only resumed
// if the downstream consumer called `next` to signal his demand.
try await withUnsafeThrowingContinuation { continuation in
self.stateMachine.withCriticalRegion { stateMachine in
let action = stateMachine.childTaskSuspended(baseIndex: 0, continuation: continuation)
let action = self.stateMachine.withCriticalRegion { stateMachine in
stateMachine.childTaskSuspended(baseIndex: 0, continuation: continuation)
}
switch action {
case .resumeContinuation(let upstreamContinuation):
upstreamContinuation.resume()
switch action {
case .resumeContinuation(let upstreamContinuation):
upstreamContinuation.resume()
case .resumeContinuationWithError(let upstreamContinuation, let error):
upstreamContinuation.resume(throwing: error)
case .resumeContinuationWithError(let upstreamContinuation, let error):
upstreamContinuation.resume(throwing: error)
case .none:
break
}
case .none:
break
}
}
if let element1 = try await base1Iterator.next() {
self.stateMachine.withCriticalRegion { stateMachine in
let action = stateMachine.elementProduced((element1, nil, nil))
let action = self.stateMachine.withCriticalRegion { stateMachine in
stateMachine.elementProduced((element1, nil, nil))
}
switch action {
case .resumeContinuation(let downstreamContinuation, let result):
downstreamContinuation.resume(returning: result)
switch action {
case .resumeContinuation(let downstreamContinuation, let result):
downstreamContinuation.resume(returning: result)
case .none:
break
}
case .none:
break
}
} else {
self.stateMachine.withCriticalRegion { stateMachine in
let action = stateMachine.upstreamFinished()
let action = self.stateMachine.withCriticalRegion { stateMachine in
stateMachine.upstreamFinished()
}
switch action {
case .resumeContinuationWithNilAndCancelTaskAndUpstreamContinuations(
let downstreamContinuation,
let task,
let upstreamContinuations
):
switch action {
case .resumeContinuationWithNilAndCancelTaskAndUpstreamContinuations(
let downstreamContinuation,
let task,
let upstreamContinuations
):
upstreamContinuations.forEach { $0.resume(throwing: CancellationError()) }
task.cancel()
upstreamContinuations.forEach { $0.resume(throwing: CancellationError()) }
task.cancel()
downstreamContinuation.resume(returning: .success(nil))
downstreamContinuation.resume(returning: .success(nil))
case .none:
break
}
case .none:
break
}
}
}
@@ -172,53 +189,53 @@ final class ZipStorage<Base1: AsyncSequence, Base2: AsyncSequence, Base3: AsyncS
// element from upstream. This continuation is only resumed
// if the downstream consumer called `next` to signal his demand.
try await withUnsafeThrowingContinuation { continuation in
self.stateMachine.withCriticalRegion { stateMachine in
let action = stateMachine.childTaskSuspended(baseIndex: 1, continuation: continuation)
let action = self.stateMachine.withCriticalRegion { stateMachine in
stateMachine.childTaskSuspended(baseIndex: 1, continuation: continuation)
}
switch action {
case .resumeContinuation(let upstreamContinuation):
upstreamContinuation.resume()
switch action {
case .resumeContinuation(let upstreamContinuation):
upstreamContinuation.resume()
case .resumeContinuationWithError(let upstreamContinuation, let error):
upstreamContinuation.resume(throwing: error)
case .resumeContinuationWithError(let upstreamContinuation, let error):
upstreamContinuation.resume(throwing: error)
case .none:
break
}
case .none:
break
}
}
if let element2 = try await base2Iterator.next() {
self.stateMachine.withCriticalRegion { stateMachine in
let action = stateMachine.elementProduced((nil, element2, nil))
let action = self.stateMachine.withCriticalRegion { stateMachine in
stateMachine.elementProduced((nil, element2, nil))
}
switch action {
case .resumeContinuation(let downstreamContinuation, let result):
downstreamContinuation.resume(returning: result)
switch action {
case .resumeContinuation(let downstreamContinuation, let result):
downstreamContinuation.resume(returning: result)
case .none:
break
}
case .none:
break
}
} else {
self.stateMachine.withCriticalRegion { stateMachine in
let action = stateMachine.upstreamFinished()
let action = self.stateMachine.withCriticalRegion { stateMachine in
stateMachine.upstreamFinished()
}
switch action {
case .resumeContinuationWithNilAndCancelTaskAndUpstreamContinuations(
let downstreamContinuation,
let task,
let upstreamContinuations
):
switch action {
case .resumeContinuationWithNilAndCancelTaskAndUpstreamContinuations(
let downstreamContinuation,
let task,
let upstreamContinuations
):
upstreamContinuations.forEach { $0.resume(throwing: CancellationError()) }
task.cancel()
upstreamContinuations.forEach { $0.resume(throwing: CancellationError()) }
task.cancel()
downstreamContinuation.resume(returning: .success(nil))
downstreamContinuation.resume(returning: .success(nil))
case .none:
break
}
case .none:
break
}
}
}
@@ -233,53 +250,53 @@ final class ZipStorage<Base1: AsyncSequence, Base2: AsyncSequence, Base3: AsyncS
// element from upstream. This continuation is only resumed
// if the downstream consumer called `next` to signal his demand.
try await withUnsafeThrowingContinuation { continuation in
self.stateMachine.withCriticalRegion { stateMachine in
let action = stateMachine.childTaskSuspended(baseIndex: 2, continuation: continuation)
let action = self.stateMachine.withCriticalRegion { stateMachine in
stateMachine.childTaskSuspended(baseIndex: 2, continuation: continuation)
}
switch action {
case .resumeContinuation(let upstreamContinuation):
upstreamContinuation.resume()
switch action {
case .resumeContinuation(let upstreamContinuation):
upstreamContinuation.resume()
case .resumeContinuationWithError(let upstreamContinuation, let error):
upstreamContinuation.resume(throwing: error)
case .resumeContinuationWithError(let upstreamContinuation, let error):
upstreamContinuation.resume(throwing: error)
case .none:
break
}
case .none:
break
}
}
if let element3 = try await base3Iterator.next() {
self.stateMachine.withCriticalRegion { stateMachine in
let action = stateMachine.elementProduced((nil, nil, element3))
let action = self.stateMachine.withCriticalRegion { stateMachine in
stateMachine.elementProduced((nil, nil, element3))
}
switch action {
case .resumeContinuation(let downstreamContinuation, let result):
downstreamContinuation.resume(returning: result)
switch action {
case .resumeContinuation(let downstreamContinuation, let result):
downstreamContinuation.resume(returning: result)
case .none:
break
}
case .none:
break
}
} else {
self.stateMachine.withCriticalRegion { stateMachine in
let action = stateMachine.upstreamFinished()
let action = self.stateMachine.withCriticalRegion { stateMachine in
stateMachine.upstreamFinished()
}
switch action {
case .resumeContinuationWithNilAndCancelTaskAndUpstreamContinuations(
let downstreamContinuation,
let task,
let upstreamContinuations
):
switch action {
case .resumeContinuationWithNilAndCancelTaskAndUpstreamContinuations(
let downstreamContinuation,
let task,
let upstreamContinuations
):
upstreamContinuations.forEach { $0.resume(throwing: CancellationError()) }
task.cancel()
upstreamContinuations.forEach { $0.resume(throwing: CancellationError()) }
task.cancel()
downstreamContinuation.resume(returning: .success(nil))
downstreamContinuation.resume(returning: .success(nil))
case .none:
break
}
case .none:
break
}
}
}
@@ -291,25 +308,25 @@ final class ZipStorage<Base1: AsyncSequence, Base2: AsyncSequence, Base3: AsyncS
try await group.next()
} catch {
// One of the upstream sequences threw an error
self.stateMachine.withCriticalRegion { stateMachine in
let action = stateMachine.upstreamThrew(error)
switch action {
case .resumeContinuationWithErrorAndCancelTaskAndUpstreamContinuations(
let downstreamContinuation,
let error,
let task,
let upstreamContinuations
):
upstreamContinuations.forEach { $0.resume(throwing: CancellationError()) }
task.cancel()
let action = self.stateMachine.withCriticalRegion { stateMachine in
stateMachine.upstreamThrew(error)
}
switch action {
case .resumeContinuationWithErrorAndCancelTaskAndUpstreamContinuations(
let downstreamContinuation,
let error,
let task,
let upstreamContinuations
):
upstreamContinuations.forEach { $0.resume(throwing: CancellationError()) }
task.cancel()
downstreamContinuation.resume(returning: .failure(error))
case .none:
break
}
}
downstreamContinuation.resume(returning: .failure(error))
case .none:
break
}
group.cancelAll()
group.cancelAll()
}
}
}